aiblueprint-cli 1.4.41 → 1.4.42

package/claude-code-config/skills/{workflow-apex → apex}/steps/step-05-examine.md

@@ -21,10 +21,12 @@ next_step: steps/step-06-resolve.md
 
 ## EXECUTION PROTOCOLS:
 
-- 🎯 Launch parallel review agents (unless economy_mode)
+- 🎯 Launch 3+ parallel review agents via Task tool in ONE message (unless economy_mode)
+- 🛑 NEVER launch only 1 review agent — you MUST launch Security + Logic + Clean Code as separate agents
 - 💾 Document all findings with severity
 - 📖 Create todos for each finding
 - 🚫 FORBIDDEN to skip security analysis
+- 🚫 FORBIDDEN to combine review categories into a single agent
 
 ## CONTEXT BOUNDARIES:
 
@@ -32,6 +34,7 @@ next_step: steps/step-06-resolve.md
 - All tests pass
 - Now looking for issues that tests miss
 - Adversarial mindset - assume bugs exist
+- **If `{teams_mode}` = true:** Agent team is still alive. Do NOT shutdown teammates — that happens in step-09-finish only.
 
 ## YOUR TASK:
 
@@ -102,38 +105,80 @@ Group files: source, tests, config, other.
 ```
 
 **If `{economy_mode}` = false:**
-→ Launch parallel review agents
+→ Launch parallel review agents using the **Task tool**
 
-**CRITICAL: Launch ALL in a SINGLE message:**
+**🛑 CRITICAL: You MUST launch ALL 3 agents (or 4 if Next.js) in a SINGLE message using MULTIPLE Task tool calls. DO NOT launch them one at a time. DO NOT use only 1 agent. Each agent reviews a DIFFERENT aspect.**
 
-**Agent 1: Security** (`code-reviewer`)
+First, gather the list of modified files:
+```bash
+git diff --name-only HEAD~1
 ```
-Review for OWASP Top 10:
-- Injection flaws
-- Auth/authz issues
-- Data exposure
-- Security misconfiguration
+
+Then, in **ONE message with 3+ parallel Task tool calls**, launch:
+
+---
+
+**Agent 1: Security Review** — `subagent_type: "code-reviewer"`
+```
+prompt: |
+  You are a SECURITY reviewer. Review ONLY the following files for security vulnerabilities:
+  {list of modified files}
+
+  Focus exclusively on:
+  - OWASP Top 10: injection flaws (SQL, command, XSS)
+  - Authentication and authorization issues
+  - Sensitive data exposure (secrets, tokens, PII in logs)
+  - Security misconfiguration
+  - Insecure deserialization
+  - Missing input validation at system boundaries
+
+  For each finding, provide: file:line, severity (CRITICAL/HIGH/MEDIUM/LOW), description, and suggested fix.
+  If no security issues found, explicitly state "No security issues found."
 ```
 
-**Agent 2: Logic** (`code-reviewer`)
+---
+
+**Agent 2: Logic & Edge Cases Review** — `subagent_type: "code-reviewer"`
 ```
-Review for:
-- Edge cases not handled
-- Race conditions
-- Null handling
-- Incorrect logic
+prompt: |
+  You are a LOGIC reviewer. Review ONLY the following files for logic correctness:
+  {list of modified files}
+
+  Focus exclusively on:
+  - Edge cases not handled (empty arrays, null/undefined, boundary values)
+  - Race conditions and concurrency issues
+  - Incorrect conditional logic or off-by-one errors
+  - Missing error handling for failure modes
+  - State management bugs
+  - Incorrect assumptions about data shape or types
+
+  For each finding, provide: file:line, severity (CRITICAL/HIGH/MEDIUM/LOW), description, and suggested fix.
+  If no logic issues found, explicitly state "No logic issues found."
 ```
 
-**Agent 3: Clean Code** (`code-reviewer`)
+---
+
+**Agent 3: Clean Code & Quality Review** — `subagent_type: "code-reviewer"`
 ```
-Review for:
-- SOLID violations
-- Code smells
-- Complexity issues
-- Duplication >20 lines
+prompt: |
+  You are a CLEAN CODE reviewer. Review ONLY the following files for code quality:
+  {list of modified files}
+
+  Focus exclusively on:
+  - SOLID principle violations
+  - Code smells (long methods, god objects, feature envy)
+  - Cyclomatic complexity > 10
+  - Code duplication > 20 lines
+  - Naming that doesn't communicate intent
+  - Functions doing too many things
+
+  For each finding, provide: file:line, severity (CRITICAL/HIGH/MEDIUM/LOW), description, and suggested fix.
+  If no quality issues found, explicitly state "No quality issues found."
 ```
 
-**Agent 4: Vercel/Next.js Best Practices** (CONDITIONAL)
+---
+
+**Agent 4: Vercel/Next.js Best Practices** (CONDITIONAL — launch alongside Agents 1-3)
 
 → **Detection:** Check if modified files match Next.js/Vercel patterns:
 ```
@@ -145,22 +190,32 @@ Review for:
 - Server components, client components
 ```
 
-→ **If Next.js/Vercel code detected:**
+→ **If Next.js/Vercel code detected:** Add a 4th parallel Task tool call:
 
-Launch additional agent using Skill tool:
-```yaml
-skill: "vercel-react-best-practices"
+`subagent_type: "code-reviewer"`
+```
+prompt: |
+  You are a NEXT.JS / REACT PERFORMANCE reviewer. Review ONLY the following files:
+  {list of modified files}
+
+  Focus exclusively on:
+  - Sequential awaits that should use Promise.all for parallel fetching
+  - Barrel imports causing bundle bloat (import from index files)
+  - Missing dynamic imports for heavy client components
+  - Server-side caching opportunities (React cache, unstable_cache)
+  - Unnecessary re-renders (missing memo, useMemo, useCallback)
+  - Wrong Server vs Client component boundaries
+  - Data fetching patterns (preloading, parallel fetching, waterfall detection)
+
+  For each finding, provide: file:line, severity (CRITICAL/HIGH/MEDIUM/LOW), description, and suggested fix.
+  If no performance issues found, explicitly state "No performance issues found."
 ```
 
-This agent reviews for:
-- Async parallel patterns (Promise.all vs sequential awaits)
-- Bundle optimization (barrel imports, dynamic imports)
-- Server-side caching (React cache, unstable_cache)
-- Re-render optimization (memo, useMemo, useCallback usage)
-- Server vs Client component boundaries
-- Data fetching patterns (preloading, parallel fetching)
+→ **If NOT Next.js/Vercel code:** Skip this agent (launch only Agents 1-3)
+
+---
 
-→ **If NOT Next.js/Vercel code:** Skip this agent
+**🛑 REMINDER: You MUST have 3+ Task tool calls in a SINGLE response. If you only launched 1 agent, you are doing it WRONG. Go back and launch all agents.**
 
 ### 4. Classify Findings
 
@@ -257,10 +312,12 @@ Append to `{output_dir}/05-examine.md`:
 
 ## FAILURE MODES:
 
+❌ **CRITICAL**: Launching only 1 review agent instead of 3+ — each category (Security, Logic, Clean Code) MUST be a separate agent
+❌ Combining multiple review categories into a single agent prompt
 ❌ Skipping security review
 ❌ Not classifying by severity
 ❌ Auto-dismissing findings
-❌ Launching agents sequentially
+❌ Launching agents sequentially instead of in parallel
 ❌ Using subagents when economy_mode
 ❌ Skipping Vercel/Next.js review when React/Next.js files are modified
 ❌ **CRITICAL**: Not using AskUserQuestion for review → resolve/test transition

package/claude-code-config/skills/{workflow-apex → apex}/steps/step-06-resolve.md

@@ -31,6 +31,7 @@ next_step: COMPLETE
 - Some are Real, some Noise, some Uncertain
 - User may want different resolution strategies
 - Must validate after any changes
+- **If `{teams_mode}` = true:** Agent team is still alive. Do NOT shutdown teammates — that happens in step-09-finish only.
 
 ## YOUR TASK:
 

package/claude-code-config/skills/{workflow-apex → apex}/steps/step-09-finish.md

@@ -25,7 +25,7 @@ previous_step: step-08-run-tests.md (or step-04-validate.md if no tests)
 
 ## CONTEXT BOUNDARIES:
 
-- Variables available: `{task_id}`, `{task_description}`, `{branch_name}`, `{pr_mode}`, `{auto_mode}`, `{save_mode}`, `{output_dir}`
+- Variables available: `{task_id}`, `{task_description}`, `{branch_name}`, `{pr_mode}`, `{auto_mode}`, `{save_mode}`, `{teams_mode}`, `{output_dir}`
 - Previous steps completed: analyze, plan, execute, validate (+ optional: tests, examine)
 - All implementation should be done at this point
 
@@ -37,6 +37,32 @@ Finalize the APEX workflow by committing remaining changes, pushing to remote, a
 
 ## EXECUTION SEQUENCE:
 
+### 0. Shutdown Agent Team (if teams_mode)
+
+<critical>
+This is the ONLY step where team shutdown should happen.
+All previous steps (validate, examine, resolve) keep the team alive.
+</critical>
+
+**If `{teams_mode}` = true:**
+
+1. Send shutdown_request to each teammate:
+```
+SendMessage:
+  type: "shutdown_request"
+  recipient: "impl-{name}"
+  content: "APEX workflow complete. Shutting down team."
+```
+
+2. Wait for all teammates to confirm shutdown.
+
+3. Delete the team:
+```
+TeamDelete
+```
+
+→ This cleans up team files and task directories.
+
 ### 1. Verify Git Status
 
 ```bash
@@ -167,6 +193,8 @@ Display workflow completion summary:
 
 ## SUCCESS METRICS:
 
+✅ Agent team shut down gracefully via SendMessage shutdown_request (if teams_mode)
+✅ TeamDelete called to clean up team resources (if teams_mode)
 ✅ All changes committed
 ✅ Branch pushed to remote
 ✅ PR created with proper title and description (if pr_mode)
@@ -189,5 +217,7 @@ Display workflow completion summary:
 This is the final step of the APEX workflow. No next step to load.
 
 <critical>
-Remember: This step ONLY handles git operations and PR creation. All code changes should have been completed in earlier steps.
+Remember: This step handles git operations, PR creation, AND team shutdown (if teams_mode).
+All code changes should have been completed in earlier steps.
+Team shutdown MUST happen here — step 0 of execution sequence — before git operations.
 </critical>

package/claude-code-config/skills/{workflow-apex → apex}/templates/00-context.md

@@ -17,6 +17,7 @@
 | Branch mode (`-b`) | {{branch_mode}} |
 | PR mode (`-pr`) | {{pr_mode}} |
 | Interactive mode (`-i`) | {{interactive_mode}} |
+| Tasks mode (`-k`) | {{tasks_mode}} |
 | Branch name | {{branch_name}} |
 
 ---
@@ -42,6 +43,7 @@ _To be defined in step-01-analyze.md_
 | 00-init | ⏸ Pending | |
 | 01-analyze | ⏸ Pending | |
 | 02-plan | ⏸ Pending | |
+| 02b-tasks | {{tasks_status}} | |
 | 03-execute | ⏸ Pending | |
 | 04-validate | ⏸ Pending | |
 | 05-examine | {{examine_status}} | |

package/claude-code-config/skills/{meta-claude-memory → claude-memory}/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: claude-memory
 description: Create and optimize CLAUDE.md memory files or .claude/rules/ modular rules for Claude Code projects. Comprehensive guidance on file hierarchy, content structure, path-scoped rules, best practices, and anti-patterns. Use when working with CLAUDE.md files, .claude/rules directories, setting up new projects, or improving Claude Code's context awareness.
-argument-hint: [task description or "optimize"]
+argument-hint: [init | optimize | task description]
 ---
 
 <core_principle>
@@ -168,6 +168,64 @@ Before creating or updating memory files, use AskUserQuestion:
 | Path rules not applying | Verify glob pattern matches target files |
 </workflow>
 
+<init_workflow>
+## `/claude-memory init` — Create Minimal CLAUDE.md
+
+When the user argument contains "init", execute this workflow to scaffold a CLAUDE.md with only the essential sections.
+
+### Step 1: Detect project context
+
+Read `package.json` (or equivalent: `pyproject.toml`, `Cargo.toml`, `go.mod`, etc.) to detect:
+- Project name
+- Tech stack (framework, language)
+- Available scripts/commands (dev, build, test)
+
+Also check for existing linter configs (ESLint, Biome, Prettier, tsconfig) — do NOT include rules they already enforce.
+
+### Step 2: Identify important files
+
+Scan for non-obvious architecture-critical files. Look for:
+- Auth config files
+- Server action wrappers, API helpers
+- Database schema files
+- Custom middleware or shared utilities
+- Skip standard framework files (package.json, tsconfig, next.config, etc.)
+
+### Step 3: Generate CLAUDE.md
+
+Create the file with ONLY these sections. Each section should be compact — the whole file should be under 50 lines.
+
+```markdown
+# [Project Name]
+[One-line description of what this project is]
+
+## Tech Stack
+- [Only non-obvious technologies — skip deps detectable from config files]
+
+## Commands
+- `[dev command]` - Dev server
+- `[build command]` - Build
+- `[test command]` - Tests
+- [Any non-obvious commands like db:push, seed, etc.]
+
+## Important Files
+- [Only files the agent wouldn't discover naturally]
+
+## Rules
+- [Leave empty with a comment: "Add project-specific rules as you encounter friction"]
+```
+
+### Step 4: Present and write
+
+Show the generated file to the user. Write it to `./CLAUDE.md` after approval.
+
+**Rules:**
+- NEVER include directory structure, code style rules, generic best practices, or marketing text
+- NEVER include anything a linter or TypeScript already enforces
+- Target: 20-50 lines. If it's longer, you're including too much
+- The Rules section starts empty — it gets populated over time as mistakes happen
+</init_workflow>
+
 <optimize_workflow>
 ## `/claude-memory optimize` — Deep CLAUDE.md Cleanup
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiblueprint-cli",
-  "version": "1.4.41",
+  "version": "1.4.42",
   "description": "AIBlueprint CLI for setting up Claude Code configurations",
   "author": "AIBlueprint",
   "license": "MIT",

package/claude-code-config/skills/workflow-apex/SKILL.md

@@ -1,303 +0,0 @@
----
-name: apex
-description: Systematic implementation using APEX methodology (Analyze-Plan-Execute-eXamine) with parallel agents, self-validation, and optional adversarial review. Use when implementing features, fixing bugs, or making code changes that benefit from structured workflow.
-argument-hint: "[-a] [-x] [-s] [-t] [-b] [-pr] [-i] [-r <task-id>] <task description>"
----
-
-<objective>
-Execute systematic implementation workflows using the APEX methodology. This skill uses progressive step loading to minimize context usage and supports saving outputs for review and resumption.
-</objective>
-
-<quick_start>
-**Basic usage:**
-
-```bash
-/apex add authentication middleware
-```
-
-**Recommended workflow (autonomous with save):**
-
-```bash
-/apex -a -s implement user registration
-```
-
-**With adversarial review:**
-
-```bash
-/apex -a -x -s fix login bug
-```
-
-**Flags:**
-
-- `-a` (auto): Skip confirmations
-- `-s` (save): Save outputs to `.claude/output/apex/`
-- `-x` (examine): Include adversarial code review
-- `-t` (test): Create and run tests
-- `-pr` (pull-request): Create PR at end
-
-See `<parameters>` for complete flag list.
-</quick_start>
-
-<parameters>
-
-<flags>
-**Enable flags (turn ON):**
-| Short | Long | Description |
-|-------|------|-------------|
-| `-a` | `--auto` | Autonomous mode: skip confirmations, auto-approve plans |
-| `-x` | `--examine` | Auto-examine mode: proceed to adversarial review |
-| `-s` | `--save` | Save mode: output each step to `.claude/output/apex/` |
-| `-t` | `--test` | Test mode: include test creation and runner steps |
-| `-e` | `--economy` | Economy mode: no subagents, save tokens (for limited plans) |
-| `-r` | `--resume` | Resume mode: continue from a previous task |
-| `-b` | `--branch` | Branch mode: verify not on main, create branch if needed |
-| `-pr` | `--pull-request` | PR mode: create pull request at end (enables -b) |
-| `-i` | `--interactive` | Interactive mode: configure flags via AskUserQuestion |
-
-**Disable flags (turn OFF):**
-| Short | Long | Description |
-|-------|------|-------------|
-| `-A` | `--no-auto` | Disable auto mode |
-| `-X` | `--no-examine` | Disable examine mode |
-| `-S` | `--no-save` | Disable save mode |
-| `-T` | `--no-test` | Disable test mode |
-| `-E` | `--no-economy` | Disable economy mode |
-| `-B` | `--no-branch` | Disable branch mode |
-| `-PR` | `--no-pull-request` | Disable PR mode |
-</flags>
-
-<examples>
-```bash
-# Basic
-/apex add auth middleware
-
-# Autonomous (skip confirmations)
-/apex -a add auth middleware
-
-# Save outputs + examine
-/apex -a -x -s add auth middleware
-
-# Full workflow with tests
-/apex -a -x -s -t add auth middleware
-
-# With PR creation
-/apex -a -pr add auth middleware
-
-# Resume previous task
-/apex -r 01-auth-middleware
-/apex -r 01  # Partial match
-
-# Economy mode (save tokens)
-/apex -e add auth middleware
-
-# Interactive flag config
-/apex -i add auth middleware
-
-# Disable flags (uppercase)
-/apex -A add auth middleware  # Disable auto
-```
-</examples>
-
-<parsing_rules>
-**Flag parsing:**
-
-1. Defaults loaded from `steps/step-00-init.md` `<defaults>` section
-2. Command-line flags override defaults (enable with lowercase `-x`, disable with uppercase `-X`)
-3. Flags removed from input, remainder becomes `{task_description}`
-4. Task ID generated as `NN-kebab-case-description`
-
-For detailed parsing algorithm, see `steps/step-00-init.md`.
-</parsing_rules>
-
-</parameters>
-
-<output_structure>
-**When `{save_mode}` = true:**
-
-All outputs saved to PROJECT directory (where Claude Code is running):
-```
-
-.claude/output/apex/{task-id}/
-├── 00-context.md # Params, user request, timestamp
-├── 01-analyze.md # Analysis findings
-├── 02-plan.md # Implementation plan
-├── 03-execute.md # Execution log
-├── 04-validate.md # Validation results
-├── 05-examine.md # Review findings (if -x)
-├── 06-resolve.md # Resolution log (if -x)
-├── 07-tests.md # Test analysis and creation (if --test)
-├── 08-run-tests.md # Test runner log (if --test)
-└── 09-finish.md # Workflow finish and PR creation (if --pull-request)
-
-````
-
-**00-context.md structure:**
-```markdown
-# APEX Task: {task_id}
-
-**Created:** {timestamp}
-**Task:** {task_description}
-
-## Flags
-- Auto mode: {auto_mode}
-- Examine mode: {examine_mode}
-- Save mode: {save_mode}
-- Test mode: {test_mode}
-
-## User Request
-{original user input}
-
-## Acceptance Criteria
-- [ ] AC1: {inferred criterion}
-- [ ] AC2: {inferred criterion}
-````
-
-</output_structure>
-
-<resume_workflow>
-**Resume mode (`-r {task-id}`):**
-
-When provided, step-00 will:
-
-1. Locate the task folder in `.claude/output/apex/`
-2. Restore state from `00-context.md`
-3. Find the last completed step
-4. Continue from the next step
-
-Supports partial matching (e.g., `-r 01` finds `01-add-auth-middleware`).
-
-For implementation details, see `steps/step-00-init.md`.
-</resume_workflow>
-
-<workflow>
-**Standard flow:**
-1. Parse flags and task description
-2. If `-r`: Execute resume workflow
-3. If `-s`: Create output folder and 00-context.md
-4. Load step-01-analyze.md → gather context
-5. Load step-02-plan.md → create strategy
-6. Load step-03-execute.md → implement
-7. Load step-04-validate.md → verify
-8. If `--test`: Load step-07-tests.md → analyze and create tests
-9. If `--test`: Load step-08-run-tests.md → run until green
-10. If `-x` or user requests: Load step-05-examine.md → adversarial review
-11. If findings: Load step-06-resolve.md → fix findings
-12. If `-pr`: Load step-09-finish.md → create pull request
-</workflow>
-
-<state_variables>
-**Persist throughout all steps:**
-
-| Variable                | Type    | Description                                            |
-| ----------------------- | ------- | ------------------------------------------------------ |
-| `{task_description}`    | string  | What to implement (flags removed)                      |
-| `{feature_name}`        | string  | Kebab-case name without number (e.g., `add-auth-middleware`) |
-| `{task_id}`             | string  | Full identifier with number (e.g., `01-add-auth-middleware`) |
-| `{acceptance_criteria}` | list    | Success criteria (inferred or explicit)                |
-| `{auto_mode}`           | boolean | Skip confirmations, use recommended options            |
-| `{examine_mode}`        | boolean | Auto-proceed to adversarial review                     |
-| `{save_mode}`           | boolean | Save outputs to .claude/output/apex/                   |
-| `{test_mode}`           | boolean | Include test steps (07-08)                             |
-| `{economy_mode}`        | boolean | No subagents, direct tool usage only                   |
-| `{branch_mode}`         | boolean | Verify not on main, create branch if needed            |
-| `{pr_mode}`             | boolean | Create pull request at end                             |
-| `{interactive_mode}`    | boolean | Configure flags interactively                          |
-| `{resume_task}`         | string  | Task ID to resume (if -r provided)                     |
-| `{output_dir}`          | string  | Full path to output directory                          |
-| `{branch_name}`         | string  | Created branch name (if branch_mode)                   |
-
-</state_variables>
-
-<entry_point>
-
-**FIRST ACTION:** Load `steps/step-00-init.md`
-
-Step 00 handles:
-
-- Flag parsing (-a, -x, -s, -r, --test)
-- Resume mode detection and task lookup
-- Output folder creation (if save_mode)
-- 00-context.md creation (if save_mode)
-- State variable initialization
-
-After initialization, step-00 loads step-01-analyze.md.
-
-</entry_point>
-
-<step_files>
-**Progressive loading - only load current step:**
-
-| Step | File                         | Purpose                                              |
-| ---- | ---------------------------- | ---------------------------------------------------- |
-| 00   | `steps/step-00-init.md`      | Parse flags, create output folder, initialize state  |
-| 01   | `steps/step-01-analyze.md`   | Smart context gathering with 1-10 parallel agents based on complexity |
-| 02   | `steps/step-02-plan.md`      | File-by-file implementation strategy                 |
-| 03   | `steps/step-03-execute.md`   | Todo-driven implementation                           |
-| 04   | `steps/step-04-validate.md`  | Self-check and validation                            |
-| 05   | `steps/step-05-examine.md`   | Adversarial code review (optional)                   |
-| 06   | `steps/step-06-resolve.md`   | Finding resolution (optional)                        |
-| 07   | `steps/step-07-tests.md`     | Test analysis and creation (if --test)               |
-| 08   | `steps/step-08-run-tests.md` | Test runner loop until green (if --test)             |
-| 09   | `steps/step-09-finish.md`    | Create pull request (if --pull-request)              |
-
-</step_files>
-
-<execution_rules>
-
-- **Load one step at a time** - Only load the current step file
-- **ULTRA THINK** before major decisions
-- **Persist state variables** across all steps
-- **Follow next_step directive** at end of each step
-- **Save outputs** if `{save_mode}` = true (append to step file)
-- **Use parallel agents** for independent exploration tasks
-
-## 🧠 Smart Agent Strategy in Analyze Phase
-
-The analyze phase (step-01) uses **adaptive agent launching** (unless economy_mode):
-
-**Available agents:**
-- `explore-codebase` - Find existing patterns, files, utilities
-- `explore-docs` - Research library docs (use when unfamiliar with API)
-- `websearch` - Find approaches, best practices, gotchas
-
-**Launch 1-10 agents based on task complexity:**
-
-| Complexity | Agents | When |
-|------------|--------|------|
-| Simple | 1-2 | Bug fix, small tweak |
-| Medium | 2-4 | New feature in familiar stack |
-| Complex | 4-7 | Unfamiliar libraries, integrations |
-| Major | 6-10 | Multiple systems, many unknowns |
-
-**BE SMART:** Analyze what you actually need before launching. Don't over-launch for simple tasks, don't under-launch for complex ones.
-
-</execution_rules>
-
-<save_output_pattern>
-**When `{save_mode}` = true:**
-
-Step-00 runs `scripts/setup-templates.sh` to initialize all output files from `templates/` directory.
-
-**Each step then:**
-
-1. Run `scripts/update-progress.sh {task_id} {step_num} {step_name} "in_progress"`
-2. Append findings/outputs to the pre-created step file
-3. Run `scripts/update-progress.sh {task_id} {step_num} {step_name} "complete"`
-
-**Template system benefits:**
-
-- Reduces token usage by ~75% (1,350 tokens saved per workflow)
-- Templates in `templates/` directory (not inline in steps)
-- Scripts handle progress tracking automatically
-- See `templates/README.md` for details
-
-</save_output_pattern>
-
-<success_criteria>
-
-- Each step loaded progressively
-- All validation checks passing
-- Outputs saved if `{save_mode}` enabled
-- Tests passing if `{test_mode}` enabled
-- Clear completion summary provided
-  </success_criteria>