--- name: run-execute description: Execute work items based on their assigned mode (autopilot, confirm, validate). Supports single-item and multi-item (batch/wide) runs. version: 1.0.0 --- Execute work items based on their assigned mode (autopilot, confirm, validate). Supports both single-item and multi-item (batch/wide) runs. Show current position in workflow: ```text ### Run Progress - [ ] Run initialized (init-run.cjs) - [ ] Context loaded - [ ] Plan generated ← {current_step} - [ ] Implementation - [ ] Tests passing - [ ] Code review - [ ] Run completed (complete-run.cjs) - [ ] Walkthrough generated ``` Update markers as you progress: [x] = done, ← current = active step Before executing scripts, ensure required dependencies are installed: Run: npm list yaml --depth=0 2>/dev/null || echo "NOT_FOUND" Installing required dependency: yaml Run: npm install yaml | Package | Purpose | Install Command | |---------|---------|-----------------| | `yaml` | Parse/stringify state.yaml | `npm install yaml` | - Pending work item ready for execution - Resumed from interrupted run - Batch of work items passed from run-plan Before starting execution, check if resuming an interrupted run: Check state.yaml for runs.active[] array No active run, start fresh Load active run from state.yaml runs.active[0] Read scope (single/batch/wide) and work_items array For EACH work item in runs.active[0].work_items, classify by status: Build status summary from state.yaml (NOT from artifact files): [DONE] {item-id} — completed [WORKING] {item-id} (phase: {current_phase}) — in_progress [PENDING] {item-id} — pending Count: completed={X}, in_progress={Y}, pending={Z} Get current_item from state.yaml Read current_phase from the current item's entry in work_items Use current_phase from state.yaml to determine resume point: | current_phase | Resume At | |---------------|-----------| | plan (or unset) | Step 3 (Generate Plan) | | execute | Step 5 (Implementation) | | test | Step 6 (Run Tests) | | review | Step 6b (Code Review) | NEVER call --complete-item for items with status "completed" — they are already done NEVER re-execute steps (plan, implement, test) for completed items ONLY work on the current_item identified in state.yaml Use current_phase from state.yaml — do NOT infer phase from artifact file existence Resuming run {run-id} ({scope}) for work item {current_item}. Mode: {mode} Phase: {current_phase} Status: {completed_count} done, {in_progress_count} working, {pending_count} pending Resuming at: Step {step_number} Varies by mode: - **Autopilot**: LOW — Execute standard patterns decisively - **Confirm**: MEDIUM — Present plan, adjust based on feedback - **Validate**: LOW — Follow approved design precisely USE SCRIPTS — NEVER bypass init-run.cjs or complete-run.cjs ALWAYS CREATE plan.md — Create plan BEFORE implementation starts (ALL modes) ALWAYS CREATE test-report.md — Create test report AFTER tests complete ALWAYS RUN code-review — Invoke code-review skill after tests pass TRACK ALL FILE OPERATIONS — Every create, modify MUST be recorded NEVER skip tests — Tests are mandatory, not optional FOLLOW BROWNFIELD RULES — Read before write, match existing patterns Artifacts MUST be created at these points: | Artifact | When Created | Created By | |----------|--------------|------------| | run.md | Start of run | init-run.cjs script | | plan.md | BEFORE implementation (Step 4) | Agent using template | | test-report.md | AFTER tests pass (Step 6) | Agent using template | | review-report.md | AFTER test report (Step 6b) | code-review skill | | walkthrough.md | After run completes (Step 8) | walkthrough-generate skill | For batch runs: Append each work item's section to plan.md and test-report.md. ⛔ HARD GATE - SCRIPT EXECUTION REQUIRED ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ You MUST call init-run.cjs script. DO NOT use mkdir or create files directly. The script creates BOTH the folder AND run.md file. If you skip this, state.yaml will be inconsistent. Prepare work items JSON array:


      # For single item:
      node scripts/init-run.cjs {rootPath} {workItemId} {intentId} {mode}

      # For batch/wide (multiple items):
      node scripts/init-run.cjs {rootPath} --batch '[
        {"id": "item-1", "intent": "intent-1", "mode": "autopilot"},
        {"id": "item-2", "intent": "intent-1", "mode": "confirm"}
      ]' --scope=batch

Parse script output for runId and runPath Verify run.md was created in .specs-fire/runs/{run-id}/ init-run.cjs failed to create run.md. Check script output. For batch runs, repeat steps 2-6b for each work item Get current_item from state.yaml runs.active[0] Load work item from .specs-fire/intents/{intent}/work-items/{id}.md Read intent brief for broader context Load project standards using hierarchical resolution: Scan repository for: **/.specs-fire/standards/ Build list sorted by path depth (root = depth 0) depth 0: .specs-fire/standards/ depth 2: packages/api/.specs-fire/standards/ depth 2: apps/mobile/.specs-fire/standards/ Load .specs-fire/standards/constitution.md from ROOT IGNORE any constitution.md in nested directories Constitution is ALWAYS inherited, NEVER overridden If constitution.md doesn't exist, skip gracefully For each discovered standards location (excluding root): FOR each standard_file IN [tech-stack.md, coding-standards.md, testing-standards.md, system-architecture.md]: IF {location}/standards/{standard_file} EXISTS: → USE this file for scope {location.parent_path}/** ELSE: → Walk UP to find nearest ancestor with this file → USE ancestor's file (ultimately root if none found) Present loaded standards with clear path-based scoping: ## Constitution (applies to ALL files) [content of root constitution.md] ## Standards for {module_path}/** files When editing files under {module_path}/, apply: - Tech Stack: [resolved tech-stack.md for this scope] - Coding Standards: [resolved coding-standards.md for this scope] - Testing Standards: [resolved testing-standards.md for this scope] ## Default Standards (paths without specific scope) For all other files, apply root standards. Determine execution mode from work item Executing in Autopilot mode (0 checkpoints). Work item: {title} Generate implementation plan Save plan IMMEDIATELY using template: templates/plan.md.hbs Write to: .specs-fire/runs/{run-id}/plan.md Plan saved to: .specs-fire/runs/{run-id}/plan.md Mark checkpoint as waiting: node scripts/update-checkpoint.cjs {rootPath} {runId} awaiting_approval --checkpoint=plan ## Implementation Plan for "{title}" ### Approach {describe approach} ### Files to Create {list files} ### Files to Modify {list files} ### Tests {list test files} --- Approve plan? [Y/n/edit] What changes to the plan? Adjust plan Update plan.md with changes Mark checkpoint approved: node scripts/update-checkpoint.cjs {rootPath} {runId} approved --checkpoint=plan Load design doc from .specs-fire/intents/{intent}/work-items/{id}-design.md Generate implementation plan based on design Save plan IMMEDIATELY using template: templates/plan.md.hbs Write to: .specs-fire/runs/{run-id}/plan.md Include reference to design doc in plan Plan saved to: .specs-fire/runs/{run-id}/plan.md Mark checkpoint as waiting: node scripts/update-checkpoint.cjs {rootPath} {runId} awaiting_approval --checkpoint=plan ## Implementation Plan for "{title}" Based on approved design document. ### Implementation Checklist {from design doc} ### Files to Create {list files} ### Files to Modify {list files} --- This is Checkpoint 2 of Validate mode. Approve implementation plan? [Y/n/edit] What changes to the plan? Adjust plan Update plan.md with changes Mark checkpoint approved: node scripts/update-checkpoint.cjs {rootPath} {runId} approved --checkpoint=plan Confirm and Validate modes already saved plan in Step 3b/3c Read existing plan.md content Append new section for current work item: --- ## Work Item: {work_item_id} ### Approach {describe approach for this specific work item} ### Files to Create {list files} ### Files to Modify {list files} ### Tests {list test files} Write updated plan.md (preserving previous sections) Generate implementation plan Save plan using template: templates/plan.md.hbs Write to: .specs-fire/runs/{run-id}/plan.md Plan saved to: .specs-fire/runs/{run-id}/plan.md (Autopilot mode - continuing without checkpoint) No checkpoint in autopilot - human can review plan.md while agent works Update phase to 'execute': node scripts/update-phase.cjs {rootPath} {runId} execute For each planned change: Implement the change Track file operation (create/modify) Record decisions made When editing a file at path X: 1. Find the LONGEST matching standards scope (most specific) 2. Apply those standards to the file 3. If no specific scope matches, apply root standards Editing packages/api/src/handler.go → Apply "Standards for packages/api/**" Editing scripts/deploy.sh → Apply "Default Standards" (root) READ existing code before modifying MATCH existing naming conventions FOLLOW existing patterns in the codebase PRESERVE existing tests USE module-specific standards when editing module files Update phase to 'test': node scripts/update-phase.cjs {rootPath} {runId} test Load testing standards from .specs-fire/standards/testing-standards.md Write tests following testing standards: Unit tests for new/modified functions Integration tests for API endpoints or workflows Follow test naming and structure conventions Run test suite Tests failed. Fixing issues... Fix failing tests Re-run tests Validate acceptance criteria from work item Create test report AFTER tests pass Read existing test-report.md content Append new section for current work item: --- ## Work Item: {work_item_id} ### Test Results - Passed: {passed_count} - Failed: {failed_count} - Skipped: {skipped_count} ### Acceptance Criteria Validation {validation_results} Write updated test-report.md (preserving previous sections) Generate test report using template: templates/test-report.md.hbs Write to: .specs-fire/runs/{run-id}/test-report.md Include in test report: Test results summary (passed/failed/skipped) Code coverage percentage Acceptance criteria validation results Any test warnings or notes Test report saved to: .specs-fire/runs/{run-id}/test-report.md Update phase to 'review': node scripts/update-phase.cjs {rootPath} {runId} review ALWAYS run code review after tests pass Running code review... Invoke code-review skill with context:


      invoke-skill: code-review
      context:
        files_created: {files_created}
        files_modified: {files_modified}
        run_id: {run_id}
        intent_id: {intent_id}

code-review Code review skill will: 1. Review all files created/modified in this work item 2. Auto-fix no-brainer issues (unused imports, console.log, etc.) 3. Present suggestions requiring approval 4. Create review-report.md artifact User interaction happens within code-review skill Wait for code-review skill to complete Re-run tests to verify fixes didn't break anything Code review fixes caused test failure. Reverting... Revert code review changes Re-run tests to confirm passing Code review complete. Review report: .specs-fire/runs/{run-id}/review-report.md ⛔ HARD GATE - SCRIPT EXECUTION REQUIRED ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ You MUST call complete-run.cjs script. DO NOT manually update state.yaml or run.md. Use --complete-item for batch runs with remaining items. Use --complete-run only when ALL items are done. If you skip this, state becomes inconsistent. BATCH RUNS: You MUST loop until ALL items are done NEVER call --complete-run until ALL items have artifacts ALWAYS check pending count BEFORE deciding which flag to use Read state.yaml runs.active[{runId}] Get scope value: single, batch, or wide Count work_items where status == "pending" Store pending_count for decision DO NOT call --complete-run yet - more items remain! Call complete-run.cjs with --complete-item flag:


          node scripts/complete-run.cjs {rootPath} {runId} --complete-item

Parse output JSON for nextItem and remainingItems Completed: {current_item} Next item: {nextItem} Remaining: {remainingItems} items MUST continue with next work item - loop back NOW All items complete - finalize the run Call complete-run.cjs with --complete-run flag:


          node scripts/complete-run.cjs {rootPath} {runId} --complete-run \
            --files-created='[{"path":"...","purpose":"..."}]' \
            --files-modified='[{"path":"...","changes":"..."}]' \
            --tests=5 --coverage=85

walkthrough-generate Run {run-id} completed. Work items completed: {count} Files created: {count} Files modified: {count} Tests added: {count} Artifacts: - Run Log: .specs-fire/runs/{run-id}/run.md - Plan: .specs-fire/runs/{run-id}/plan.md - Test Report: .specs-fire/runs/{run-id}/test-report.md - Code Review: .specs-fire/runs/{run-id}/review-report.md - Walkthrough: .specs-fire/runs/{run-id}/walkthrough.md | Script | Purpose | Usage | |--------|---------|-------| | `scripts/init-run.cjs` | Initialize run record and folder | Creates run.md with all work items | | `scripts/update-checkpoint.cjs` | Mark approval gate state for active item | `awaiting_approval` / `approved` | | `scripts/update-phase.cjs` | Update current work item's phase | `node scripts/update-phase.cjs {rootPath} {runId} {phase}` | | `scripts/complete-run.cjs` | Finalize run and update state | `--complete-item` or `--complete-run` | ```yaml files_created: - path: src/auth/login.ts purpose: Login endpoint handler files_modified: - path: src/routes/index.ts changes: Added login route decisions: - decision: Use JWT for tokens rationale: Stateless, works with load balancer ``` After init-run.cjs creates a run: ``` .specs-fire/runs/run-fabriqa-2026-001/ ├── run.md # Created by init-run.cjs, updated by complete-run.cjs ├── plan.md # Created BEFORE implementation (ALL modes - required) ├── test-report.md # Created AFTER tests pass (required) ├── review-report.md # Created by code-review skill (Step 6b) └── walkthrough.md # Created by walkthrough-generate skill ``` 1. `run.md` — Created at run start by init-run.cjs 2. `plan.md` — Created BEFORE implementation begins (Step 4) 3. `test-report.md` — Created AFTER tests pass (Step 6) 4. `review-report.md` — Created by code-review skill (Step 6b) 5. `walkthrough.md` — Created after run completes (Step 8) The run.md contains: - All work items with their statuses - Current item being executed - Files created/modified (after completion) - Decisions made (after completion) - Summary (after completion) Run initialized via init-run.cjs script Standards loaded with hierarchical resolution Constitution loaded from root (if exists) Module-specific standards applied to module files plan.md created BEFORE implementation All work items implemented All tests pass test-report.md created AFTER tests pass code-review skill invoked and completed review-report.md created Run completed via complete-run.cjs script walkthrough.md generated

run-execute

Install this skill

Comments