compound-agent 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -9,6 +9,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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 +438,8 @@ 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.0...HEAD
+[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

@@ -170,6 +170,18 @@ The CLI binary is `ca` (alias: `compound-agent`).
 | `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';
@@ -2971,7 +2971,15 @@ Create a structured implementation plan enriched by semantic memory and existing
    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.
+9. **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.
+10. Output the plan as a structured list with task IDs and dependency graph.
 
 ## Memory Integration
 - Call \`memory_search\` before planning to learn from past approaches.
@@ -3168,6 +3176,7 @@ Chain all phases: brainstorm, plan, work, review, compound. End-to-end delivery.
    - \`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.
 
 3. **Work phase**: Implement with adaptive TDD.
@@ -3348,6 +3357,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
@@ -5612,6 +5622,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);
@@ -5897,6 +6170,7 @@ registerRetrievalCommands(program);
 registerManagementCommands(program);
 registerSetupCommands(program);
 registerCompoundCommands(program);
+registerLoopCommands(program);
 program.parse();
 //# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map