# Context-Aware Planning Workflow for folder-mcp
## 🔄 Two-Command Enhanced Workflow
This workflow uses two commands for streamlined development with embedded architectural enforcement:
1. **`/create-phase-plan`** - Creates phase overview
2. **`/create-task-plan`** - Creates comprehensive task plans with embedded execution guidance and mandatory DI patterns
```mermaid
graph TD
A[folder-mcp-roadmap-1.1.md] -->|/create-phase-plan 6| B[Phase-6-plan.md]
B -->|/create-task-plan 6 1| C[Phase-6-Task-1.md with Embedded DI Guidance]
C -->|Follow Embedded Execution Guidance| D[Implementation with Mandatory DI Validation]
D -->|Human Verification| E[✅ Task 1 Complete]
E -->|/create-task-plan 6 2| F[Phase-6-Task-2.md with Embedded DI Guidance]
F -->|Follow Embedded Execution Guidance| G[Implementation with Mandatory DI Validation]
G -->|Human Verification| H[✅ Task 2 Complete]
E --> I[Update Phase Plan Progress]
H --> I
I --> J[Linear Progress: 2/11 Tasks Complete]
```
## 📋 How It Works
### Step 1: Create Phase Plan
```bash
/create-phase-plan 6
```
This generates a **high-level overview** with:
- All tasks listed with complexity estimates
- Phase-wide context and goals
- Progress tracking for the entire phase
- Links to create individual task plans
### Step 2: Create Enhanced Task Plans (As Needed)
```bash
/create-task-plan 6 1 # For Configuration System Foundation
/create-task-plan 6 2 # For Basic Daemon Architecture
# etc...
```
Each generates a **comprehensive implementation plan** with:
- Specific implementation assignments with embedded DI patterns
- Mandatory architectural validation after every assignment
- Living document progress tracking requirements
- Exact code locations and DI structure requirements
- Built-in module boundary enforcement
## 📊 Measurable Linear Progress
Since all work is sequential, progress is clearly measurable:
- **Phase Progress**: X/Y tasks complete (e.g., 3/11 = 27%)
- **Task Progress**: X/Y assignments complete (e.g., 2/5 = 40%)
- **Time Tracking**: Actual vs estimated for each task
- **Clear Handoffs**: Each task completion enables the next
No parallel work means:
- Simple progress tracking
- Clear dependencies
- No coordination overhead
- Predictable timeline
## 📊 Example: Phase 6 Linear Workflow
### 1. Generate Phase Plan
```bash
/create-phase-plan 6
```
Creates: `Phase-6-Configuration-Foundation-plan.md` with:
- 11 tasks in sequential order
- Linear progress tracking (0/11)
- Clear task sequence
- Overall timeline estimate
### 2. Start First Task
```bash
/create-task-plan 6 1
```
Creates: `Phase-6-Task-1-Configuration-System.md` with:
- Sequential implementation assignments
- Must complete Assignment 1 before 2, etc.
- Progress shown as percentage complete
- ~8-10 implementation steps in order
### 3. Follow Embedded Execution Guidance
The task plan now contains **all execution guidance embedded within**:
- **Mandatory DI patterns** visible in every assignment
- **Validation checklists** after each assignment
- **Living document requirements** built into progress tracking
- **Module boundary enforcement** throughout implementation
- **Human verification checklist** at task completion
### 4. Human Verification
- Review AI summary
- Run verification commands
- Check architecture
- Sign off on completion
### 5. Move to Next Task
```bash
/create-task-plan 6 2 # Only after Task 1 is verified complete
```
**Linear Progress Visualization**:
```
Phase 6: [██░░░░░░░░░] 2/11 Tasks (18%)
Task 2: [████░░░░░░] 2/5 Assignments (40%)
```
## 🔧 Command Locations
Place these files in your project:
```
folder-mcp/
├── .claude/
│ └── commands/
│ ├── create-phase-plan.md
│ └── create-task-plan.md # Enhanced with embedded execution guidance
├── folder-mcp-roadmap-1.1.md
├── IMPLEMENTATION-METHODOLOGY.md
└── [Your implementation plans will be generated here]
```
## 💡 Usage Tips for Linear Workflow
1. **Complete Tasks Sequentially**: Never start Task N+1 until Task N is 100% complete
2. **Track Progress Linearly**: Update percentage complete after each assignment
3. **Create Task Plans One at a Time**: Generate task plan only when ready to start that task
4. **Follow Embedded Validation**: Each assignment includes mandatory DI validation checklists
5. **Commit at Milestones**: Clear git history showing linear progression
## 🚀 Getting Started
1. Create the `.claude/commands/` directory
2. Save both command files there
3. Run `/create-phase-plan 6` to start with Phase 6
4. Run `/create-task-plan 6 1` when ready to implement first task
The enhanced `/create-task-plan` command will automatically:
- Extract all relevant information from your roadmap
- Structure it into actionable plans with embedded DI patterns
- Include mandatory validation checklists after every assignment
- Provide comprehensive architectural enforcement throughout
- Build in living document requirements for progress tracking
## 🚨 Enhanced Quality Gates
Every task plan now includes **MANDATORY ARCHITECTURAL ENFORCEMENT**:
1. **DI Patterns Embedded Throughout**
- Interface → Implementation → Registration pattern in every assignment
- Constructor injection requirements with validation commands
- Module boundary checks after each step
- Zero direct instantiation enforcement
2. **Comprehensive Validation After Every Assignment**
- TypeScript build validation (zero errors required)
- DI pattern compliance checks
- Module boundary verification
- Integration test requirements
3. **Living Document Progress Tracking**
- Built-in progress tracking templates
- Discovery documentation requirements
- Time tracking and completion status
- Human verification checklists embedded
4. **Architectural Consistency Throughout Long Sessions**
- DI patterns visible in every assignment (prevents architectural drift)
- Validation steps prevent progression with violations
- Module boundary enforcement prevents coupling
These requirements are now **embedded within each task plan** to ensure visibility and compliance during long implementation sessions.
Complete Folder Structure for folder-mcp
📁 Project Structure with Context Engineering
folder-mcp/
├── .claude/ # Claude-specific files
│ └── commands/ # Slash commands
│ ├── create-phase-plan.md # Creates phase overview
│ └── create-task-plan.md # Creates comprehensive task plans with embedded execution guidance
│
├── docs/ # All documentation
│ ├── development-plan/ # Development planning
│ │ ├── methodology/ # Development methodologies
│ │ │ ├── IMPLEMENTATION-METHODOLOGY.md
│ │ │ ├── USEFUL-PROMPTS.md
│ │ │ └── context-aware-workflow.md
│ │ └── roadmap/ # Project roadmap
│ │ ├── completed/ # Completed implementation docs
│ │ │ ├── 0.endpoints-cleanup.md
│ │ │ ├── 1.mcp-endpoint-redesign.md
│ │ │ ├── 2.robust-real-folder-oriented-tests-implementation.md
│ │ │ ├── 3.tui-design-and-implementation-plan.md
│ │ │ ├── 4.tui-components-development.md
│ │ │ └── 5.tui-eliminate-all-dev-errors.md
│ │ ├── currently-implementing/
│ │ │ └── 6.configuration-foundation-CLI-TUI-parity.md
│ │ └── folder-mcp-roadmap-1.1.md
│ │
│ └── (other docs folders as needed)
│
├── src/ # Source code with DI structure
│ ├── domain/ # Interfaces only
│ │ └── config/
│ │ └── IConfigurationManager.ts
│ │
│ ├── application/ # Business logic
│ │ └── config/
│ │ └── ConfigurationManager.ts
│ │
│ ├── infrastructure/ # External dependencies
│ │ └── config/
│ │ └── YamlFileLoader.ts
│ │
│ └── di/ # Dependency injection
│ └── container.ts # All service registrations
│
└── tests/ # Test files
├── unit/
├── integration/
└── e2e/
🔄 Workflow with Folder Structure
1. **Roadmap Reference**
- Main roadmap: `docs/development-plan/roadmap/folder-mcp-roadmap-1.1.md`
- Currently implementing: `docs/development-plan/roadmap/currently-implementing/`
- Completed tasks: `docs/development-plan/roadmap/completed/`
2. **Create Implementation Plans** (if using PRP approach)
- Plans would be generated in a designated folder
- Follow task plans in the roadmap structure
3. **After Completion**
- Completed tasks are already organized in `docs/development-plan/roadmap/completed/`
- Update current task status
- Continue to next task
📝 Key Points
- Roadmap and completed tasks live in `docs/development-plan/roadmap/`
- Methodology docs are in `docs/development-plan/methodology/`
- Source code follows strict DI structure (domain → application → infrastructure)
- Slash commands live in `.claude/commands/`
This structure keeps everything organized with:
- Clear separation of planning vs implementation
- Completed work already tracked in roadmap structure
- Methodologies grouped together
- Natural task progression tracking
