specsmd 0.0.0-dev.6 → 0.0.0-dev.60

package/flows/fire/agents/builder/skills/run-plan/SKILL.md

@@ -0,0 +1,376 @@
+# Skill: Run Plan
+
+Plan the scope of a run by discovering available work items and suggesting groupings.
+
+---
+
+## Trigger
+
+- After work-item decomposition completes
+- User wants to start execution
+- Pending work items exist
+
+---
+
+## Degrees of Freedom
+
+**MEDIUM** — Present smart grouping suggestions but let user choose scope.
+
+---
+
+## Critical Clarifications
+
+### Dependencies Mean Sequential Execution, NOT Separate Runs
+
+**IMPORTANT**: When work items have dependencies:
+- They execute **sequentially within the SAME run**
+- They do **NOT** require separate runs
+- The dependent item waits for its dependency to complete before starting
+
+**Example**: If item 05 depends on item 04:
+- **CORRECT**: ONE run with both items, 04 executes first, then 05
+- **WRONG**: TWO separate runs
+
+### All Options Can Include Multiple Items Per Run
+
+| Option | Items Per Run | Execution |
+|--------|---------------|-----------|
+| Single | 1 item | One at a time, separate runs |
+| Batch | Multiple items (same mode) | Sequential within run |
+| Wide | All compatible items | Sequential within run |
+
+---
+
+## Workflow
+
+```xml
+<skill name="run-plan">
+
+  <mandate>
+    DISCOVER all available work - both in state.yaml AND file system.
+    FILE SYSTEM IS SOURCE OF TRUTH — state.yaml may be incomplete.
+    ALWAYS SCAN FILE SYSTEM — even if state.yaml shows all completed.
+    SUGGEST smart groupings based on mode, dependencies, and user history.
+    LEARN from user choices to improve future recommendations.
+    NEVER force a scope - always let user choose.
+    DEPENDENCIES = SEQUENTIAL EXECUTION, NOT SEPARATE RUNS.
+  </mandate>
+
+  <step n="1" title="Discover Available Work" critical="true">
+    <critical>
+      MUST scan file system BEFORE deciding if work exists.
+      state.yaml may be missing intents or work items that exist on disk.
+      DO NOT skip this step even if state.yaml shows all items completed.
+    </critical>
+
+    <substep n="1a" title="List All Intent Directories">
+      <action>Use Glob to list: .specs-fire/intents/*/brief.md</action>
+      <action>Extract intent IDs from directory names</action>
+      <output>Found intent directories: {list}</output>
+    </substep>
+
+    <substep n="1b" title="List All Work Item Files">
+      <action>Use Glob to list: .specs-fire/intents/*/work-items/*.md</action>
+      <action>Extract work item IDs and their parent intents</action>
+      <output>Found work item files: {list}</output>
+    </substep>
+
+    <substep n="1c" title="Compare with state.yaml">
+      <action>Read state.yaml for known intents and work items</action>
+      <action>Compare file system list against state.yaml entries</action>
+    </substep>
+
+    <substep n="1d" title="Reconcile Differences">
+      <check if="intent directory exists but not in state.yaml">
+        <output>
+          **Discovered new intent**: {intent-id}
+          (exists in file system but not in state.yaml)
+        </output>
+        <action>Parse brief.md frontmatter for intent metadata</action>
+        <action>Add intent to state.yaml with status: active</action>
+        <action>Scan its work-items/ folder</action>
+      </check>
+
+      <check if="work item file exists but not in state.yaml">
+        <output>
+          **Discovered new work item**: {work-item-id} in {intent-id}
+          (exists in file system but not in state.yaml)
+        </output>
+        <action>Parse work item frontmatter for metadata</action>
+        <action>Add work item to state.yaml with status: pending</action>
+      </check>
+
+      <check if="work item exists in both but status mismatch">
+        <note>
+          state.yaml is authoritative for status (tracks run history).
+          Frontmatter status may be stale from initial creation.
+        </note>
+        <output>
+          **Status mismatch**: {work-item-id}
+          - state.yaml: {state_status}
+          - frontmatter: {frontmatter_status}
+          (Using state.yaml as authoritative)
+        </output>
+        <action if="frontmatter says pending but state says completed">
+          Update work item frontmatter to match state.yaml
+        </action>
+        <action if="state says pending but frontmatter says completed">
+          Flag for review - work may have been done outside FIRE
+        </action>
+      </check>
+
+      <check if="in state.yaml but file missing">
+        <output>Warning: {item} in state but file not found on disk</output>
+      </check>
+    </substep>
+
+    <output>
+      ## File System Scan Complete
+
+      Intents on disk: {count}
+      Intents in state.yaml: {count}
+      Work items on disk: {count}
+      Work items in state.yaml: {count}
+
+      {if new items discovered}
+      **Newly discovered (added to state.yaml)**:
+      {list new items}
+      {/if}
+    </output>
+  </step>
+
+  <step n="2" title="Collect Pending Work Items">
+    <action>Filter work items with status == pending</action>
+    <action>Group by intent</action>
+    <action>Note mode (after autonomy_bias applied) for each</action>
+    <action>Identify dependencies within and across intents</action>
+
+    <check if="no pending work items">
+      <output>
+        No pending work items found.
+
+        Create a new intent? [Y/n]
+      </output>
+      <check if="response == y">
+        <route-to>planner-agent (intent-capture)</route-to>
+      </check>
+      <stop/>
+    </check>
+  </step>
+
+  <step n="3" title="Analyze Groupings">
+    <action>Read workspace.autonomy_bias from state.yaml</action>
+    <action>Read workspace.run_scope_preference from state.yaml (if exists)</action>
+
+    <grouping-rules>
+      <rule>Dependencies = SEQUENTIAL execution in SAME run (NOT separate runs)</rule>
+      <rule>Different modes CAN be in same run (executed sequentially)</rule>
+      <rule>Cross-intent items allowed in same run if compatible</rule>
+      <rule>Validate mode items may benefit from running alone (more checkpoints)</rule>
+    </grouping-rules>
+
+    <generate-options>
+      <option name="single">
+        Each work item in its own run
+        Total runs: {count of pending items}
+      </option>
+
+      <option name="batch">
+        All pending items in ONE run
+        Execute sequentially (dependencies respected by order)
+        Checkpoints pause at confirm/validate items
+        Total runs: 1
+      </option>
+
+      <option name="wide">
+        Same as batch - all items in one run
+        Total runs: 1
+      </option>
+    </generate-options>
+  </step>
+
+  <step n="4" title="Present Options">
+    <action>Determine recommended option based on:</action>
+    <substep>autonomy_bias (autonomous→batch, controlled→single)</substep>
+    <substep>run_scope_preference (user's historical choice)</substep>
+    <substep>Number of pending items (few items→single is fine)</substep>
+
+    <output>
+      ## Run Planning
+
+      **Found**: {count} pending work items across {intent_count} intent(s)
+
+      {for each intent with pending items}
+      **{intent.title}**:
+      {for each pending item}
+      - {item.title} ({item.mode})
+      {/for}
+      {/for}
+
+      {if dependencies exist}
+      **Dependencies** (determines execution order):
+      - {dependent_item} depends on {dependency_item}
+      {/if}
+
+      ---
+
+      **How would you like to execute?**
+
+      **[1] One at a time** — {single_count} separate runs
+          Most controlled, review after each run
+
+      **[2] Sequential chain** — 1 run with {count} items (Recommended)
+          Execute in order: {item1} → {item2} → ...
+          Checkpoints pause at confirm/validate items
+
+      **[3] All together** — Same as [2]
+          1 run, sequential execution
+
+      Choose [1/2/3]:
+    </output>
+  </step>
+
+  <step n="5" title="Process Choice">
+    <check if="response == 1">
+      <set>run_scope = single</set>
+      <set>work_items_for_run = [first_pending_item]</set>
+    </check>
+    <check if="response == 2 or response == 3">
+      <set>run_scope = batch</set>
+      <set>work_items_for_run = all_pending_items_in_dependency_order</set>
+    </check>
+  </step>
+
+  <step n="6" title="Learn Preference">
+    <action>Update workspace.run_scope_preference in state.yaml</action>
+    <action>Add to workspace.run_scope_history (keep last 10)</action>
+
+    <history-entry>
+      choice: {run_scope}
+      items_count: {count}
+      timestamp: {now}
+    </history-entry>
+
+    <note>
+      After 3+ consistent choices, start pre-selecting that option
+      and ask "Proceed with {preference}? [Y/n/change]" instead
+    </note>
+  </step>
+
+  <step n="7" title="Confirm Run">
+    <output>
+      Starting run with {count} work item(s):
+
+      {for each item in work_items_for_run}
+      {index}. {item.title} ({item.mode})
+      {/for}
+
+      Items will execute sequentially within this run.
+      {if any item is confirm or validate}
+      Checkpoints will pause for approval at confirm/validate items.
+      {/if}
+
+      ---
+
+      Begin execution? [Y/n]
+    </output>
+    <check if="response == y">
+      <invoke-skill args="work_items_for_run, run_scope">run-execute</invoke-skill>
+    </check>
+  </step>
+
+</skill>
+```
+
+---
+
+## State Schema Updates
+
+**workspace section additions**:
+```yaml
+workspace:
+  # ... existing fields ...
+  run_scope_preference: batch  # single | batch | wide (learned)
+  run_scope_history:
+    - choice: batch
+      items_count: 4
+      timestamp: 2026-01-19T10:00:00Z
+```
+
+**active_run with multi-item support**:
+```yaml
+active_run:
+  id: run-001
+  scope: batch  # single | batch | wide
+  work_items:
+    - id: 01-stats-data-model
+      intent: session-stats
+      mode: autopilot
+      status: completed
+    - id: 02-stats-api-endpoint
+      intent: session-stats
+      mode: autopilot
+      status: in_progress
+  current_item: 02-stats-api-endpoint
+  started: 2026-01-19T10:00:00Z
+```
+
+---
+
+## File Discovery Logic
+
+```
+.specs-fire/
+├── intents/
+│   ├── user-auth/
+│   │   ├── brief.md           ← Parse frontmatter for intent metadata
+│   │   └── work-items/
+│   │       ├── login-endpoint.md   ← Parse for work item metadata
+│   │       └── session-mgmt.md
+│   └── analytics/
+│       ├── brief.md
+│       └── work-items/
+│           └── dashboard.md
+```
+
+**Frontmatter parsing**:
+- Extract `id`, `title`, `status` from YAML frontmatter
+- If status missing, default to `pending`
+- If in file but not state.yaml, add to state
+
+---
+
+## Grouping Algorithm
+
+```
+1. Collect all pending items with their modes
+2. Build dependency graph
+3. Sort items in dependency order (dependencies first)
+4. For "single" option:
+   - Each item is its own run
+5. For "batch" or "wide" option:
+   - ALL items in ONE run
+   - Execution order follows dependency graph
+   - Checkpoints pause at confirm/validate items
+```
+
+---
+
+## Recommendation Logic
+
+```
+IF run_scope_history has 3+ same choices:
+  pre_selected = most_common_choice
+
+ELSE IF autonomy_bias == autonomous:
+  recommended = batch (all in one run)
+
+ELSE IF autonomy_bias == controlled:
+  recommended = single
+
+ELSE: # balanced
+  IF pending_count <= 2:
+    recommended = single
+  ELSE:
+    recommended = batch
+```

package/flows/fire/agents/builder/skills/run-status/SKILL.md

@@ -0,0 +1,94 @@
+# Skill: Run Status
+
+Display current run status and progress.
+
+---
+
+## Trigger
+
+- User asks about run status
+- During long-running execution
+
+---
+
+## Workflow
+
+```xml
+<skill name="run-status">
+
+  <step n="1" title="Check Active Run">
+    <action>Read state.yaml for active_run</action>
+    <check if="no active run">
+      <output>
+        No active run. Last completed run: {last-run-id}
+      </output>
+      <stop/>
+    </check>
+  </step>
+
+  <step n="2" title="Display Status">
+    <output>
+      ## Run Status: {run-id}
+
+      **Work Item**: {title}
+      **Intent**: {intent-title}
+      **Mode**: {mode}
+      **Started**: {started}
+      **Duration**: {elapsed}
+
+      ### Progress
+
+      - [x] Initialize run
+      - [x] Load context
+      {checkpoint status}
+      - [{status}] Execute implementation
+      - [ ] Run tests
+      - [ ] Generate walkthrough
+
+      ### Files Changed So Far
+
+      Created: {created-count}
+      Modified: {modified-count}
+
+      ### Recent Activity
+
+      {last 5 actions}
+    </output>
+  </step>
+
+</skill>
+```
+
+---
+
+## Example Output
+
+```
+## Run Status: run-003
+
+**Work Item**: Add session management
+**Intent**: User Authentication
+**Mode**: confirm
+**Started**: 2026-01-19T10:30:00Z
+**Duration**: 12 minutes
+
+### Progress
+
+- [x] Initialize run
+- [x] Load context
+- [x] Plan approved (Checkpoint 1)
+- [~] Execute implementation
+- [ ] Run tests
+- [ ] Generate walkthrough
+
+### Files Changed So Far
+
+Created: 2
+Modified: 1
+
+### Recent Activity
+
+- Created src/auth/session.ts
+- Created src/auth/session.test.ts
+- Modified src/auth/index.ts
+```

package/flows/fire/agents/builder/skills/walkthrough-generate/SKILL.md

@@ -0,0 +1,140 @@
+# Skill: Walkthrough Generate
+
+Generate implementation walkthrough for human review after run completion.
+
+---
+
+## Trigger
+
+- Run completed successfully
+- Invoked by run-execute skill
+
+---
+
+## Degrees of Freedom
+
+**LOW** — Follow walkthrough structure precisely. Be thorough but concise.
+
+---
+
+## Workflow
+
+```xml
+<skill name="walkthrough-generate">
+
+  <mandate>
+    ALWAYS generate walkthrough after run completion.
+    Document DECISIONS, not just changes.
+    Include verification steps - how to test this works.
+  </mandate>
+
+  <step n="1" title="Gather Implementation Data">
+    <action>Read run log from .specs-fire/runs/{run-id}/run.md</action>
+    <action>Collect:</action>
+    <substep>Work item details (id, title, intent)</substep>
+    <substep>Files created during implementation</substep>
+    <substep>Files modified during implementation</substep>
+    <substep>Decisions made during execution</substep>
+    <substep>Tests added and coverage</substep>
+  </step>
+
+  <step n="2" title="Analyze Implementation">
+    <action>For each file created/modified:</action>
+    <substep>Identify purpose of the file</substep>
+    <substep>Summarize key changes</substep>
+    <substep>Note patterns or approaches used</substep>
+  </step>
+
+  <step n="3" title="Document Key Details">
+    <action>Extract implementation highlights:</action>
+    <substep>Main flow/algorithm implemented</substep>
+    <substep>Security considerations (if applicable)</substep>
+    <substep>Performance considerations (if applicable)</substep>
+    <substep>Integration points with existing code</substep>
+  </step>
+
+  <step n="4" title="Create Verification Steps">
+    <action>Generate how-to-verify section:</action>
+    <substep>Commands to run the feature</substep>
+    <substep>Expected behavior/output</substep>
+    <substep>Manual test scenarios</substep>
+  </step>
+
+  <step n="5" title="Generate Walkthrough">
+    <action>Generate walkthrough using template: templates/walkthrough.md.hbs</action>
+    <action>Save to: .specs-fire/runs/{run-id}/walkthrough.md</action>
+    <output>
+      Walkthrough generated: .specs-fire/runs/{run-id}/walkthrough.md
+    </output>
+  </step>
+
+</skill>
+```
+
+---
+
+## Output
+
+**Walkthrough** (`.specs-fire/runs/{run-id}/walkthrough.md`):
+
+```markdown
+---
+run: {run-id}
+work_item: {work-item-id}
+intent: {intent-id}
+generated: {timestamp}
+mode: {mode}
+---
+
+# Implementation Walkthrough: {title}
+
+## Summary
+
+{2-3 sentences describing what was implemented}
+
+## Files Changed
+
+### Created
+
+| File | Purpose |
+|------|---------|
+| `{path}` | {purpose} |
+
+### Modified
+
+| File | Changes |
+|------|---------|
+| `{path}` | {changes} |
+
+## Key Implementation Details
+
+### 1. {Detail Title}
+
+{description of implementation approach}
+
+## Decisions Made
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| {decision} | {choice} | {rationale} |
+
+## How to Verify
+
+1. **{Step Title}**
+   ```bash
+   {command}
+   ```
+   Expected: {expected output}
+
+2. **{Step Title}**
+   {manual verification steps}
+
+## Test Coverage
+
+- Tests added: {count}
+- Coverage: {percentage}%
+- Status: {passing/failing}
+
+---
+*Generated by FIRE Run {run-id}*
+```