@codyswann/lisa 1.0.5 → 1.0.9

package/all/copy-overwrite/.claude/commands/project/add-test-coverage.md

@@ -1,6 +1,6 @@
 ---
 description: Increase test coverage to a specified threshold percentage
-allowed-tools: Read, Write, Edit, Bash, Task, TaskCreate, TaskUpdate, TaskList, TaskGet
+allowed-tools: Read, Bash, Glob, Grep
 argument-hint: <threshold-percentage>
 model: sonnet
 ---
@@ -11,48 +11,47 @@ Target threshold: $ARGUMENTS%
 
 If no argument provided, prompt the user for a target.
 
-## Process
+## Step 1: Gather Requirements
 
-### Step 0: Check Project Context
+1. **Find coverage config** (jest.config.js, vitest.config.ts, .nycrc, etc.)
+2. **Run coverage report** to get current state:
+   ```bash
+   bun run test:cov 2>&1 | head -100
+   ```
+3. **Identify the 20 files with lowest coverage**, noting:
+   - File path
+   - Current coverage % (lines, branches, functions)
+   - Which lines/branches are uncovered
 
-Check if there's an active project for task syncing:
+## Step 2: Generate Brief
 
-```bash
-cat .claude-active-project 2>/dev/null
-```
-
-If a project is active, include `metadata: { "project": "<project-name>" }` in all TaskCreate calls.
-
-### Step 1: Locate Configuration
-
-Find the test coverage config (jest.config.js, vitest.config.ts, .nycrc, etc.).
-
-### Step 2: Update Thresholds
-
-Set any threshold below $ARGUMENTS% to $ARGUMENTS% (line, branch, function, statement).
+Compile findings into a detailed brief:
 
-### Step 3: Identify Gaps
-
-Run coverage and identify the **20 files** with the lowest coverage.
-
-### Step 4: Create Task List
-
-Create a task for each file needing test coverage, ordered by coverage gap (lowest first).
+```
+Increase test coverage from [current]% to $ARGUMENTS%.
 
-Each task should have:
-- **subject**: "Add test coverage for [file]" (imperative form)
-- **description**: File path, current coverage %, target threshold, notes about uncovered lines/branches
-- **activeForm**: "Adding tests for [file]" (present continuous)
-- **metadata**: `{ "project": "<active-project>" }` if project context exists
+## Files Needing Coverage (ordered by coverage gap)
 
-### Step 5: Parallel Execution
+1. src/services/user.ts - 23% coverage (target: $ARGUMENTS%)
+   - Uncovered: lines 45-67, 89-102
+   - Missing branch coverage: lines 34, 56
+2. src/utils/helpers.ts - 34% coverage (target: $ARGUMENTS%)
+   - Uncovered: lines 12-45
+...
 
-Launch **up to 5 sub-agents** using the `test-coverage-agent` subagent to add tests in parallel.
+## Configuration
+- Config file: [path to coverage config]
+- Update thresholds to $ARGUMENTS% for: lines, branches, functions, statements
 
-### Step 6: Iterate
+## Acceptance Criteria
+- All files meet $ARGUMENTS% coverage threshold
+- `bun run test:cov` passes with no threshold violations
 
-Check for remaining pending tasks. Re-run coverage to verify.
+## Verification
+Command: `bun run test:cov`
+Expected: All thresholds pass at $ARGUMENTS%
+```
 
-If thresholds aren't met, repeat from Step 3.
+## Step 3: Bootstrap Project
 
-Continue until all thresholds meet or exceed $ARGUMENTS%.
+Run `/project:bootstrap` with the generated brief as a text prompt.

package/all/copy-overwrite/.claude/commands/project/archive.md

@@ -5,4 +5,5 @@ allowed-tools: Read, Write, Bash(git*), Glob, Grep, Task, TaskCreate, TaskUpdate
 ---
 
 1. Move $ARGUMENTS to `projects/archive`
-2. run /git:commit-and-submit-pr
+2. Clear the active project marker: `rm -f .claude-active-project`
+3. run /git:commit-and-submit-pr

package/all/copy-overwrite/.claude/commands/project/bootstrap.md

@@ -1,49 +1,44 @@
 ---
 description: Automated project setup and research with gap detection
-argument-hint: <project-brief-file-or-jira-issue-number>
+argument-hint: <file-path|jira-issue|"text description">
 ---
 
 Complete all of the following steps for $ARGUMENTS:
 
-## Step 0: MANDATORY SETUP
-
-Create workflow tracking todos:
-- Step 1: Setup
-- Step 2: Research
-- Step 3: Gap Detection
-
-⚠️ **CRITICAL**: DO NOT STOP until all 3 todos are marked completed.
-
 ## Step 1: Setup
-Mark "Step 1: Setup" as in_progress.
 
-Use Task tool with prompt: "run /project:setup $ARGUMENTS"
+Run `/project:setup $ARGUMENTS` directly (not via Task tool).
 - Creates project directory, brief.md, findings.md, git branch
+- Creates `.claude-active-project` marker file
+- Outputs the project name (e.g., `2026-01-26-my-feature`)
 
-Mark "Step 1: Setup" as completed. Proceed to Step 2.
-
-## Step 2: Research
-Mark "Step 2: Research" as in_progress.
+Capture the project name from the output for use in subsequent steps.
 
-Use Task tool with prompt: "run /project:research [project-dir]" where [project-dir] is the directory created in Step 1
-- Generates research.md with findings
+## Step 2: Create and Execute Tasks
 
-Mark "Step 2: Research" as completed. Proceed to Step 3.
+Create workflow tracking tasks with `metadata.project` set to the project name from Step 1:
 
-## Step 3: Gap Detection
-Mark "Step 3: Gap Detection" as in_progress.
+```
+TaskCreate:
+  subject: "Research project requirements"
+  description: "Run /project:research projects/<project-name> to gather codebase and web research."
+  metadata: { project: "<project-name-from-step-1>" }
 
-Read the generated research.md file:
-- Locate "## Open Questions" section
-- Check if it contains actual unresolved questions (not just template/empty)
-- If gaps exist:
-  ❌ STOP and report: "Research complete but has open questions. Review $PROJECT/research.md and resolve questions before running /project:execute"
-- If no gaps:
-  ✅ Report: "Bootstrap complete. Research has no gaps. Ready to run /project:execute @projects/$PROJECT"
+TaskCreate:
+  subject: "Gap detection and execution"
+  description: "Read projects/<project-name>/research.md. Check '## Open Questions' section. If unresolved questions exist, STOP and report to human. If no gaps, immediately run /project:execute @projects/<project-name>"
+  metadata: { project: "<project-name-from-step-1>" }
+```
 
-Mark "Step 3: Gap Detection" as completed.
+**Execute each task via a subagent** to preserve main context. Launch up to 6 in parallel where tasks don't have dependencies. Do not stop until both are completed.
 
 ## Output to Human
 
-- "✅ Bootstrap complete with no gaps - ready for execution" OR
-- "⚠️ Bootstrap complete but needs human review - see Open Questions in research.md"
+- If gaps exist: "⚠️ Bootstrap complete but needs human review - see Open Questions in research.md"
+- If no gaps: Execution will begin automatically
+
+---
+
+## Next Step
+
+After completing this phase, tell the user: "To continue, run `/project:execute @projects/<project-name>`"

package/all/copy-overwrite/.claude/commands/project/debrief.md

@@ -1,54 +1,49 @@
 ---
-description: Evaluates findings.md and uses skill-evaluator to decide where each learning belongs (new skill, .claude/rules/PROJECT_RULES.md, or omit)
+description: Aggregates learnings from tasks and findings, uses skill-evaluator to decide where each belongs (new skill, .claude/rules/PROJECT_RULES.md, or omit)
 argument-hint: <project-directory>
 allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, Skill
 ---
 
 ## Setup
 
-Create workflow tracking tasks with `metadata: { "project": "<project-name>", "phase": "debrief" }`:
+Set active project marker: `echo "$ARGUMENTS" | sed 's|.*/||' > .claude-active-project`
 
-1. Read project findings
-2. Evaluate each finding
-3. Apply decisions
+Extract `<project-name>` from the last segment of `$ARGUMENTS`.
 
-## Step 1: Read Project Findings
+## Create and Execute Tasks
 
-Read `$ARGUMENTS/findings.md` FULLY (no limit/offset).
-
-Extract each distinct finding/learning as a separate item.
-
-## Step 2: Evaluate Each Finding
-
-For each finding, use the Task tool with `subagent_type: "skill-evaluator"`:
+Create workflow tracking tasks with `metadata.project` set to the project name:
 
 ```
-Evaluate this finding from a project debrief:
+TaskCreate:
+  subject: "Aggregate project learnings"
+  description: "Collect all learnings from two sources: 1) Read $ARGUMENTS/findings.md for manual findings. 2) Read all task files in $ARGUMENTS/tasks/*.json and extract metadata.learnings arrays. Compile into a single list of distinct findings/learnings."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Evaluate each learning"
+  description: "For each learning, use Task tool with subagent_type 'skill-evaluator' to determine: CREATE SKILL (complex, reusable pattern), ADD TO RULES (simple never/always rule), or OMIT ENTIRELY (already covered or too project-specific). Collect all decisions."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Apply decisions"
+  description: "For each learning based on skill-evaluator decision: CREATE SKILL → run /skill-creator with details. ADD TO RULES → add succinctly to .claude/rules/PROJECT_RULES.md. OMIT → no action. Report summary: skills created, rules added, omitted count."
+  metadata: { project: "<project-name>" }
+```
 
-"[FINDING TEXT]"
+**Execute each task via a subagent** to preserve main context. Launch up to 6 in parallel where tasks don't have dependencies. Do not stop until all are completed.
 
-Determine if this should be:
-1. CREATE SKILL - if it's a complex, reusable pattern
-2. ADD TO RULES - if it's a simple never/always rule for .claude/rules/PROJECT_RULES.md
-3. OMIT ENTIRELY - if it's already covered or too project-specific
-```
+## Important: Rules vs Skills
 
-Collect all decisions from the skill-evaluator.
+**⚠️ WARNING about PROJECT_RULES.md**: Rules in `.claude/rules/` are **always loaded** at session start for every request. Only add learnings to PROJECT_RULES.md if they:
+- Apply to **every** request in this codebase (not just specific features)
+- Are simple "never do X" or "always do Y" statements
+- Cannot be scoped to a skill that's invoked on-demand
 
-## Step 3: Apply Decisions
+If a learning only applies to certain types of work (e.g., "when writing GraphQL resolvers..."), it should be a **skill** instead, not a rule.
 
-For each finding based on skill-evaluator's decision:
+---
 
-| Decision | Action |
-|----------|--------|
-| CREATE SKILL | Use Task tool: "run /skill-creator with [finding details]" |
-| ADD TO RULES | Add the rule succinctly to @.claude/rules/PROJECT_RULES.md |
-| OMIT ENTIRELY | No action needed |
+## Next Step
 
-Report summary:
-```
-Debrief complete:
-- Skills created: [X]
-- Rules added: [Y]
-- Omitted (redundant/narrow): [Z]
-```
+After completing this phase, tell the user: "To continue, run `/project:archive $ARGUMENTS`"

package/all/copy-overwrite/.claude/commands/project/execute.md

@@ -21,30 +21,48 @@ Execute complete implementation workflow for $ARGUMENTS.
 3. Check if planning is already complete: `ls $ARGUMENTS/tasks/*.md 2>/dev/null | head -3`
    - If task files exist: Skip planning, start at implementation
 
-## Workflow Tasks
+## Create and Execute Tasks
 
-Create workflow tracking tasks with `metadata: { "project": "<project-name>", "phase": "execution" }`:
+Create workflow tracking tasks with `metadata.project` set to the project name:
 
-1. Step 1: Planning
-2. Step 2: Implementation
-3. Step 3: Review
-4. Step 4: Verification
-5. Step 5: Debrief
-6. Step 6: Archive
+```
+TaskCreate:
+  subject: "Planning"
+  description: "Run /project:plan $ARGUMENTS to create implementation tasks."
+  metadata: { project: "<project-name>" }
 
-## Execution
+TaskCreate:
+  subject: "Implementation"
+  description: "Run /project:implement $ARGUMENTS to execute all planned tasks."
+  metadata: { project: "<project-name>" }
 
-Work through each workflow task:
+TaskCreate:
+  subject: "Review"
+  description: "Run /project:review $ARGUMENTS to review code changes."
+  metadata: { project: "<project-name>" }
 
-| Step | Command |
-|------|---------|
-| Planning | `run /project:plan $ARGUMENTS` |
-| Implementation | `run /project:implement $ARGUMENTS` |
-| Review | `run /project:review $ARGUMENTS` |
-| Verification | `run /project:verify $ARGUMENTS` |
-| Debrief | `run /project:debrief $ARGUMENTS` |
-| Archive | `run /project:archive $ARGUMENTS` |
+TaskCreate:
+  subject: "Verification"
+  description: "Run /project:verify $ARGUMENTS to verify all requirements are met."
+  metadata: { project: "<project-name>" }
 
-**CRITICAL**: Use Task tool with subagent for Planning, Implementation, Verification, Debrief, and Archive steps.
+TaskCreate:
+  subject: "Debrief"
+  description: "Run /project:debrief $ARGUMENTS to capture learnings."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Archive"
+  description: "Run /project:archive $ARGUMENTS to archive the completed project."
+  metadata: { project: "<project-name>" }
+```
+
+**Execute each task via a subagent** to preserve main context. Launch up to 6 in parallel where tasks don't have dependencies. Do not stop until all are completed.
 
 Report "Project complete and archived" when done.
+
+---
+
+## Next Step
+
+The project workflow is now complete. The implementation is done, reviewed, verified, learnings captured, and the project is archived.

package/all/copy-overwrite/.claude/commands/project/fix-linter-error.md

@@ -1,6 +1,6 @@
 ---
 description: Fix all violations of one or more ESLint rules across the codebase
-allowed-tools: Read, Write, Edit, Bash, Task, TaskCreate, TaskUpdate, TaskList, TaskGet
+allowed-tools: Read, Bash, Glob, Grep
 argument-hint: <rule-1> [rule-2] [rule-3] ...
 model: sonnet
 ---
@@ -9,79 +9,58 @@ model: sonnet
 
 Target rules: $ARGUMENTS
 
-Parse the arguments as space-separated ESLint rule names. If no arguments provided, prompt the user for at least one lint rule name.
+If no arguments provided, prompt the user for at least one lint rule name.
 
-## Setup
+## Step 1: Gather Requirements
 
-Check for active project: `cat .claude-active-project 2>/dev/null`
+1. **Parse rules** from $ARGUMENTS (space-separated)
+2. **Run linter** to collect all violations:
+   ```bash
+   bun run lint 2>&1
+   ```
+3. **Group violations** by rule, then by file, noting:
+   - File path and line numbers
+   - Violation count per file
+   - Sample error messages
 
-If active, include `metadata: { "project": "<project-name>" }` in TaskCreate calls.
+## Step 2: Generate Brief
 
-## Step 1: Parse Rules
+Compile findings into a detailed brief:
 
-Split `$ARGUMENTS` into individual rule names (space-separated).
-
-Example inputs:
-- `sonarjs/cognitive-complexity` → 1 rule
-- `sonarjs/cognitive-complexity @typescript-eslint/no-explicit-any` → 2 rules
-- `react-hooks/exhaustive-deps import/order prefer-const` → 3 rules
-
-## Step 2: Enable Rules
-
-For each rule, find the ESLint config and set it to `"error"` severity if not already enabled. NOTE: Make sure to scan for overrides that need to be changed too. For example eslint.config.local.ts.
-
-## Step 3: Identify Violations
-
-Run linting and collect violations for all target rules:
-
-```bash
-bun run lint 2>&1 | grep -E "(rule-1|rule-2|...)"
 ```
+Fix ESLint violations for rules: $ARGUMENTS
 
-Group violations by:
-1. **Rule name** (primary grouping)
-2. **File path** (secondary grouping)
+## Violations by Rule
 
-Count violations per file per rule.
+### [rule-name-1] (X total violations across Y files)
 
-## Step 4: Create Tasks
+1. src/services/user.ts (5 violations)
+   - Line 23: [error message]
+   - Line 45: [error message]
+   - Line 67: [error message]
+   ...
+2. src/utils/helpers.ts (3 violations)
+   - Line 12: [error message]
+   ...
 
-Create tasks organized by rule, then by file:
+### [rule-name-2] (X total violations across Y files)
+...
 
-For each rule:
-- Create a parent task: "Fix all [rule-name] violations ([N] files, [M] total)"
-- Create child tasks for each file with violations, ordered by count (highest first)
+## Fix Strategies
+- **Complexity rules** (sonarjs/*): Extract functions, early returns, simplify conditions
+- **Style rules** (prettier/*, import/order): Apply formatting fixes
+- **Best practice rules** (react-hooks/*, prefer-const): Refactor to recommended pattern
+- **Type rules** (@typescript-eslint/*): Add proper types, remove `any`
 
-Each file task should include:
-- File path and violation count for that specific rule
-- Sample error messages
-- Fix approach based on rule type:
-  - **Complexity rules** (`sonarjs/*`): Extract functions, use early returns, simplify conditions
-  - **Style rules** (`prettier/*`, `import/order`): Apply formatting fixes
-  - **Best practice rules** (`react-hooks/*`, `prefer-const`): Refactor to follow recommended pattern
-  - **Type rules** (`@typescript-eslint/*`): Add proper types, remove `any`
-
-## Step 5: Execute
-
-Process rules sequentially (to avoid conflicts), but parallelize file fixes within each rule:
-
-For each rule:
-1. Launch up to 5 sub-agents to fix files for that rule in parallel
-2. Wait for all files to be fixed
-3. Run `bun run lint` to verify rule is now clean
-4. Commit all fixes for that rule with message: `fix(lint): resolve [rule-name] violations`
-5. Move to next rule
-
-## Step 6: Report
+## Acceptance Criteria
+- `bun run lint` passes with zero violations for: $ARGUMENTS
+- Each rule's fixes committed separately: `fix(lint): resolve [rule-name] violations`
 
+## Verification
+Command: `bun run lint 2>&1 | grep -E "($ARGUMENTS)" | wc -l`
+Expected: 0
 ```
-Lint rule fix complete:
 
-| Rule | Files Fixed | Violations Resolved |
-|------|-------------|---------------------|
-| rule-1 | N1 | M1 |
-| rule-2 | N2 | M2 |
-| ... | ... | ... |
+## Step 3: Bootstrap Project
 
-Total: [N] files fixed, [M] violations resolved
-```
+Run `/project:bootstrap` with the generated brief as a text prompt.

package/all/copy-overwrite/.claude/commands/project/implement.md

@@ -15,17 +15,17 @@ allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate
 
 Use **TaskList** to get current task status.
 
+**Always execute tasks via subagents** to keep the main context window clean. Launch up to 6 subagents in parallel for unblocked tasks.
+
 For each pending, unblocked task (filter by `metadata.project` = `<project-name>`):
 
 1. Use **TaskUpdate** to mark it `in_progress`
-2. Use **TaskGet** to retrieve full task details (description contains all instructions)
-3. Launch a subagent to complete the task:
-   - Pass the task's full description (includes skills to invoke, verification, etc.)
-   - Subagent should follow the instructions in the description
-   - Subagent runs the verification command and confirms expected output
-4. When subagent completes successfully, use **TaskUpdate** to mark it `completed`
-5. If verification fails, keep task `in_progress` and report the failure
-6. Check **TaskList** for newly unblocked tasks
+2. Use **TaskGet** to retrieve full task details
+3. Complete the task following the instructions in its description
+4. Run the verification command and confirm expected output
+5. If verification passes, use **TaskUpdate** to mark it `completed`
+6. If verification fails, keep task `in_progress` and report the failure
+7. Check **TaskList** for newly unblocked tasks
 
 Continue until all tasks are completed.
 
@@ -35,4 +35,4 @@ Use **TaskList** to generate a summary showing:
 - Total tasks completed
 - Any tasks that failed or remain in progress
 
-Suggest running `/project:review`.
+After completing this phase, tell the user: "To continue, run `/project:review $ARGUMENTS`"

package/all/copy-overwrite/.claude/commands/project/lower-code-complexity.md

@@ -1,49 +1,61 @@
 ---
 description: Reduces the code complexity of the codebase by 2 on each run
-allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, TaskGet
+allowed-tools: Read, Bash, Glob, Grep
 ---
 
-## Setup
+# Lower Code Complexity
 
-Check for active project: `cat .claude-active-project 2>/dev/null`
+Reduces the cognitive complexity threshold by 2 and fixes all violations.
 
-If active, include `metadata: { "project": "<project-name>" }` in TaskCreate calls.
+## Step 1: Gather Requirements
 
-## Step 1: Lower Threshold
+1. **Read current threshold** from eslint config (cognitive-complexity rule)
+2. **Calculate new threshold**: current - 2 (e.g., 15 → 13)
+3. **Run lint** with the new threshold to find violations:
+   ```bash
+   bun run lint 2>&1 | grep "cognitive-complexity"
+   ```
+4. **Note for each violation**:
+   - File path and line number
+   - Function name
+   - Current complexity score
 
-1. Read the eslint config to find the current `cognitive-complexity` threshold
-2. Lower the threshold by 2 (e.g., 15 → 13)
+If no violations at new threshold, report success and exit.
 
-## Step 2: Identify Violations
+## Step 2: Generate Brief
 
-Run lint to find all cognitive complexity violations. Note file path, function name, and complexity score.
+Compile findings into a detailed brief:
 
-If no violations, report success and exit.
+```
+Reduce cognitive complexity threshold from [current] to [new].
 
-## Step 3: Create Tasks
+## Functions Exceeding Threshold (ordered by complexity)
 
-Create a task for each function needing refactoring, ordered by complexity score (highest first).
+1. src/services/user.ts:processUser (complexity: 18, target: [new])
+   - Line 45, function spans lines 45-120
+2. src/utils/helpers.ts:validateInput (complexity: 15, target: [new])
+   - Line 23, function spans lines 23-67
+...
 
-Each task should include:
-- File path and function name
-- Current complexity score and target threshold
-- Refactoring strategies:
-  - **Extract functions**: Break complex logic into smaller, named functions
-  - **Early returns**: Reduce nesting with guard clauses
-  - **Extract conditions**: Move complex boolean logic into named variables
-  - **Use lookup tables**: Replace complex switch/if-else chains with object maps
+## Configuration Change
+- File: [eslint config path]
+- Change: cognitive-complexity threshold from [current] to [new]
 
-## Step 4: Execute
+## Refactoring Strategies
+- **Extract functions**: Break complex logic into smaller, named functions
+- **Early returns**: Reduce nesting with guard clauses
+- **Extract conditions**: Move complex boolean logic into named variables
+- **Use lookup tables**: Replace complex switch/if-else chains with object maps
 
-Launch up to 5 sub-agents using `code-simplifier` to refactor in parallel.
+## Acceptance Criteria
+- All functions at or below complexity [new]
+- `bun run lint` passes with no cognitive-complexity violations
 
-Work through all tasks until complete.
+## Verification
+Command: `bun run lint 2>&1 | grep "cognitive-complexity" | wc -l`
+Expected: 0
+```
 
-## Step 5: Report
+## Step 3: Bootstrap Project
 
-```
-Code complexity reduction complete:
-- Previous threshold: [X]
-- New threshold: [Y]
-- Functions simplified: [list]
-```
+Run `/project:bootstrap` with the generated brief as a text prompt.

package/all/copy-overwrite/.claude/commands/project/plan.md

@@ -109,7 +109,16 @@ For each task, use **TaskCreate** with:
 [Or "N/A - no user-facing changes"]
 
 ## Verification
-**Type:** `ui-recording` | `test-coverage` | `api-test` | `manual-check` | `documentation`
+**Type:** `test` | `ui-recording` | `test-coverage` | `api-test` | `manual-check` | `documentation`
+
+| Type | When to Use | Example |
+|------|-------------|---------|
+| `test` | Run specific tests | `bun run test -- src/services/user.spec.ts` |
+| `ui-recording` | UI/UX changes | `bun run playwright:test ...` |
+| `test-coverage` | Coverage threshold | `bun run test:cov -- --collectCoverageFrom='...'` |
+| `api-test` | API endpoints | `./scripts/verify/<task-name>.sh` |
+| `documentation` | Docs, README | `cat path/to/doc.md` |
+| `manual-check` | Config, setup | Command showing config exists |
 
 **Proof Command:**
 ```bash
@@ -118,6 +127,21 @@ For each task, use **TaskCreate** with:
 
 **Expected Output:**
 [What success looks like]
+
+## Learnings
+During implementation, collect any discoveries valuable for future developers:
+- Gotchas or unexpected behavior encountered
+- Edge cases that weren't obvious from requirements
+- Better approaches discovered during implementation
+- Patterns that should be reused or avoided
+- Documentation gaps or misleading information found
+
+**On task completion**, use `TaskUpdate` to save learnings:
+```
+TaskUpdate:
+  taskId: "<this-task-id>"
+  metadata: { learnings: ["Learning 1", "Learning 2", ...] }
+```
 ```
 
 **metadata**:
@@ -127,7 +151,7 @@ For each task, use **TaskCreate** with:
   "type": "bug|task|epic|story",
   "skills": ["/coding-philosophy", ...],
   "verification": {
-    "type": "test-coverage|ui-recording|api-test|manual-check|documentation",
+    "type": "test|ui-recording|test-coverage|api-test|manual-check|documentation",
     "command": "the proof command",
     "expected": "what success looks like"
   }
@@ -138,16 +162,6 @@ For each task, use **TaskCreate** with:
 
 After creating all tasks, use **TaskUpdate** with `addBlockedBy` to establish task order where needed.
 
-**Verification Type Reference:**
-
-| Type | When to Use | Example |
-|------|-------------|---------|
-| `ui-recording` | UI/UX changes | `bun run playwright:test ...` |
-| `test-coverage` | New code with tests | `bun run test:cov -- --collectCoverageFrom='...'` |
-| `api-test` | New API endpoints | `./scripts/verify/<task-name>.sh` |
-| `documentation` | Docs, README | `cat path/to/doc.md` |
-| `manual-check` | Config, setup | Command showing config exists |
-
 ## Step 5: Report
 
 Report: "Planning complete - X tasks created for project <project-name>"
@@ -157,3 +171,9 @@ Use **TaskList** to show the created tasks.
 ---
 
 **IMPORTANT**: Each task description should contain all necessary information from `brief.md` and `research.md` to complete in isolation. Tasks should be independent and as small in scope as possible.
+
+---
+
+## Next Step
+
+After completing this phase, tell the user: "To continue, run `/project:implement $ARGUMENTS`"