rafcode 1.0.0

package/RAF/013-dependencies-watchdog/outcomes/001-define-dependency-syntax.md

@@ -0,0 +1,56 @@
+# Outcome: Define Dependency Syntax in Plan Files
+
+## Summary
+
+Established the syntax and location for specifying task dependencies in plan markdown files. This is the foundational task for the dependencies watchdog feature.
+
+## Key Changes
+
+### 1. Updated Planning Prompt (`src/prompts/planning.ts`)
+- Added `## Dependencies` section to the plan file template structure
+- Section is optional and should be omitted if task has no dependencies
+- Format: comma-separated task IDs (e.g., "001, 002")
+- Includes clear instruction that dependent tasks are blocked if a dependency fails
+- Updated Important Rules to include dependency specification guidelines
+
+### 2. Updated Amend Prompt (`src/prompts/amend.ts`)
+- Added `## Dependencies` section to the plan file template structure
+- Added instruction to check existing plan files for dependencies when analyzing new requirements
+- Updated Important Rules to include dependency specification guidelines
+
+### 3. Updated CLAUDE.md Documentation
+- Added new "Plan File Structure" subsection under "RAF Project Structure"
+- Documents the complete plan file format including the optional Dependencies section
+- Explains the format and behavior of dependencies (task IDs, blocking on failure)
+
+## Dependency Syntax Specification
+
+```markdown
+## Dependencies
+001, 002
+```
+
+- **Location**: After `## Context`, before `## Requirements`
+- **Format**: Comma-separated list of task IDs (e.g., "001, 002")
+- **Optional**: Omit entirely if task has no dependencies
+- **Behavior**: If a dependency fails, dependent tasks are automatically blocked
+
+## Files Modified
+
+- `src/prompts/planning.ts` - Planning prompt template
+- `src/prompts/amend.ts` - Amendment prompt template
+- `CLAUDE.md` - Project documentation
+
+## Notes
+
+- This task only defines the syntax; parsing is handled in task 003
+- All tests pass (638/638)
+- TypeScript build succeeds with no errors
+
+<promise>COMPLETE</promise>
+
+
+## Details
+- Attempts: 1
+- Elapsed time: 2m 15s
+- Completed at: 2026-01-31T16:35:37.298Z

package/RAF/013-dependencies-watchdog/outcomes/002-update-planning-prompts.md

@@ -0,0 +1,60 @@
+# Outcome: Update Planning Prompts for Dependency Inference
+
+## Summary
+
+Updated the planning system prompt to instruct Claude to automatically infer and record task dependencies during project planning. The prompt now includes comprehensive guidance on task ordering, dependency identification, and circular dependency prevention.
+
+## Key Changes
+
+### 1. Updated Planning Prompt (`src/prompts/planning.ts`)
+
+**Step 1 Enhancement - Task Ordering:**
+- Renamed "Identify Tasks" to "Identify and Order Tasks"
+- Added CRITICAL section emphasizing logical execution order
+- Provided ordering guidelines: setup → core → integration → testing
+
+**New Step 4 - Dependency Inference:**
+- Added dedicated section for inferring task dependencies
+- Explained how to identify dependencies:
+  - Task B uses output/artifacts from task A
+  - Task B modifies code created by task A
+  - Task B tests functionality from task A
+  - Task B extends or builds upon task A
+- Provided format examples for single and multiple dependencies
+- Listed rules for proper dependency specification
+
+**Updated Important Rules:**
+- Rule 2: Create plans reflecting "logical execution order"
+- Rule 5: "Infer dependencies automatically - analyze task relationships, don't ask the user about dependencies"
+- Rule 6: "Only add Dependencies section when a task genuinely requires another to complete first"
+- Rule 7: "Dependencies must only reference lower-numbered tasks to prevent circular dependencies"
+
+### 2. Updated Test (`tests/unit/planning-prompt.test.ts`)
+- Updated test expectation to match new section title "Identify and Order Tasks"
+
+## Files Modified
+
+- `src/prompts/planning.ts` - Planning prompt with dependency inference instructions
+- `tests/unit/planning-prompt.test.ts` - Updated test for new section title
+
+## Acceptance Criteria Verification
+
+- [x] Planning prompt includes clear instructions for dependency inference (Step 4)
+- [x] Prompt explains to order tasks by logical execution order (Step 1 with CRITICAL guidance)
+- [x] Prompt includes example of Dependencies section format (both single and multiple dependencies)
+- [x] Prompt warns against circular dependencies (Rule 7 and Step 4 rules)
+- [x] Generated plans include appropriate Dependencies sections (template from task 001 + inference instructions)
+
+## Notes
+
+- Dependencies are inferred automatically by Claude during planning, not asked about
+- The "only reference lower-numbered tasks" rule structurally prevents circular dependencies
+- All 638 tests pass
+
+<promise>COMPLETE</promise>
+
+
+## Details
+- Attempts: 1
+- Elapsed time: 1m 58s
+- Completed at: 2026-01-31T16:37:35.541Z

package/RAF/013-dependencies-watchdog/outcomes/003-parse-dependencies-update-state.md

@@ -0,0 +1,81 @@
+# Outcome: Parse Dependencies and Update State Derivation
+
+## Summary
+
+Implemented dependency parsing from plan files and extended the state derivation system to support a new `blocked` status. Tasks are now automatically blocked when any of their dependencies have failed or are blocked (transitive blocking).
+
+## Key Changes
+
+### 1. Updated Types (`src/core/state-derivation.ts`)
+
+- **DerivedTaskStatus**: Added `'blocked'` to the union type (`'pending' | 'completed' | 'failed' | 'blocked'`)
+- **DerivedTask interface**: Added `dependencies: string[]` field to track task dependencies
+- **DerivedStats interface**: Added `blocked: number` field for statistics
+
+### 2. New Dependency Parser (`parseDependencies()`)
+
+Created function to extract dependencies from plan file content:
+- Looks for `## Dependencies` section followed by a line of comma-separated task IDs
+- Validates task IDs (must be 2-3 digit numbers)
+- Returns empty array if no Dependencies section exists
+
+### 3. Updated `parseOutcomeStatus()`
+
+- Extended regex to recognize `<promise>BLOCKED</promise>` marker
+- Uses switch statement for cleaner handling of COMPLETE/FAILED/BLOCKED
+
+### 4. Updated `deriveProjectState()`
+
+- **First pass**: Reads plan files to extract dependencies along with outcome statuses
+- **Second pass**: Derives blocked status using iterative algorithm for transitive blocking
+  - A task is blocked if ANY of its dependencies are failed or blocked
+  - Uses `while` loop to handle chains (e.g., A fails → B blocked → C blocked)
+
+### 5. Updated `getDerivedStats()`
+
+- Added `blocked: 0` initialization
+- Added case for `'blocked'` status in the switch statement
+
+### 6. Updated `getNextExecutableTask()`
+
+- Updated documentation to clarify that blocked tasks are skipped
+- No code change needed - blocked tasks already excluded since they don't match 'pending' or 'failed'
+
+## Files Modified
+
+- `src/core/state-derivation.ts` - Main implementation
+- `tests/unit/state-derivation.test.ts` - Added 21 new tests, updated existing tests
+
+## New Tests Added
+
+- `parseDependencies`: 7 tests (single/multiple dependencies, whitespace handling, invalid IDs, empty sections)
+- `parseOutcomeStatus`: 2 tests for BLOCKED marker
+- `deriveProjectState`: 6 tests for dependency parsing and blocked status derivation
+- `getNextPendingTask`: 1 test for skipping blocked tasks
+- `getNextExecutableTask`: 2 tests for blocked task handling
+- `getDerivedStats`: 1 test for blocked count
+- `isProjectComplete`: 1 test for blocked tasks
+- `hasProjectFailed`: 1 test for blocked vs failed distinction
+
+## Acceptance Criteria Verification
+
+- [x] DerivedTask includes dependencies array
+- [x] TaskStatus includes 'blocked'
+- [x] Dependencies correctly parsed from plan files
+- [x] Tasks with failed/blocked dependencies have status 'blocked'
+- [x] BLOCKED marker recognized in outcome files
+- [x] getNextExecutableTask() skips blocked tasks
+
+## Notes
+
+- Blocked status is derived, not persisted - calculated each time state is derived
+- Transitive blocking is handled through iterative algorithm
+- All 659 tests pass
+
+<promise>COMPLETE</promise>
+
+
+## Details
+- Attempts: 1
+- Elapsed time: 4m 50s
+- Completed at: 2026-01-31T16:42:26.156Z

package/RAF/013-dependencies-watchdog/outcomes/004-implement-dependency-checking-in-do.md

@@ -0,0 +1,116 @@
+# Outcome: Implement Dependency Checking in `raf do`
+
+## Summary
+
+Updated the `raf do` command to detect blocked tasks and automatically create blocked outcome files instead of attempting execution. When a task's dependencies fail, the task is marked as blocked and skipped, with a proper outcome file generated explaining which dependencies caused the block.
+
+## Key Changes
+
+### 1. Updated Terminal Symbols (`src/utils/terminal-symbols.ts`)
+
+- **Added `blocked` symbol**: `⊘` for blocked tasks
+- **Updated `TaskStatus` type**: Added `'blocked'` to union type
+- **Updated `formatSummary()`**:
+  - Added optional `blocked` parameter (default 0)
+  - Summary now shows blocked count separately: "3/5 (1 failed, 2 blocked)"
+  - Blocked counts are included in the total
+
+### 2. Updated Do Command (`src/commands/do.ts`)
+
+**New Function: `getNextTaskToProcess()`**
+- Replaces `getNextTask()` to handle blocked tasks
+- First checks for blocked tasks that need outcome files generated
+- Then returns next executable task (pending or failed)
+
+**New Function: `generateBlockedOutcome()`**
+- Creates structured blocked outcome file content
+- Lists failed and blocked dependencies
+- Includes resolution instructions
+- Ends with `<promise>BLOCKED</promise>` marker
+
+**Task Loop Updates**
+- Detects blocked tasks and handles them separately
+- Skips Claude execution for blocked tasks entirely
+- Generates blocked outcome file via `projectManager.saveOutcome()`
+- Shows console output: "Task X blocked by failed dependency: Y"
+- Re-derives state after each blocked task to cascade blocking
+
+**Summary Output Updates**
+- Verbose mode: Shows blocked count in summary
+- Minimal mode: Passes blocked count to `formatSummary()`
+
+### 3. New Tests (`tests/unit/do-blocked-tasks.test.ts`)
+
+Added 12 new tests covering:
+- Blocked task detection when dependency fails
+- Cascading blocking through multiple tasks
+- Non-blocking when dependency succeeds
+- Blocking with multiple dependencies (one fails)
+- `getNextExecutableTask` skipping blocked tasks
+- `getDerivedStats` counting blocked separately
+- `isProjectComplete` with blocked tasks
+- `hasProjectFailed` distinguishing blocked from failed
+- BLOCKED marker recognition in outcome files
+
+### 4. Updated Terminal Symbols Tests (`tests/unit/terminal-symbols.test.ts`)
+
+- Added test for `blocked` symbol
+- Updated SYMBOLS test to include `blocked`
+- Added tests for `formatTaskProgress` with blocked status
+- Added tests for `formatSummary` with blocked tasks (single, multiple, combined with failures)
+- Added test for `formatProgressBar` with blocked status
+
+## Blocked Outcome File Format
+
+```markdown
+# Outcome: Task 002 Blocked
+
+## Summary
+
+This task was automatically blocked because one or more of its dependencies failed or are blocked.
+
+## Blocking Dependencies
+
+**Failed dependencies**: 001
+**Blocked dependencies**: (if any)
+
+**Task dependencies**: 001
+
+## Resolution
+
+To unblock this task:
+1. Fix the failed dependency task(s)
+2. Re-run the project with `raf do`
+
+<promise>BLOCKED</promise>
+```
+
+## Files Modified
+
+- `src/commands/do.ts` - Main implementation
+- `src/utils/terminal-symbols.ts` - Blocked symbol and formatSummary updates
+- `tests/unit/do-blocked-tasks.test.ts` - New test file (12 tests)
+- `tests/unit/terminal-symbols.test.ts` - Updated tests for blocked status
+
+## Acceptance Criteria Verification
+
+- [x] Blocked tasks are detected and skipped
+- [x] Blocked outcome file created with proper format and BLOCKED marker
+- [x] Console shows clear blocked message with dependency info
+- [x] Blocking cascades properly (if 001 fails, 002 blocked, 003 depends on 002 also blocked)
+- [x] Summary shows blocked tasks separately from failed
+- [x] No Claude execution attempted for blocked tasks
+
+## Test Results
+
+- All 677 tests pass
+- 12 new tests for blocked task handling
+- 6 updated tests for terminal symbols
+
+<promise>COMPLETE</promise>
+
+
+## Details
+- Attempts: 1
+- Elapsed time: 4m 20s
+- Completed at: 2026-01-31T16:46:46.254Z

package/RAF/013-dependencies-watchdog/outcomes/005-update-execution-prompts.md

@@ -0,0 +1,75 @@
+# Outcome: Update Execution Prompts with Dependency Context
+
+## Summary
+
+Updated the execution system prompt to include outcome summaries of completed dependency tasks, providing Claude with full context when executing tasks that depend on other tasks. This enables Claude to understand and build upon previous work effectively.
+
+## Key Changes
+
+### 1. Added `summarizeOutcome()` function (`src/prompts/execution.ts`)
+
+Created a helper function to manage context size for dependency outcomes:
+- Returns content as-is if under 4000 characters
+- Extracts just the Summary section for longer outcomes
+- Falls back to truncation at a reasonable break point (newline or period)
+- Appends "[Outcome truncated for context size]" indicator when truncated
+
+### 2. Extended `ExecutionPromptParams` interface (`src/prompts/execution.ts`)
+
+Added two new optional parameters:
+- `dependencyIds?: string[]` - Task IDs that this task depends on
+- `dependencyOutcomes?: Array<{ taskId: string; content: string }>` - Outcomes of dependency tasks
+
+### 3. Updated `getExecutionPrompt()` function (`src/prompts/execution.ts`)
+
+Added generation of "## Dependency Context" section:
+- Only included when task has both dependencies AND dependency outcomes
+- Lists all dependency IDs
+- Shows each dependency outcome with task ID header
+- Explains purpose: "Review their outcomes to understand what was accomplished and build upon their work"
+- Placed before the existing "Previous Task Outcomes" section
+
+### 4. Updated `do.ts` to pass dependency info (`src/commands/do.ts`)
+
+- Extracts `dependencyIds` from the current task's `dependencies` array
+- Filters `previousOutcomes` to get only outcomes for dependency tasks
+- Passes both `dependencyIds` and `dependencyOutcomes` to the execution prompt
+
+### 5. Added comprehensive tests (`tests/unit/execution-prompt.test.ts`)
+
+Added 11 new tests covering:
+- No dependency context when task has no dependencies
+- No dependency context when dependencyIds is empty
+- No dependency context when dependencyOutcomes is empty
+- Dependency context included with proper formatting
+- Multiple dependency outcomes
+- Purpose explanation text
+- Correct ordering (dependency context before previous outcomes)
+- `summarizeOutcome` function behavior (4 tests)
+
+## Files Modified
+
+- `src/prompts/execution.ts` - Added summarizeOutcome function, extended params, added dependency context section
+- `src/commands/do.ts` - Pass dependency info to execution prompt
+- `tests/unit/execution-prompt.test.ts` - Added 11 new tests
+
+## Acceptance Criteria Verification
+
+- [x] Execution prompt includes dependency context section when task has dependencies
+- [x] Dependency outcomes clearly labeled by task ID (e.g., "### Task 001")
+- [x] Claude receives useful context about what dependencies accomplished
+- [x] Tasks without dependencies have no extra context section
+- [x] Context size remains reasonable (summarize if needed) - MAX_DEPENDENCY_OUTCOME_CHARS = 4000
+
+## Test Results
+
+- All 688 tests pass
+- 11 new tests added for dependency context functionality
+
+<promise>COMPLETE</promise>
+
+
+## Details
+- Attempts: 1
+- Elapsed time: 3m 47s
+- Completed at: 2026-01-31T16:50:33.800Z

package/RAF/013-dependencies-watchdog/outcomes/006-add-tests.md

@@ -0,0 +1,100 @@
+# Outcome: Add Tests for Dependency Features
+
+## Summary
+
+Added comprehensive integration tests for the dependency watchdog feature to ensure reliable behavior across all dependency-related functionality. The previous tasks (001-005) had already added unit tests for their specific features, so this task focused on creating a comprehensive integration test that verifies the full end-to-end dependency blocking workflow.
+
+## Key Changes
+
+### 1. New Integration Test File (`tests/unit/dependency-integration.test.ts`)
+
+Created 20 new integration tests covering:
+
+**Complete Dependency Chain Simulation (7 tests)**
+- Simulates a real project with complex dependency structure:
+  ```
+  001-setup (no deps)
+  002-core (depends on 001)
+  003-api (depends on 001, 002)
+  004-tests (depends on 003)
+  005-docs (depends on 003)
+  006-deploy (depends on 004, 005)
+  ```
+- Tests initial state derivation with all tasks pending
+- Tests cascade blocking when task 001 fails (all 5 dependent tasks blocked)
+- Tests cascade blocking when task 002 fails (001 completed)
+- Tests cascade blocking when task 003 fails (001, 002 completed)
+- Tests partial failure in parallel branches (004 succeeds, 005 fails)
+- Tests project completion when all tasks succeed
+
+**getNextExecutableTask with Complex States (3 tests)**
+- Skip blocked tasks and find next available pending task
+- Return failed task for retry when no pending tasks exist
+- Return null when all tasks are blocked with no failed tasks to retry
+
+**Execution Prompt with Dependency Context (2 tests)**
+- Include dependency outcomes in execution prompt
+- Include multiple dependency outcomes
+
+**BLOCKED Outcome File Recognition (3 tests)**
+- Recognize BLOCKED marker and set status to blocked
+- Parse BLOCKED marker correctly
+- Handle mixed markers using last one
+
+**Edge Cases (5 tests)**
+- Handle circular dependency detection (prevented by lower-ID rule)
+- Handle dependency on non-existent task gracefully
+- Handle self-dependency gracefully
+- Handle empty project gracefully
+- Handle task with all dependencies completed
+
+## Test Coverage Summary
+
+| File | Statements | Branches | Functions | Lines |
+|------|-----------|----------|-----------|-------|
+| state-derivation.ts | 99.18% | 98.18% | 100% | 99.14% |
+| execution.ts | 96.87% | 95% | 100% | 96.87% |
+
+Both files exceed the 80% coverage requirement.
+
+## Files Modified
+
+- `tests/unit/dependency-integration.test.ts` - New file with 20 integration tests
+
+## Existing Tests Summary (Added by Previous Tasks)
+
+**Task 003 - `tests/unit/state-derivation.test.ts`**:
+- 7 tests for `parseDependencies`
+- 2 tests for `parseOutcomeStatus` with BLOCKED marker
+- 6 tests for `deriveProjectState` with dependencies and blocking
+
+**Task 004 - `tests/unit/do-blocked-tasks.test.ts`**:
+- 12 tests for blocked task handling in the do command
+
+**Task 004 - `tests/unit/terminal-symbols.test.ts`**:
+- 6 tests for blocked symbol and formatSummary
+
+**Task 005 - `tests/unit/execution-prompt.test.ts`**:
+- 11 tests for dependency context in execution prompts
+
+## Acceptance Criteria Verification
+
+- [x] Dependency parsing tests pass (7 tests in state-derivation.test.ts)
+- [x] Blocked status derivation tests pass (multiple test files)
+- [x] getNextExecutableTask tests cover blocked scenarios (state-derivation.test.ts, do-blocked-tasks.test.ts, dependency-integration.test.ts)
+- [x] Prompt generation tests verify dependency context (execution-prompt.test.ts, dependency-integration.test.ts)
+- [x] All new code has >80% test coverage (state-derivation: 99%, execution: 97%)
+- [x] Tests follow existing patterns in the codebase
+
+## Test Results
+
+- All 708 tests pass (20 new tests added)
+- Test run time: ~1s
+
+<promise>COMPLETE</promise>
+
+
+## Details
+- Attempts: 1
+- Elapsed time: 3m 46s
+- Completed at: 2026-01-31T16:54:20.311Z

package/RAF/013-dependencies-watchdog/outcomes/007-add-act-alias.md

@@ -0,0 +1,46 @@
+# Outcome: Add 'act' Alias for 'do' Command
+
+## Summary
+
+Added `act` as a complete alias for the `raf do` command, allowing users to run `raf act` instead of `raf do`. This is a simple one-line change using Commander.js's built-in `.alias()` method.
+
+## Key Changes
+
+### 1. Updated `src/commands/do.ts`
+
+Added `.alias('act')` to the command definition chain:
+
+```typescript
+const command = new Command('do')
+  .description('Execute planned tasks for one or more projects')
+  .alias('act')  // Added this line
+  .argument('[projects...]', ...)
+```
+
+## Verification
+
+- **Build**: TypeScript compiles successfully
+- **Tests**: All 708 tests pass
+- **Help output**:
+  - `raf --help` shows `do|act [options] [projects...]`
+  - `raf do --help` and `raf act --help` show identical options
+  - All flags (`-t`, `-v`, `-d`, `-f`, `-m`, `--sonnet`) work with both commands
+
+## Files Modified
+
+- `src/commands/do.ts` - Added `.alias('act')` to command definition
+
+## Acceptance Criteria Verification
+
+- [x] `raf act <project>` executes tasks just like `raf do <project>`
+- [x] `raf act --help` shows the same options as `raf do --help`
+- [x] All flags (`-m`, `--sonnet`, `-y`, `--retries`, etc.) work with `raf act`
+- [x] `raf --help` shows `act` as an alias (displayed as `do|act`)
+
+<promise>COMPLETE</promise>
+
+
+## Details
+- Attempts: 1
+- Elapsed time: 1m 1s
+- Completed at: 2026-01-31T16:55:21.347Z

package/RAF/013-dependencies-watchdog/outcomes/008-add-exit-message.md

@@ -0,0 +1,52 @@
+# Outcome: Add Exit Instructions After Planning
+
+## Summary
+
+Added clear exit instructions to both planning and amendment prompts. After Claude completes plan creation, users now see a message explaining how to exit the Claude session (Ctrl-C twice) and how to run their tasks.
+
+## Key Changes
+
+### 1. Updated Planning Prompt (`src/prompts/planning.ts`)
+
+Updated Step 5: Confirm Completion to include:
+- Summary of created tasks (existing)
+- Exit message with Ctrl-C instructions and `raf do <project>` command
+
+### 2. Updated Amendment Prompt (`src/prompts/amend.ts`)
+
+Updated Step 5: Confirm Completion to include:
+- Summary of new tasks, relationships, and total count (existing)
+- Exit message with Ctrl-C instructions and `raf do <project>` command
+
+## Exit Message Format
+
+```
+Planning complete! To exit this session and run your tasks:
+  1. Press Ctrl-C twice to exit
+  2. Then run: raf do <project>
+```
+
+## Files Modified
+
+- `src/prompts/planning.ts` - Added exit instructions to Step 5
+- `src/prompts/amend.ts` - Added exit instructions to Step 5
+
+## Acceptance Criteria Verification
+
+- [x] After `raf plan` completes, Claude displays exit instructions
+- [x] After `raf plan --amend` completes, Claude displays exit instructions
+- [x] Message is clear and actionable
+- [x] Message uses generic `<project>` placeholder (not actual project name)
+
+## Test Results
+
+- All 708 tests pass
+- No regressions introduced
+
+<promise>COMPLETE</promise>
+
+
+## Details
+- Attempts: 1
+- Elapsed time: 1m 37s
+- Completed at: 2026-01-31T16:56:58.718Z

package/RAF/013-dependencies-watchdog/plans/001-define-dependency-syntax.md

@@ -0,0 +1,32 @@
+# Task: Define Dependency Syntax in Plan Files
+
+## Objective
+Establish the syntax and location for specifying task dependencies in plan markdown files.
+
+## Context
+Tasks in RAF can depend on other tasks. When a dependency fails, dependent tasks should be blocked. This task defines how dependencies are expressed in plan files, which is foundational for the entire feature.
+
+## Dependencies
+None - this is the foundational task.
+
+## Requirements
+- Dependencies use task IDs only (e.g., `001`, `002`) - not full task names
+- Add a new `## Dependencies` section after `## Context`, before `## Requirements`
+- Section is optional - tasks without dependencies omit it
+- Multiple dependencies are comma-separated
+- Dependencies must reference task IDs that exist in the same project
+
+## Implementation Steps
+1. Update the plan file template in `src/prompts/planning.ts` to include the optional Dependencies section
+2. Document the new section format in the plan structure comment/documentation
+3. Update the amend prompt in `src/prompts/amend.ts` to show dependencies for existing tasks
+
+## Acceptance Criteria
+- [ ] Planning prompt template includes Dependencies section with clear format instructions
+- [ ] Amend prompt displays dependencies when showing existing tasks
+- [ ] Documentation in CLAUDE.md updated to reflect new plan structure
+
+## Notes
+- The Dependencies section is optional - first tasks typically have none
+- Format: `## Dependencies\n001, 002` (simple comma-separated list)
+- This task only defines syntax; parsing is handled in task 003

package/RAF/013-dependencies-watchdog/plans/002-update-planning-prompts.md

@@ -0,0 +1,38 @@
+# Task: Update Planning Prompts for Dependency Inference
+
+## Objective
+Modify the planning system prompt so Claude automatically infers and records task dependencies during project planning.
+
+## Context
+When Claude breaks down a project into tasks, it should analyze relationships between tasks and specify dependencies. This enables the execution engine to properly handle task failures by blocking dependent tasks.
+
+## Dependencies
+001
+
+## Requirements
+- Claude should automatically infer dependencies from task relationships (not ask user)
+- Tasks must be ordered in suggested execution order (lower numbers first)
+- Circular dependencies must be avoided through proper task ordering
+- Dependencies section added to each plan file that has dependencies
+- Planning prompt must instruct Claude on dependency inference logic
+
+## Implementation Steps
+1. Update `src/prompts/planning.ts` system prompt with dependency inference instructions:
+   - Explain what dependencies are and why they matter
+   - Instruct Claude to order tasks by execution order
+   - Instruct Claude to add Dependencies section listing prerequisite task IDs
+   - Warn against circular dependencies
+2. Update the plan file template to show Dependencies section format
+3. Add examples of proper dependency specification to the prompt
+
+## Acceptance Criteria
+- [ ] Planning prompt includes clear instructions for dependency inference
+- [ ] Prompt explains to order tasks by logical execution order
+- [ ] Prompt includes example of Dependencies section format
+- [ ] Prompt warns against circular dependencies
+- [ ] Generated plans include appropriate Dependencies sections
+
+## Notes
+- Dependencies are inferred, not asked about - this keeps planning efficient
+- Claude should use its judgment about what tasks require others to complete first
+- Common patterns: setup before implementation, implementation before testing, core before extensions