compound-agent 1.1.0 → 1.2.1

package/CHANGELOG.md

@@ -9,6 +9,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.1] - 2026-02-15
+
+### Added
+
+- **`ca verify-gates <epic-id>` command**: Verifies review and compound beads tasks exist and are closed before epic can be marked complete
+- **Phase enforcement gates in `/compound:lfg`**: Mechanical STOP markers (`PHASE GATE 3`, `PHASE GATE 4`, `FINAL GATE`) between workflow phases prevent Claude from skipping review and compound phases
+- **Per-phase MEMORY CHECK instructions**: Each of the 5 phases in lfg.md now has explicit `MEMORY CHECK` instructions for memory_search/memory_capture
+- **Phase state tracking**: lfg.md tracks phase completion via `bd update --notes` with `Phase: COMPLETE` markers, surviving context compaction
+- **SESSION CLOSE checklist in lfg.md**: Inviolable 8-step checklist at end of lfg workflow ensures bd sync and git push
+
+### Fixed
+
+- **`ca setup --update` now ensures MCP config**: Previously only regenerated templates; now also calls `configureClaudeSettings()` to ensure `.mcp.json` and hooks are current for projects upgrading from older versions
+- **`ca prime` warns when MCP server is missing**: Displays actionable warning with `Run 'npx ca setup'` when `.mcp.json` is not registered
+- **work.md verification gate strengthened**: Replaced soft "Verification Gate" with `MANDATORY VERIFICATION` section requiring `/implementation-reviewer` APPROVED status
+- **compound.md minimum capture requirement**: Added "At minimum, capture 1 lesson per significant decision" to prevent empty compound phases
+- **plan.md post-plan verification**: Added `POST-PLAN VERIFICATION` section with grep checks for review and compound task creation
+
+## [1.2.0] - 2026-02-15
+
+### Added
+
+- **`ca loop` command**: Generate autonomous infinity loop scripts that process beads epics end-to-end via chained Claude Code sessions
+- **HUMAN_REQUIRED marker**: Loop detects human-blocking issues, logs reason to beads, skips epic without stopping the loop
+- **Review+compound blocking tasks**: Plan phase now creates review and compound beads issues with dependencies, ensuring these phases survive context compaction and surface via `bd ready`
+
+### Fixed
+
+- **Loop script `set -u` crash**: `LOOP_DRY_RUN` now uses safe expansion (`${VAR:-}`) for `set -u` compatibility
+- **Infinite reprocessing**: Loop tracks processed epics to prevent re-selecting the same epic in dry-run or human-required paths
+- **Input validation**: `--max-retries` rejects non-integer values; epic IDs validated against safe pattern to prevent shell injection
+- **Exit codes**: `ca loop` now returns non-zero on errors (overwrite refusal, invalid options)
+
 ## [1.1.0] - 2026-02-15
 
 ### Added
@@ -423,7 +456,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Vitest test suite
   - tsup build configuration
 
-[Unreleased]: https://github.com/Nathandela/learning_agent/compare/v1.1.0...HEAD
+[Unreleased]: https://github.com/Nathandela/learning_agent/compare/v1.2.1...HEAD
+[1.2.1]: https://github.com/Nathandela/learning_agent/compare/v1.2.0...v1.2.1
+[1.2.0]: https://github.com/Nathandela/learning_agent/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/Nathandela/learning_agent/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/Nathandela/learning_agent/compare/v0.2.9...v1.0.0
 [0.2.9]: https://github.com/Nathandela/learning_agent/compare/v0.2.8...v0.2.9

package/README.md

@@ -166,10 +166,23 @@ The CLI binary is `ca` (alias: `compound-agent`).
 | `ca export` | Export items as JSON |
 | `ca import <file>` | Import items from JSONL file |
 | `ca prime` | Load workflow context (used by hooks) |
+| `ca verify-gates <epic-id>` | Verify review + compound tasks exist and are closed |
 | `ca audit` | Run audit checks against the codebase |
 | `ca rules check` | Run repository-defined rule checks |
 | `ca test-summary` | Run tests and output a compact summary |
 
+### Automation
+
+| Command | Description |
+|---------|-------------|
+| `ca loop` | Generate infinity loop script for autonomous epic processing |
+| `ca loop --epics <ids...>` | Target specific epic IDs |
+| `ca loop -o <path>` | Custom output path (default: `./infinity-loop.sh`) |
+| `ca loop --max-retries <n>` | Max retries per epic on failure (default: 1) |
+| `ca loop --force` | Overwrite existing script |
+
+Generated scripts detect three markers: `EPIC_COMPLETE` (success), `EPIC_FAILED` (retry then stop), `HUMAN_REQUIRED: <reason>` (skip and continue). Run with `LOOP_DRY_RUN=1` to preview.
+
 ### Setup
 
 | Command | Description |

package/dist/cli.js

@@ -3,9 +3,9 @@ import { Command } from 'commander';
 import { getLlama, resolveModelFile } from 'node-llama-cpp';
 import { mkdirSync, writeFileSync, statSync, existsSync, readFileSync, unlinkSync, chmodSync, readdirSync } from 'fs';
 import { homedir } from 'os';
-import { join, dirname, relative } from 'path';
+import { join, dirname, resolve, relative } from 'path';
 import * as fs from 'fs/promises';
-import { readFile, mkdir, appendFile, rm, writeFile, rename } from 'fs/promises';
+import { readFile, mkdir, appendFile, writeFile, chmod, rm, rename } from 'fs/promises';
 import { createHash } from 'crypto';
 import { z } from 'zod';
 import { createRequire } from 'module';
@@ -2966,12 +2966,28 @@ Create a structured implementation plan enriched by semantic memory and existing
 5. Synthesize research findings from all agents into a coherent plan. Flag any conflicts between ADRs and proposed approach.
 6. Use \`AskUserQuestion\` to resolve ambiguities: unclear requirements, conflicting ADRs, or priority trade-offs that need user input before decomposing.
 7. Break the goal into concrete, ordered tasks with clear acceptance criteria.
-8. Create beads issues and map dependencies:
+8. **Create review and compound blocking tasks** so they survive compaction:
+   \`\`\`bash
+   bd create --title="Review: /compound:review" --type=task --priority=1
+   bd create --title="Compound: /compound:compound" --type=task --priority=1
+   bd dep add <review-id> <last-work-task>   # review depends on work
+   bd dep add <compound-id> <review-id>       # compound depends on review
+   \`\`\`
+   These tasks surface via \`bd ready\` after work completes, ensuring review and compound phases are never skipped \u2014 even after context compaction.
+9. Create beads issues and map dependencies:
    \`\`\`bash
    bd create --title="<task>" --type=task --priority=<1-4>
    bd dep add <dependent-task> <blocking-task>
    \`\`\`
-9. Output the plan as a structured list with task IDs and dependency graph.
+10. Output the plan as a structured list with task IDs and dependency graph.
+
+## POST-PLAN VERIFICATION -- MANDATORY
+After creating all tasks, verify review and compound tasks exist:
+\`\`\`bash
+bd list --status=open | grep 'Review:'    # Must show a result
+bd list --status=open | grep 'Compound:'  # Must show a result
+\`\`\`
+If either is missing, CREATE THEM NOW. The plan is NOT complete without these gates.
 
 ## Memory Integration
 - Call \`memory_search\` before planning to learn from past approaches.
@@ -2999,7 +3015,7 @@ Execute implementation by delegating to an agent team. The lead coordinates and
 ## Workflow
 1. Parse task from \`$ARGUMENTS\`. If empty, run \`bd ready\` to find available tasks.
 2. Mark task in progress: \`bd update <id> --status=in_progress\`.
-3. Call \`memory_search\` with the task description to retrieve relevant lessons. Run \`memory_search\` per agent/subtask so each gets targeted context.
+3. Call \`memory_search\` with the task description to retrieve relevant lessons. Run \`memory_search\` per agent/subtask so each gets targeted context. Display retrieved lessons in your response. Do not silently discard memory results.
 4. Assess complexity to determine team strategy.
 5. If **trivial** (config changes, typos, one-line fixes): handle directly with a single subagent. No AgentTeam needed. Proceed to step 10.
 6. If **simple** or **complex**, create an AgentTeam:
@@ -3026,9 +3042,16 @@ Execute implementation by delegating to an agent team. The lead coordinates and
 14. Run the full test suite to check for regressions.
 15. Close the task: \`bd close <id>\`.
 
-## Verification Gate
-Before marking work complete, run the 8-step TDD verification pipeline:
-1. /invariant-designer \u2192 2. /cct-subagent \u2192 3. /test-first-enforcer \u2192 4. /property-test-generator \u2192 5. /anti-cargo-cult-reviewer \u2192 6. /module-boundary-reviewer \u2192 7. /drift-detector \u2192 8. /implementation-reviewer
+## MANDATORY VERIFICATION -- DO NOT CLOSE TASK WITHOUT THIS
+STOP. Before running \`bd close\`, you MUST:
+1. Run \`pnpm test && pnpm lint\` (quality gates)
+2. Run /implementation-reviewer on the changed code
+3. Wait for APPROVED status
+If /implementation-reviewer returns REJECTED: fix ALL issues, re-run tests, resubmit.
+DO NOT close the task until approved. This is INVIOLABLE per CLAUDE.md.
+
+The full 8-step pipeline (invariant-designer through implementation-reviewer) is recommended
+for complex changes. For all changes, /implementation-reviewer is the minimum required gate.
 
 ## Memory Integration
 - Call \`memory_search\` per delegated subtask with the subtask's specific description, not one shared query.
@@ -3127,6 +3150,7 @@ Multi-agent analysis to capture high-quality lessons from completed work into th
    - **Medium**: workflow changes, pattern corrections, tooling preferences
    - **Low**: style preferences, minor optimizations, reinforcements
 7. For approved items, store via \`memory_capture\` with supersedes/related linking to connect with existing memory.
+   At minimum, capture 1 lesson per significant decision made during this cycle.
 8. After storing new items, delegate to the **compounding** subagent to run compounding synthesis:
    - Read all lessons from \`.claude/lessons/index.jsonl\`
    - Cluster by embedding similarity (threshold 0.75)
@@ -3156,41 +3180,76 @@ Chain all phases: brainstorm, plan, work, review, compound. End-to-end delivery.
 
 ## Workflow
 1. **Brainstorm phase**: Explore the goal from \`$ARGUMENTS\`.
+   - MEMORY CHECK: Call \`memory_search\` with the current goal/task. Display results to user. If relevant items found, state which ones apply and why. If none found, state "No relevant lessons found."
    - Call \`memory_search\` with the goal.
    - \`TeamCreate\` team "brainstorm-<slug>", spawn docs-explorer + code-explorer as parallel teammates.
    - Ask clarifying questions via \`AskUserQuestion\`, explore alternatives.
    - Auto-create ADRs for significant decisions in \`docs/decisions/\`.
    - Create a beads epic from conclusions with \`bd create --type=feature\`.
    - Shut down brainstorm team before next phase.
+   - Update epic phase state: \`bd update <epic-id> --notes="Phase: brainstorm COMPLETE | Next: plan"\`
 
 2. **Plan phase**: Structure the work.
+   - MEMORY CHECK: Call \`memory_search\` with the current goal/task. Display results to user. If relevant items found, state which ones apply and why. If none found, state "No relevant lessons found."
    - Check for brainstorm epic via \`bd list\`.
    - \`TeamCreate\` team "plan-<slug>", spawn docs-analyst + repo-analyst + memory-analyst as parallel teammates.
    - Break into tasks with dependencies and acceptance criteria.
    - Create beads issues with \`bd create\` and map dependencies with \`bd dep add\`.
+   - Create review and compound blocking tasks (\`bd create\` + \`bd dep add\`) so they survive compaction and surface via \`bd ready\` after work completes.
    - Shut down plan team before next phase.
+   - Update epic phase state: \`bd update <epic-id> --notes="Phase: plan COMPLETE | Next: work"\`
 
 3. **Work phase**: Implement with adaptive TDD.
+   - MEMORY CHECK: Call \`memory_search\` with the current goal/task. Display results to user. If relevant items found, state which ones apply and why. If none found, state "No relevant lessons found."
    - Assess complexity (trivial/simple/complex) to choose strategy.
    - Trivial: single subagent, no team. Simple/complex: \`TeamCreate\` team "work-<task-id>".
    - Spawn test-analyst first, then test-writer + implementer as teammates.
    - Call \`memory_search\` per subtask; \`memory_capture\` after corrections.
    - Commit incrementally. Close tasks as they complete.
    - Run verification gate before marking complete. Shut down work team.
+   - Update epic phase state: \`bd update <epic-id> --notes="Phase: work COMPLETE | Next: review"\`
+
+## PHASE GATE 3->4 -- MANDATORY
+Before starting Review, verify ALL work tasks are closed:
+\`\`\`bash
+bd list --status=in_progress  # Must return empty
+bd list --status=open | grep -v 'Review:\\|Compound:'  # Must return empty (only review+compound should be open)
+\`\`\`
+If any work tasks remain open, DO NOT proceed. Complete them first.
+Update epic phase: \`bd update <epic-id> --notes="Phase: work COMPLETE | Next: review"\`
 
 4. **Review phase**: 11-agent review with severity classification.
+   - MEMORY CHECK: Call \`memory_search\` with the current goal/task. Display results to user. If relevant items found, state which ones apply and why. If none found, state "No relevant lessons found."
    - Run quality gates first: \`pnpm test && pnpm lint\`.
    - \`TeamCreate\` team "review-<slug>", spawn all 11 reviewers as parallel teammates.
    - Classify findings as P1 (critical/blocking), P2 (important), P3 (minor).
    - P1 findings must be fixed before proceeding \u2014 they block completion.
    - Submit to \`/implementation-reviewer\` as the mandatory gate. Shut down review team.
+   - Update epic phase state: \`bd update <epic-id> --notes="Phase: review COMPLETE | Next: compound"\`
+
+## PHASE GATE 4->5 -- MANDATORY
+Before starting Compound, verify review is complete:
+- /implementation-reviewer must have returned APPROVED
+- All P1 findings must be resolved
+Update epic phase: \`bd update <epic-id> --notes="Phase: review COMPLETE | Next: compound"\`
 
 5. **Compound phase**: Capture learnings.
+   - MEMORY CHECK: Call \`memory_search\` with the current goal/task. Display results to user. If relevant items found, state which ones apply and why. If none found, state "No relevant lessons found."
    - \`TeamCreate\` team "compound-<slug>", spawn 6 analysis agents as parallel teammates.
    - Search first with \`memory_search\` to avoid duplicates. Apply quality filters (novelty + specificity).
    - Store novel insights via \`memory_capture\` with supersedes/related links.
    - Update outdated docs and deprecate superseded ADRs.
    - Use \`AskUserQuestion\` to confirm high-severity items. Shut down compound team.
+   - Update epic phase state: \`bd update <epic-id> --notes="Phase: compound COMPLETE | Next: close"\`
+
+## FINAL GATE -- EPIC CLOSURE
+Before closing the epic, run:
+\`\`\`bash
+ca verify-gates <epic-id>    # Must return PASS
+pnpm test && pnpm lint       # Must pass
+\`\`\`
+If verify-gates fails, the missing phase was SKIPPED. Go back and complete it.
+CRITICAL: 3/5 phases is NOT success. All 5 phases are required.
 
 ## Agent Team Pattern
 Each phase creates its own AgentTeam via \`TeamCreate\`, spawns teammates via \`Task\` tool with \`team_name\`, coordinates via \`SendMessage\`, and shuts down with \`shutdown_request\` before the next phase starts. Use subagents (Task without team_name) only for quick lookups like \`memory_search\` or \`bd\` commands.
@@ -3199,7 +3258,7 @@ Each phase creates its own AgentTeam via \`TeamCreate\`, spawns teammates via \`
 - **Skip phases**: Parse \`$ARGUMENTS\` for "from <phase>" (e.g., "from plan"). Skip all phases before the named one.
 - **Progress**: Announce the current phase before starting it (e.g., "[Phase 2/5] Plan").
 - **Retry**: If a phase fails, report the failure and ask the user whether to retry, skip, or abort.
-- **Resume**: After interruption, check \`bd list --status=in_progress\` to find where work stopped and resume from that phase.
+- **Resume**: After interruption, run \`bd show <epic-id>\` and read the notes field for current phase state. Resume from that phase. If no phase state, check \`bd list --status=in_progress\` to infer.
 
 ## Stop Conditions
 - Stop if brainstorm reveals the goal is unclear (ask user).
@@ -3209,6 +3268,18 @@ Each phase creates its own AgentTeam via \`TeamCreate\`, spawns teammates via \`
 ## Memory Integration
 - \`memory_search\` is called in brainstorm, work, and compound phases.
 - \`memory_capture\` is called in work and compound phases.
+
+## SESSION CLOSE -- INVIOLABLE
+Before saying "done" or "complete", ALL of these must pass:
+1. \`ca verify-gates <epic-id>\` -- All workflow gates satisfied
+2. \`pnpm test && pnpm lint\` -- Quality gates green
+3. \`git status\` -- Review changes
+4. \`git add <specific-files>\` -- Stage (never git add .)
+5. \`bd sync\` -- Sync beads
+6. \`git commit -m "..."\` -- Commit
+7. \`bd sync\` -- Post-commit sync
+8. \`git push\` -- Push to remote
+If ANY step fails, fix it. Work is NOT done until git push succeeds.
 `,
   // =========================================================================
   // Utility commands (CLI wrappers)
@@ -3348,6 +3419,7 @@ Create a concrete implementation plan by decomposing work into small, testable t
 7. Define acceptance criteria for each task
 8. Map dependencies between tasks
 9. Create beads issues: \`bd create --title="..." --type=task\`
+10. Create review and compound blocking tasks (\`bd create\` + \`bd dep add\`) that depend on work tasks \u2014 these survive compaction and surface via \`bd ready\` after work completes
 
 ## Memory Integration
 - Call \`memory_search\` for patterns related to the feature area
@@ -3810,7 +3882,12 @@ async function runUpdate(repoRoot, dryRun) {
       }
     }
   }
-  return { updated, added, skipped };
+  let configUpdated = false;
+  if (!dryRun) {
+    const { hooks, mcpServer } = await configureClaudeSettings(repoRoot);
+    configUpdated = hooks || mcpServer;
+  }
+  return { updated, added, skipped, configUpdated };
 }
 async function runStatus(repoRoot) {
   const agentsDir = join(repoRoot, ".claude", "agents", "compound");
@@ -3861,6 +3938,7 @@ function registerSetupAllCommand(setupCommand) {
         if (result2.added > 0) console.log(`  ${prefix}Added: ${result2.added} file(s)`);
       }
       if (result2.skipped > 0) console.log(`  Skipped: ${result2.skipped} user-customized file(s)`);
+      if (result2.configUpdated) console.log(`  ${prefix}Config: hooks/MCP updated`);
       return;
     }
     if (options.status) {
@@ -5055,6 +5133,13 @@ async function getPrimeContext(repoRoot) {
   }
   const lessons = await loadSessionLessons(root, 5);
   let output = TRUST_LANGUAGE_TEMPLATE;
+  const hasMcp = await hasMcpServerInMcpJson(root);
+  if (!hasMcp) {
+    output += `
+WARNING: MCP server not registered. Run 'npx ca setup' to enable memory_search/memory_capture tools.
+
+`;
+  }
   if (lessons.length > 0) {
     const formattedLessons = lessons.map(formatLessonForPrime).join("\n\n");
     output += `
@@ -5371,6 +5456,79 @@ function registerTestSummaryCommand(program2) {
     process.exit(exitCode);
   });
 }
+function parseDeps(output) {
+  const deps = [];
+  const lines = output.split("\n");
+  let inDeps = false;
+  for (const line of lines) {
+    if (line.trim() === "DEPENDS ON") {
+      inDeps = true;
+      continue;
+    }
+    if (inDeps) {
+      const match = line.match(
+        /^\s+→\s+(✓|○)\s+\S+-\S+:\s+(.+?)\s+●/
+      );
+      if (match && match[1] && match[2]) {
+        deps.push({ closed: match[1] === "\u2713", title: match[2] });
+      } else if (line.trim() !== "" && !line.startsWith("  ")) {
+        break;
+      }
+    }
+  }
+  return deps;
+}
+function checkGate(deps, prefix, gateName) {
+  const task = deps.find((d) => d.title.startsWith(prefix));
+  if (!task) {
+    return { name: gateName, status: "fail", detail: `No ${gateName.toLowerCase()} found (missing)` };
+  }
+  if (!task.closed) {
+    return { name: gateName, status: "fail", detail: `${gateName} exists but is not closed` };
+  }
+  return { name: gateName, status: "pass" };
+}
+async function runVerifyGates(epicId) {
+  const raw = execSync(`bd show ${epicId}`, { encoding: "utf-8" });
+  const deps = parseDeps(raw);
+  return [
+    checkGate(deps, "Review:", "Review task"),
+    checkGate(deps, "Compound:", "Compound task")
+  ];
+}
+var STATUS_LABEL = {
+  pass: "PASS",
+  fail: "FAIL"
+};
+function registerVerifyGatesCommand(program2) {
+  program2.command("verify-gates <epic-id>").description("Verify workflow gates are satisfied before epic closure").action(async (epicId) => {
+    try {
+      const checks = await runVerifyGates(epicId);
+      console.log(`Gate checks for epic ${epicId}:
+`);
+      for (const check of checks) {
+        const label = STATUS_LABEL[check.status];
+        console.log(`  [${label}] ${check.name}`);
+        if (check.detail) {
+          console.log(`          ${check.detail}`);
+        }
+      }
+      const failures = checks.filter((c) => c.status === "fail");
+      console.log("");
+      if (failures.length === 0) {
+        console.log("All gates passed.");
+      } else {
+        console.log(`${failures.length} gate(s) failed.`);
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      console.error(
+        `Error: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exitCode = 1;
+    }
+  });
+}
 
 // src/commands/capture.ts
 function createLessonFromFlags(trigger, insight, confirmed) {
@@ -5612,6 +5770,269 @@ function registerCaptureCommands(program2) {
     await handleCapture(this, options);
   });
 }
+var EPIC_ID_PATTERN = /^[a-zA-Z0-9_.-]+$/;
+function buildScriptHeader(timestamp, maxRetries, model, epicIds) {
+  return `#!/usr/bin/env bash
+# Infinity Loop - Generated by: ca loop
+# Date: ${timestamp}
+# Autonomously processes beads epics via Claude Code sessions.
+#
+# Usage:
+#   ./infinity-loop.sh
+#   LOOP_DRY_RUN=1 ./infinity-loop.sh  # Preview without executing
+
+set -euo pipefail
+
+# Config
+MAX_RETRIES=${maxRetries}
+MODEL="${model}"
+EPIC_IDS="${epicIds}"
+LOG_DIR="agent_logs"
+
+# Helpers
+timestamp() { date '+%Y-%m-%d_%H-%M-%S'; }
+log() { echo "[$(timestamp)] $*"; }
+die() { log "FATAL: $*"; exit 1; }
+
+command -v python3 >/dev/null || die "python3 required for JSON parsing"
+command -v claude >/dev/null || die "claude CLI required"
+command -v bd >/dev/null || die "bd (beads) CLI required"
+
+mkdir -p "$LOG_DIR"
+` + buildEpicSelector() + buildPromptFunction();
+}
+function buildEpicSelector() {
+  return `
+get_next_epic() {
+  if [ -n "$EPIC_IDS" ]; then
+    # From explicit list, find first still-open epic not yet processed
+    for epic_id in $EPIC_IDS; do
+      case " $PROCESSED " in *" $epic_id "*) continue ;; esac
+      local status
+      status=$(bd show "$epic_id" --json 2>/dev/null | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('status',''))" 2>/dev/null || echo "")
+      if [ "$status" = "open" ]; then
+        echo "$epic_id"
+        return 0
+      fi
+    done
+    return 1
+  else
+    # Dynamic: get next ready epic from dependency graph, filtering processed
+    local epic_id
+    epic_id=$(bd list --type=epic --ready --json --limit=10 2>/dev/null | python3 -c "
+import sys,json
+processed = set('$PROCESSED'.split())
+items = json.load(sys.stdin)
+for item in items:
+    if item['id'] not in processed:
+        print(item['id'])
+        break" 2>/dev/null || echo "")
+    if [ -z "$epic_id" ]; then
+      return 1
+    fi
+    echo "$epic_id"
+    return 0
+  fi
+}
+`;
+}
+function buildPromptFunction() {
+  return `
+build_prompt() {
+  local epic_id="$1"
+  cat <<'PROMPT_HEADER'
+You are running in an autonomous infinity loop. Your task is to fully implement a beads epic.
+
+## Step 1: Load context
+Run these commands to prime your session:
+PROMPT_HEADER
+  cat <<PROMPT_BODY
+\\\`\\\`\\\`bash
+npx ca load-session
+bd show $epic_id
+\\\`\\\`\\\`
+
+Read the epic details carefully. Understand scope, acceptance criteria, and sub-tasks.
+
+## Step 2: Execute the workflow
+Run the full compound workflow for this epic, starting from the plan phase
+(brainstorm is already done -- the epic exists):
+
+/compound:lfg from plan -- Epic: $epic_id
+
+Work through all phases: plan, work, review, compound.
+
+## Step 3: On completion
+When all work is done and tests pass:
+1. Close the epic: \`bd close $epic_id\`
+2. Sync beads: \`bd sync\`
+3. Commit and push all changes
+4. Output this exact marker on its own line:
+
+EPIC_COMPLETE
+
+## Step 4: On failure
+If you cannot complete the epic after reasonable effort:
+1. Add a note: \`bd update $epic_id --notes "Loop failed: <reason>"\`
+2. Output this exact marker on its own line:
+
+EPIC_FAILED
+
+## Step 5: On human required
+If you hit a blocker that REQUIRES human action (account creation, API keys,
+external service setup, design decisions you cannot make, etc.):
+1. Add a note: \`bd update $epic_id --notes "Human required: <reason>"\`
+2. Output this exact marker followed by a short reason on the SAME line:
+
+HUMAN_REQUIRED: <reason>
+
+Example: HUMAN_REQUIRED: Need AWS credentials configured in .env
+
+## Rules
+- Do NOT ask questions -- there is no human. Make reasonable decisions.
+- Do NOT stop early -- complete the full workflow.
+- If tests fail, fix them. Retry up to 3 times before declaring failure.
+- Use HUMAN_REQUIRED only for true blockers that no amount of retrying can solve.
+- Commit incrementally as you make progress.
+PROMPT_BODY
+}`;
+}
+function buildMainLoop() {
+  return `
+# Main loop
+COMPLETED=0
+FAILED=0
+SKIPPED=0
+PROCESSED=""
+
+log "Infinity loop starting"
+log "Config: max_retries=$MAX_RETRIES model=$MODEL"
+[ -n "$EPIC_IDS" ] && log "Targeting epics: $EPIC_IDS" || log "Targeting: all ready epics"
+
+while true; do
+  EPIC_ID=$(get_next_epic) || break
+
+  log "Processing epic: $EPIC_ID"
+
+  ATTEMPT=0
+  SUCCESS=false
+
+  while [ $ATTEMPT -le $MAX_RETRIES ]; do
+    ATTEMPT=$((ATTEMPT + 1))
+    LOGFILE="$LOG_DIR/loop_$EPIC_ID-$(timestamp).log"
+
+    log "Attempt $ATTEMPT/$((MAX_RETRIES + 1)) for $EPIC_ID (log: $LOGFILE)"
+
+    if [ -n "\${LOOP_DRY_RUN:-}" ]; then
+      log "[DRY RUN] Would run claude session for $EPIC_ID"
+      SUCCESS=true
+      break
+    fi
+
+    PROMPT=$(build_prompt "$EPIC_ID")
+
+    claude --dangerously-skip-permissions \\
+           --model "$MODEL" \\
+           -p "$PROMPT" \\
+           &> "$LOGFILE" || true
+
+    if grep -q "EPIC_COMPLETE" "$LOGFILE"; then
+      log "Epic $EPIC_ID completed successfully"
+      SUCCESS=true
+      break
+    elif grep -q "HUMAN_REQUIRED" "$LOGFILE"; then
+      REASON=$(grep "HUMAN_REQUIRED:" "$LOGFILE" | head -1 | sed 's/.*HUMAN_REQUIRED: *//')
+      log "Epic $EPIC_ID needs human action: $REASON"
+      bd update "$EPIC_ID" --notes "Human required: $REASON" 2>/dev/null || true
+      SKIPPED=$((SKIPPED + 1))
+      SUCCESS=skip
+      break
+    elif grep -q "EPIC_FAILED" "$LOGFILE"; then
+      log "Epic $EPIC_ID reported failure (attempt $ATTEMPT)"
+    else
+      log "Epic $EPIC_ID session ended without marker (attempt $ATTEMPT)"
+    fi
+
+    if [ $ATTEMPT -le $MAX_RETRIES ]; then
+      log "Retrying $EPIC_ID..."
+      sleep 5
+    fi
+  done
+
+  if [ "$SUCCESS" = true ]; then
+    COMPLETED=$((COMPLETED + 1))
+    log "Epic $EPIC_ID done. Completed so far: $COMPLETED"
+  elif [ "$SUCCESS" = skip ]; then
+    log "Epic $EPIC_ID skipped (human required). Continuing."
+  else
+    FAILED=$((FAILED + 1))
+    log "Epic $EPIC_ID failed after $((MAX_RETRIES + 1)) attempts. Stopping loop."
+    PROCESSED="$PROCESSED $EPIC_ID"
+    break
+  fi
+
+  PROCESSED="$PROCESSED $EPIC_ID"
+done
+
+log "Loop finished. Completed: $COMPLETED, Failed: $FAILED, Skipped: $SKIPPED"
+[ $FAILED -eq 0 ] && exit 0 || exit 1`;
+}
+function validateOptions(options) {
+  if (!Number.isInteger(options.maxRetries) || options.maxRetries < 0) {
+    throw new Error(`Invalid maxRetries: must be a non-negative integer, got ${options.maxRetries}`);
+  }
+  if (options.epics) {
+    for (const id of options.epics) {
+      if (!EPIC_ID_PATTERN.test(id)) {
+        throw new Error(`Invalid epic ID "${id}": must match ${EPIC_ID_PATTERN}`);
+      }
+    }
+  }
+}
+function generateLoopScript(options) {
+  validateOptions(options);
+  const epicIds = options.epics?.join(" ") ?? "";
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return buildScriptHeader(timestamp, options.maxRetries, options.model, epicIds) + buildMainLoop();
+}
+async function handleLoop(cmd, options) {
+  const outputPath = resolve(options.output ?? "./infinity-loop.sh");
+  if (existsSync(outputPath) && !options.force) {
+    out.error(`File already exists: ${outputPath}`);
+    out.info("Use --force to overwrite");
+    process.exitCode = 1;
+    return;
+  }
+  const maxRetries = Number(options.maxRetries ?? 1);
+  if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+    out.error(`Invalid --max-retries: must be a non-negative integer, got "${options.maxRetries}"`);
+    process.exitCode = 1;
+    return;
+  }
+  let script;
+  try {
+    script = generateLoopScript({
+      epics: options.epics,
+      maxRetries,
+      model: options.model ?? "claude-opus-4-6"
+    });
+  } catch (err) {
+    out.error(err.message);
+    process.exitCode = 1;
+    return;
+  }
+  await mkdir(dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, script, "utf-8");
+  await chmod(outputPath, 493);
+  out.success(`Generated infinity loop script: ${outputPath}`);
+  out.info("Run it with: " + outputPath);
+  out.info("Preview with: LOOP_DRY_RUN=1 " + outputPath);
+}
+function registerLoopCommands(program2) {
+  program2.command("loop").description("Generate infinity loop script for epic tasks").option("--epics <ids...>", "Specific epic IDs to process").option("-o, --output <path>", "Output script path", "./infinity-loop.sh").option("--max-retries <n>", "Max retries per epic on failure", "1").option("--model <model>", "Claude model to use", "claude-opus-4-6").option("--force", "Overwrite existing script").action(async function(options) {
+    await handleLoop(this, options);
+  });
+}
 function parseLimitOrExit(rawLimit, optionName, commandName) {
   try {
     return parseLimit(rawLimit, optionName);
@@ -5872,6 +6293,7 @@ function registerManagementCommands(program2) {
   registerReviewerCommand(program2);
   registerRulesCommands(program2);
   registerTestSummaryCommand(program2);
+  registerVerifyGatesCommand(program2);
 }
 
 // src/cli.ts
@@ -5897,6 +6319,7 @@ registerRetrievalCommands(program);
 registerManagementCommands(program);
 registerSetupCommands(program);
 registerCompoundCommands(program);
+registerLoopCommands(program);
 program.parse();
 //# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map