5-phase-workflow 2.1.0 → 3.0.0-beta-2

package/src/references/configure-tables.md

@@ -85,10 +85,6 @@ For each command found: record exact syntax, note variants (e.g., `test:unit`, `
     }
   },
   "tools": {
-    "coderabbit": {
-      "available": false,
-      "authenticated": false
-    },
     "ide": {
       "available": false,
       "type": null
@@ -100,7 +96,6 @@ For each command found: record exact syntax, note variants (e.g., `test:unit`, `
       "available": false
     }
   },
-  "reviewTool": "native",
   "git": {
     "autoCommit": false,
     "commitMessage": {

package/src/settings.json

@@ -36,16 +36,6 @@
             "timeout": 5
           }
         ]
-      },
-      {
-        "matcher": "Task|Agent|Write|Edit|EnterPlanMode|Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node .claude/hooks/plan-guard.js",
-            "timeout": 5
-          }
-        ]
       }
     ]
   }

package/src/workflows/5-implement.js

@@ -1,7 +1,7 @@
 export const meta = {
   name: '5-implement',
   description: 'Execute a unified plan: derive steps, run executors in parallel waves, verify. Claude Code only; Codex uses the prose loop.',
-  whenToUse: 'Invoked by the /5:implement command when the Workflow tool is available. Reads args from the command, returns final state for the command to persist to state.json.',
+  whenToUse: 'Invoked by the /5:implement command when the Workflow tool is available. Reads args from the command, returns the run result for the command to persist to the slim state.json.',
   phases: [
     { title: 'Orchestrate', detail: 'derive steps + components (agent for non-trivial plans, inline for compact)' },
     { title: 'Execute', detail: 'one executor agent per component; parallel components fire together per step' },
@@ -15,8 +15,12 @@ export const meta = {
 // the canonical human-readable contract; keep these prompts in sync with them.
 //
 // This script has NO filesystem access. It orchestrates agents and RETURNS the
-// final state object. The /5:implement command (which has Write) persists
-// state.json + state-events.jsonl and runs auto-commit after this returns.
+// final result. The /5:implement command (which has Write) persists the slim
+// state.json and runs auto-commit after this returns.
+//
+// The execution graph (steps/components) is derived fresh on every run and is
+// NOT persisted. Resume works because component names are copied verbatim from
+// the plan's Component Checklist, so re-derivation is stable by name.
 // ─────────────────────────────────────────────────────────────────────────────
 
 const RESULT_SCHEMA = {
@@ -128,6 +132,7 @@ Codebase scan: ${a.paths.scan} (read only if present)
 Config: ${a.paths.config} (read only if present)
 
 Turn the lean component checklist in the plan into steps + components:
+- COPY EVERY COMPONENT NAME VERBATIM from the plan's Component Checklist. Resume matches components by name across runs, so a renamed or reformatted name makes completed work run twice.
 - Group independent components into one step with mode "parallel"; use "sequential" only when components touch the same file, one imports another, or there is an explicit dependency.
 - Prefer fewer steps. Tests run after the components they validate.
 - model "haiku" by default (mechanical, UI, tests, docs, config, single-file). model "sonnet" only for complex logic, cross-module, security/auth, migrations, or public API.
@@ -260,18 +265,12 @@ async function runStep(step, components, a) {
 // ── Main ─────────────────────────────────────────────────────────────────────
 
 const a = args || {}
-const resume = a.resume || {}
-const resumeDone = new Set(resume.completedComponents || [])
+const resumeDone = new Set(a.completedComponents || [])
 
 phase('Orchestrate')
+if (resumeDone.size) log(`resume: ${resumeDone.size} component(s) already complete, matched by name`)
 let plan
-if (Array.isArray(resume.steps) && resume.steps.length && Array.isArray(resume.pendingComponents) && resume.pendingComponents.length) {
-  // Resume: reuse the steps/components derived in the original run (stored in state.json).
-  // Re-deriving via the orchestrator agent is non-deterministic and could rename components,
-  // breaking name-based resume matching — so never re-orchestrate on resume.
-  log(`resume: reusing ${resume.steps.length} prior step(s); ${resumeDone.size} component(s) already complete`)
-  plan = { steps: resume.steps, pendingComponents: resume.pendingComponents }
-} else if (a.isCompact && Array.isArray(a.components) && a.components.length) {
+if (a.isCompact && Array.isArray(a.components) && a.components.length) {
   log(`compact plan: ${a.components.length} component(s), no orchestrator agent`)
   plan = compactSteps(a.components)
 } else {
@@ -310,8 +309,9 @@ if (allPassed && !usedSonnet) {
 const newlyCompleted = allItems.filter(i => i.result && i.result.status === 'success').map(i => i.component.name)
 const completedComponents = [...new Set([...resumeDone, ...newlyCompleted])]
 
-// Returned to the /5:implement command, which persists state.json + state-events.jsonl and auto-commits.
-// steps + components are returned so a later resume can pass them back (deterministic, no re-orchestration).
+// Returned to the /5:implement command, which persists the slim state.json and auto-commits.
+// steps + components are returned for reporting and per-step staging only — they are NOT persisted;
+// the next run re-derives them, and resume matches on completedComponents by name.
 return {
   feature: a.feature,
   steps,

package/src/commands/5/discuss-feature.md

@@ -1,189 +0,0 @@
----
-name: 5:discuss-feature
-description: Discusses and refines an existing unified plan through iterative Q&A. Use after /5:plan when requirements need clarification or changes. Updates the unified plan based on discussion.
-allowed-tools: Read, Write, Glob, Grep, Agent, AskUserQuestion
-user-invocable: true
-context: inherit
----
-
-<role>
-You are a Feature Discussion Facilitator. You refine existing unified plans through Q&A.
-You do NOT create new unified plans, create implementation plans, write code, or start implementation.
-You read an existing plan.md, discuss it with the user, and update only the changed sections.
-After updating the plan and informing the user, you are DONE.
-</role>
-
-# Discuss Feature Plan (Optional Iteration)
-
-## Overview
-
-This helper refines the unified `plan.md` created by `/5:plan`.
-
-Use it when requirements, scope, acceptance criteria, decisions, or the component checklist need adjustment before `/5:implement`.
-
-## ⚠️ CRITICAL SCOPE CONSTRAINT
-
-**THIS COMMAND ONLY UPDATES THE UNIFIED PLAN. IT DOES NOT IMPLEMENT.**
-
-Your job in this command:
-✅ Read existing unified plan
-✅ Ask what user wants to discuss
-✅ Explore codebase if needed for context
-✅ Ask clarifying questions
-✅ Update unified plan
-✅ Tell user to run /5:implement
-
-Your job is NOT:
-❌ Create new unified plans (use /5:plan)
-❌ Start implementation
-❌ Write any code
-❌ Rewrite entire unified plan (only update changed sections)
-
-**After updating the unified plan and informing the user, YOUR JOB IS COMPLETE. EXIT IMMEDIATELY.**
-
-## Use Cases
-
-Use this skill when:
-- Requirements need clarification after initial planning
-- User wants to add/modify/remove requirements
-- Scope needs adjustment
-- Technical constraints discovered during exploration
-- Alternative approaches need evaluation
-- Feature complexity needs reduction
-- Acceptance criteria need refinement
-
-## Prerequisites
-
-Before invoking this skill, ensure:
-1. Unified plan exists at `.5/features/{feature-name}/plan.md`
-2. You have the feature name or ticket ID ready (e.g., "PROJ-1234-add-feature")
-
-## Discussion Process
-
-### Step 1: Extract Feature Name
-
-If user provides only ticket ID (e.g., "PROJ-1234"), find the plan file:
-- Use Glob: `.5/features/{TICKET-ID}-*/plan.md` (pattern from config)
-- Match the ticket ID
-- If multiple matches, ask user to specify
-- If no match found, inform user and suggest running `/5:plan` first
-
-If user provides full feature name (e.g., "PROJ-1234-add-feature"), use directly.
-
-### Step 2: Read Plan
-
-Read the unified plan from `.5/features/{feature-name}/plan.md`.
-
-Extract current state:
-- Ticket ID
-- Overview
-- What Changes
-- Existing Patterns to Follow
-- Constraints
-- Scope
-- Acceptance Criteria
-- Decisions ([DECIDED]/[FLEXIBLE]/[DEFERRED])
-- Module Impact
-- Component Checklist
-- Technical Notes
-- Alternatives Considered
-
-### Step 3: Initial Discussion Prompt
-
-**FIRST ACTION:** Ask the user what they want to discuss using AskUserQuestion.
-
-Prompt to use:
-
-"What would you like to discuss or change about this feature?"
-
-Provide context options for common scenarios:
-- "Clarify existing requirements"
-- "Add new requirements"
-- "Remove or simplify requirements"
-- "Change scope or approach"
-- "Discuss technical constraints"
-- "Review acceptance criteria"
-- "Other (specify)"
-
-Use `multiSelect: false` to get single focus area initially.
-
-### Step 4: Contextual Exploration (Optional)
-
-Based on the user's focus area, explore the codebase if needed:
-
-**Index shortcut:** Before spawning Explore agents or running Glob/Grep, invoke the `use-index` skill to quickly orient in the codebase using the generated index.
-
-**For technical constraint discussions:**
-- Search for similar implementations
-- Check existing patterns
-- Identify integration points
-
-**For scope changes:**
-- Verify affected modules
-- Check dependencies
-- Identify ripple effects
-
-Use Agent tool with subagent_type=Explore for complex exploration.
-
-### Step 5: Interactive Q&A
-
-Based on the discussion topic, ask targeted follow-up questions using AskUserQuestion.
-
-Ask targeted follow-up questions informed by the unified plan and any codebase exploration. Focus on: requirements clarity, scope boundaries, edge cases, technical constraints, and acceptance criteria. Challenge assumptions constructively — suggest simpler alternatives when appropriate.
-
-### Step 6: Iterative Refinement
-
-After each round of Q&A:
-1. Summarize what you've learned
-2. Ask: "Would you like to discuss anything else about this feature?"
-3. Provide options:
-   - "Yes, discuss another aspect"
-   - "Yes, continue this topic"
-   - "No, update the plan"
-
-Allow multiple rounds of discussion until user is satisfied.
-
-### Step 7: Update Plan
-
-When user indicates they're done discussing, update `.5/features/{feature-name}/plan.md`:
-
-**Update these sections based on discussion:**
-
-1. **Overview** - If core understanding changed
-2. **What Changes** - Add/modify/remove behavior
-3. **Constraints** - Add new constraints discovered
-4. **Scope** - If boundaries changed
-5. **Acceptance Criteria** - Add/refine verification criteria
-6. **Decisions** - Append new decisions tagged [DECIDED], [FLEXIBLE], or [DEFERRED]
-7. **Component Checklist** - Adjust components only when scope or requirements changed
-8. **Technical Notes / Alternatives Considered** - Document useful context from discussion
-
-**Preserve existing content** - Only update sections that changed during discussion.
-
-**Track changes** - Add a "Discussion History" section if it doesn't exist:
-
-```markdown
-## Discussion History
-
-### Session 1: {Date} - {Topic}
-**Changes made:**
-- Added requirement: {X}
-- Clarified: {Y}
-- Removed: {Z}
-
-**Rationale:** {Why these changes}
-```
-
-### Step 8: Inform Developer
-
-After updating the plan, tell the developer:
-
-1. "Plan updated at `.5/features/{feature-name}/plan.md`"
-2. Summarize key changes:
-   - "Added: {X}"
-   - "Modified: {Y}"
-   - "Removed: {Z}"
-3. Ask: "Would you like to:"
-   - "Discuss more (run /5:discuss-feature again)"
-   - "Proceed to implementation (run `/clear` followed by `/5:implement {feature-name}`)"
-   - "Review the updated plan first"

package/src/commands/5/unlock.md

@@ -1,23 +0,0 @@
----
-name: 5:unlock
-description: Remove the planning guard lock to allow edits outside the workflow
-allowed-tools: Bash
-user-invocable: true
-context: inherit
----
-
-# Unlock Planning Guard
-
-Remove the `.planning-active` marker file that restricts Write/Edit operations during planning phases.
-
-## Process
-
-Run this bash command to check and remove the marker in one step:
-
-```bash
-if [ -f .5/.planning-active ]; then rm .5/.planning-active && echo "REMOVED"; else echo "ABSENT"; fi
-```
-
-Based on the output, confirm to the user:
-- If output contains "REMOVED": "Planning guard removed. You can now edit files freely."
-- If output contains "ABSENT": "No planning guard was active. You're already free to edit files."

package/src/hooks/plan-guard.js

@@ -1,269 +0,0 @@
-#!/usr/bin/env node
-
-// Plan Guard - PreToolUse Hook
-// Prevents LLM breakout from planning phases by blocking:
-// - Agent/Task agents other than Explore (when not in implementation mode)
-// - Write/Edit operations outside .5/ (when not in implementation mode)
-//
-// Planning mode is detected per-feature by checking if that specific feature's
-// state.json exists. Only the feature in implementation mode gets unrestricted
-// tool access. Other features remain in planning mode.
-
-const fs = require('fs');
-const path = require('path');
-
-let input = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => input += chunk);
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(input);
-    const toolName = data.tool_name || '';
-
-    // Short-circuit: only check Agent, Task, Write, Edit, EnterPlanMode, and Bash tools
-    if (toolName !== 'Agent' && toolName !== 'Task' && toolName !== 'Write' && toolName !== 'Edit' && toolName !== 'EnterPlanMode' && toolName !== 'Bash') {
-      process.exit(0);
-    }
-
-    const workspaceDir = data.cwd || data.workspace?.current_dir || process.cwd();
-
-    // If no planning phase is active, allow all tools
-    if (!isPlanningActive(workspaceDir)) {
-      process.exit(0);
-    }
-
-    const toolInput = data.tool_input || {};
-
-    // Determine which feature is being targeted and check its state
-    const targetFeature = getTargetFeature(toolName, toolInput, workspaceDir);
-    if (targetFeature && isFeatureInImplementationMode(workspaceDir, targetFeature)) {
-      process.exit(0); // Tools allowed for features in implementation mode
-    }
-
-    // Planning mode enforcement
-    if (toolName === 'EnterPlanMode') {
-      const blockCount = incrementBlockCount(workspaceDir);
-      const phase = getPlanningPhase(workspaceDir);
-      const escalation = blockCount >= 3
-        ? ` CRITICAL: Block #${blockCount}. You have attempted to break out of planning ${blockCount} times. You MUST return to your current step in the Progress Checklist, complete your planning artifact, output the completion message, and STOP. Do NOT attempt any other action.`
-        : '';
-      process.stderr.write(
-        `BLOCKED: EnterPlanMode is not allowed during workflow planning. ` +
-        `dev-workflow has its own planning process. ` +
-        `REDIRECT: You are in ${phase || 'a planning phase'}. Return to your Progress Checklist. ` +
-        `Find the last "✓ Step N complete" you output, then continue with Step N+1. ` +
-        `Write your output to .5/features/{name}/ and output the completion message when done.${escalation}`
-      );
-      process.exit(2);
-    }
-
-    if (toolName === 'Agent' || toolName === 'Task') {
-      const agentType = toolInput.subagent_type || '';
-      if (agentType && agentType !== 'Explore') {
-        const blockCount = incrementBlockCount(workspaceDir);
-        const phase = getPlanningPhase(workspaceDir);
-        const escalation = blockCount >= 3
-          ? ` CRITICAL: Block #${blockCount}. You are a planner, NOT an implementer. You have attempted to spawn non-Explore agents ${blockCount} times. Implementation happens in /5:implement. Return to your Progress Checklist immediately, complete your planning artifact, and STOP.`
-          : '';
-        process.stderr.write(
-          `BLOCKED: Only Explore agents are allowed during planning. ` +
-          `Attempted: subagent_type="${agentType}". ` +
-          `You are in ${phase || 'the planning phase'}. Implementation agents are /5:implement only. ` +
-          `REDIRECT: Return to your Progress Checklist. Find your last "✓ Step N complete" and continue with Step N+1. ` +
-          `If you need codebase information, use subagent_type=Explore. ` +
-          `If you are done planning, output the completion message and STOP.${escalation}`
-        );
-        process.exit(2);
-      }
-    }
-
-    if (toolName === 'Bash') {
-      const command = toolInput.command || '';
-      // Detect file-writing shell commands that bypass Write/Edit guards
-      const writePatterns = /\b(cat\s*>|cat\s*<<|echo\s.*>|tee\s|printf\s.*>|cp\s|mv\s|mkdir\s.*&&.*>|sed\s+-i|awk\s.*>|touch\s|install\s)/;
-      if (writePatterns.test(command)) {
-        const blockCount = incrementBlockCount(workspaceDir);
-        const phase = getPlanningPhase(workspaceDir);
-        const escalation = blockCount >= 3
-          ? ` CRITICAL: Block #${blockCount}. You are repeatedly attempting to write files via Bash to bypass planning guards. STOP immediately.`
-          : '';
-        process.stderr.write(
-          `BLOCKED: File-writing Bash commands are not allowed during planning. ` +
-          `You are in ${phase || 'the planning phase'}. ` +
-          `REDIRECT: Return to your Progress Checklist. Planners do not create or modify source files. ` +
-          `Complete your planning artifact and output the completion message.${escalation}`
-        );
-        process.exit(2);
-      }
-    }
-
-    if (toolName === 'Write' || toolName === 'Edit') {
-      const filePath = toolInput.file_path || '';
-      if (!filePath) {
-        process.exit(0);
-      }
-
-      const phase = getPlanningPhase(workspaceDir);
-
-      // First check: block anything outside .5/
-      if (!isInsideDotFive(filePath, workspaceDir)) {
-        const blockCount = incrementBlockCount(workspaceDir);
-        const isSourceFile = !filePath.includes('.5/') && !filePath.includes('.claude/');
-        const escalation = blockCount >= 3
-          ? ` CRITICAL: Block #${blockCount}. You have attempted to write source files ${blockCount} times. You are a PLANNER, not an implementer. Writing source code is /5:implement's job. Return to your Progress Checklist, finish your planning artifact, and STOP.`
-          : '';
-        const redirectMsg = isSourceFile
-          ? `REDIRECT: You are in ${phase || 'the planning phase'}. You may ONLY write to .5/features/. ` +
-            `Source file creation happens in /5:implement. ` +
-            `Return to your Progress Checklist — find your last "✓ Step N complete" and continue with Step N+1.`
-          : `REDIRECT: The path "${filePath}" is outside the allowed .5/ directory. ` +
-            `Check your file path — you should be writing to .5/features/{name}/.`;
-        process.stderr.write(
-          `BLOCKED: ${toolName} outside .5/ is not allowed during planning. ` +
-          `Attempted: "${filePath}". ${redirectMsg}${escalation}`
-        );
-        process.exit(2);
-      }
-
-      // Second check: during plan, only allow specific files
-      if (normalizePlanningPhase(phase) === 'plan' && !isAllowedPlanFile(filePath, workspaceDir)) {
-        const blockCount = incrementBlockCount(workspaceDir);
-        const escalation = blockCount >= 3
-          ? ` CRITICAL: Block #${blockCount}. You are attempting to create implementation artifacts during planning. Planning ONLY produces plan.md and codebase-scan.md. STOP and output your completion message.`
-          : '';
-        process.stderr.write(
-          `BLOCKED: During plan, you may only write to .planning-active, codebase-scan.md, and plan.md. ` +
-          `Attempted: "${filePath}". ` +
-          `REDIRECT: If you have already written plan.md, output the completion message and STOP. ` +
-          `Do NOT create source files or state.json during planning.${escalation}`
-        );
-        process.exit(2);
-      }
-    }
-
-    process.exit(0);
-  } catch (e) {
-    // Silent failure - don't block on parse errors
-    process.exit(0);
-  }
-});
-
-function isAllowedPlanFile(filePath, workspaceDir) {
-  const resolved = path.resolve(workspaceDir, filePath);
-  const dotFiveDir = path.join(workspaceDir, '.5');
-
-  // Allow .5/.planning-active
-  if (resolved === path.join(dotFiveDir, '.planning-active')) return true;
-
-  // Allow .5/features/{name}/plan.md and .5/features/{name}/codebase-scan.md
-  const featuresDir = path.join(dotFiveDir, 'features');
-  if (resolved.startsWith(featuresDir + path.sep)) {
-    const basename = path.basename(resolved);
-    if (basename === 'plan.md' || basename === 'codebase-scan.md') return true;
-  }
-
-  return false;
-}
-
-function isInsideDotFive(filePath, workspaceDir) {
-  const resolved = path.resolve(workspaceDir, filePath);
-  const dotFiveDir = path.join(workspaceDir, '.5');
-  return resolved.startsWith(dotFiveDir + path.sep) ||
-         resolved === dotFiveDir;
-}
-
-function getTargetFeature(toolName, toolInput, workspaceDir) {
-  // Extract the feature name from the tool input context
-  const featuresDir = path.join(workspaceDir, '.5', 'features');
-
-  if (toolName === 'Write' || toolName === 'Edit') {
-    // Check if the file path is inside a feature directory
-    const filePath = toolInput.file_path || '';
-    const resolved = path.resolve(workspaceDir, filePath);
-    if (resolved.startsWith(featuresDir + path.sep)) {
-      // Extract feature name: .5/features/{feature-name}/...
-      const relative = resolved.slice(featuresDir.length + 1);
-      const featureName = relative.split(path.sep)[0];
-      if (featureName) return featureName;
-    }
-  }
-
-  if (toolName === 'Agent' || toolName === 'Task') {
-    // Check the task prompt for feature name references
-    const prompt = toolInput.prompt || '';
-    const desc = toolInput.description || '';
-    const combined = prompt + ' ' + desc;
-
-    // Try to match a feature directory that exists
-    try {
-      if (fs.existsSync(featuresDir)) {
-        const features = fs.readdirSync(featuresDir, { withFileTypes: true });
-        for (const entry of features) {
-          if (!entry.isDirectory()) continue;
-          if (combined.includes(entry.name)) {
-            return entry.name;
-          }
-        }
-      }
-    } catch (e) {
-      // Ignore read errors
-    }
-  }
-
-  return null;
-}
-
-function isPlanningActive(workspaceDir) {
-  const markerPath = path.join(workspaceDir, '.5', '.planning-active');
-  if (!fs.existsSync(markerPath)) return false;
-  try {
-    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
-    if (marker.startedAt) {
-      const elapsed = Date.now() - new Date(marker.startedAt).getTime();
-      if (elapsed > 4 * 60 * 60 * 1000) {
-        try { fs.unlinkSync(markerPath); } catch (e) {}
-        return false;
-      }
-    }
-    return true;
-  } catch (e) {
-    return true; // Unreadable marker → fail-safe, assume active
-  }
-}
-
-function incrementBlockCount(workspaceDir) {
-  const markerPath = path.join(workspaceDir, '.5', '.planning-active');
-  try {
-    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
-    marker.blockCount = (marker.blockCount || 0) + 1;
-    fs.writeFileSync(markerPath, JSON.stringify(marker, null, 2));
-    return marker.blockCount;
-  } catch (e) {
-    return 1;
-  }
-}
-
-function getPlanningPhase(workspaceDir) {
-  const markerPath = path.join(workspaceDir, '.5', '.planning-active');
-  try {
-    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
-    return marker.phase || null;
-  } catch (e) {
-    return null;
-  }
-}
-
-function normalizePlanningPhase(phase) {
-  if (!phase) return 'plan';
-  if (phase === 'plan-feature' || phase === 'plan-implementation') return 'plan';
-  if (phase === 'plan') return 'plan';
-  return 'plan';
-}
-
-function isFeatureInImplementationMode(workspaceDir, featureName) {
-  // Check if this specific feature has a state.json (created by /5:implement)
-  const stateFile = path.join(
-    workspaceDir, '.5', 'features', featureName, 'state.json'
-  );
-  return fs.existsSync(stateFile);
-}

package/src/templates/workflow/STATE.json

@@ -1,43 +0,0 @@
-{
-  "ticket": "{TICKET-ID}",
-  "feature": "{feature-name}",
-  "status": "in-progress",
-  "currentStep": 1,
-  "totalSteps": 0,
-  "steps": [
-    {
-      "number": 1,
-      "name": "{step-name}",
-      "mode": "parallel",
-      "model": "haiku",
-      "components": []
-    }
-  ],
-  "pendingComponents": [
-    {
-      "name": "{component-name}",
-      "action": "create",
-      "step": 1,
-      "mode": "parallel",
-      "model": "haiku",
-      "file": "{target-path}",
-      "sourceFile": null,
-      "description": "{one-sentence intent}",
-      "dependsOn": [],
-      "patternRefs": [],
-      "verifyCommands": [],
-      "notes": []
-    }
-  ],
-  "completedComponents": [],
-  "recentFailures": [],
-  "baseline": {},
-  "latestCommandResults": [],
-  "verificationStatus": "pending",
-  "verificationResults": {},
-  "verifiedAt": null,
-  "latestCommitResults": [],
-  "eventLog": ".5/features/{feature-name}/state-events.jsonl",
-  "startedAt": "{ISO-timestamp}",
-  "lastUpdated": "{ISO-timestamp}"
-}