compound-agent 1.6.5 → 1.7.0

package/CHANGELOG.md

@@ -9,6 +9,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.7.0] - 2026-03-08
+
+### Added
+
+- **Loop observability**: Generated loop script now writes `.loop-status.json` (real-time epic/attempt/status) and `loop-execution.jsonl` (append-only result log with per-epic duration and end-of-loop summary). Enables `ca watch --status` and post-mortem forensics.
+- **ESLint rule `no-solo-trivial-assertion`**: Custom rule that warns when a test's only assertion is `toBeDefined()`, `toBeTruthy()`, `toBeFalsy()`, or `toBeNull()`. Registered but not yet enabled (requires cleanup of ~40 existing violations).
+
+### Fixed
+
+- **Loop 0-byte log resilience**: `extract_text` pipeline could produce 0-byte log files while the trace JSONL had valid content, causing the loop to falsely detect failure. New `detect_marker()` function checks the macro log first (anchored grep), then falls back to the trace JSONL (unanchored grep). Includes health check warning on extraction failure.
+- **Search fallback when embeddings unavailable**: `retrieveForPlan()` no longer throws when the embedding model is missing or broken. Falls back to keyword-only search with a console warning.
+
+### Changed
+
+- **Anti-cargo-cult reviewer strengthened**: Added three new subtle anti-patterns to the reviewer agent: solo trivial assertions, substring-only `toContain()` checks, and keyword-presence tests. Each with bad/good examples.
+- **Loop template extraction**: Bash script templates moved to `loop-templates.ts` to stay within lint limits.
+
 ## [1.6.5] - 2026-03-07
 
 ### Fixed

package/dist/cli.js

@@ -3425,11 +3425,25 @@ init_storage();
 var DEFAULT_LIMIT3 = 5;
 async function retrieveForPlan(repoRoot, planText, limit = DEFAULT_LIMIT3) {
   const candidateLimit = limit * CANDIDATE_MULTIPLIER;
-  const [vectorResults, keywordResults] = await Promise.all([
-    searchVector(repoRoot, planText, { limit: candidateLimit }),
-    searchKeywordScored(repoRoot, planText, candidateLimit)
-  ]);
-  const merged = mergeHybridResults(vectorResults, keywordResults, { minScore: MIN_HYBRID_SCORE });
+  let vectorResults = [];
+  let vectorFailed = false;
+  const keywordResultsPromise = searchKeywordScored(repoRoot, planText, candidateLimit);
+  try {
+    vectorResults = await searchVector(repoRoot, planText, { limit: candidateLimit });
+  } catch {
+    vectorFailed = true;
+    console.error("[compound-agent] Vector search unavailable, falling back to keyword-only search");
+  }
+  const keywordResults = await keywordResultsPromise;
+  let merged;
+  if (vectorFailed) {
+    merged = mergeHybridResults([], keywordResults, {
+      vectorWeight: 0,
+      textWeight: DEFAULT_TEXT_WEIGHT
+    });
+  } else {
+    merged = mergeHybridResults(vectorResults, keywordResults, { minScore: MIN_HYBRID_SCORE });
+  }
   const ranked = rankLessons(merged);
   const topLessons = ranked.slice(0, limit);
   if (topLessons.length > 0) {
@@ -10467,7 +10481,24 @@ function registerVerifyGatesCommand(program) {
 }
 
 // src/changelog-data.ts
-var CHANGELOG_RECENT = `## [1.6.5] - 2026-03-07
+var CHANGELOG_RECENT = `## [1.7.0] - 2026-03-08
+
+### Added
+
+- **Loop observability**: Generated loop script now writes \`.loop-status.json\` (real-time epic/attempt/status) and \`loop-execution.jsonl\` (append-only result log with per-epic duration and end-of-loop summary). Enables \`ca watch --status\` and post-mortem forensics.
+- **ESLint rule \`no-solo-trivial-assertion\`**: Custom rule that warns when a test's only assertion is \`toBeDefined()\`, \`toBeTruthy()\`, \`toBeFalsy()\`, or \`toBeNull()\`. Registered but not yet enabled (requires cleanup of ~40 existing violations).
+
+### Fixed
+
+- **Loop 0-byte log resilience**: \`extract_text\` pipeline could produce 0-byte log files while the trace JSONL had valid content, causing the loop to falsely detect failure. New \`detect_marker()\` function checks the macro log first (anchored grep), then falls back to the trace JSONL (unanchored grep). Includes health check warning on extraction failure.
+- **Search fallback when embeddings unavailable**: \`retrieveForPlan()\` no longer throws when the embedding model is missing or broken. Falls back to keyword-only search with a console warning.
+
+### Changed
+
+- **Anti-cargo-cult reviewer strengthened**: Added three new subtle anti-patterns to the reviewer agent: solo trivial assertions, substring-only \`toContain()\` checks, and keyword-presence tests. Each with bad/good examples.
+- **Loop template extraction**: Bash script templates moved to \`loop-templates.ts\` to stay within lint limits.
+
+## [1.6.5] - 2026-03-07
 
 ### Fixed
 
@@ -10488,13 +10519,7 @@ var CHANGELOG_RECENT = `## [1.6.5] - 2026-03-07
 - **Agentic skill missing completion gate**: Other skills have phase gates; the agentic skill was missing one. Added Setup Completion Gate with verification steps.
 - **Agentic skill stack-biased scoring**: Rubric was TypeScript-heavy. Added language-neutral scoring guidance (mypy, clippy, ruff equivalents).
 - **Agentic skill \`$ARGUMENTS\` dead code**: Mode is set by the calling command (\`/compound:agentic-audit\` or \`/compound:agentic-setup\`), not parsed from \`$ARGUMENTS\`.
-- **Docs template missing agentic commands**: \`SKILLS.md\` template now lists \`agentic-audit\` and \`agentic-setup\` in the command inventory.
-
-## [1.6.3] - 2026-03-05
-
-### Changed
-
-- **Cook-it session banner**: Replaced "Claude the Cooker" chef ASCII art with rscr's detailed front-view brain ASCII art ("Claw'd"). Brain features ANSI-colored augmentation zones: cyan neural interface (\`##\`), bright cyan signal crosslinks (\`::\`), green bio-circuits (\`%\`), magenta data highways (\`######\`), and yellow power nodes (\`@@\`).`;
+- **Docs template missing agentic commands**: \`SKILLS.md\` template now lists \`agentic-audit\` and \`agentic-setup\` in the command inventory.`;
 
 // src/commands/about.ts
 function registerAboutCommand(program) {
@@ -11290,76 +11315,12 @@ function registerManagementCommands(program) {
     process.exitCode = 1;
   });
 }
-var LOOP_EPIC_ID_PATTERN = /^[a-zA-Z0-9_.-]+$/;
-var MODEL_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 claude >/dev/null || die "claude CLI required"
-command -v bd >/dev/null || die "bd (beads) CLI required"
-
-# Detect JSON parser: prefer jq, fall back to python3
-HAS_JQ=false
-command -v jq >/dev/null 2>&1 && HAS_JQ=true
-if [ "$HAS_JQ" = false ]; then
-  command -v python3 >/dev/null 2>&1 || die "jq or python3 required for JSON parsing"
-fi
-
-# parse_json() - extract a value from JSON stdin
-# Uses jq (primary) with python3 fallback
-# Auto-unwraps single-element arrays (bd show --json returns [...])
-# Usage: echo '[{"status":"open"}]' | parse_json '.status'
-parse_json() {
-  local filter="$1"
-  if [ "$HAS_JQ" = true ]; then
-    jq -r "if type == \\"array\\" then .[0] else . end | $filter"
-  else
-    python3 -c "
-import sys, json
-data = json.load(sys.stdin)
-if isinstance(data, list):
-    data = data[0] if data else {}
-f = '$filter'.strip('.')
-parts = [p for p in f.split('.') if p]
-v = data
-try:
-    for p in parts:
-        v = v[p]
-except (KeyError, IndexError, TypeError):
-    v = None
-print('' if v is None else v)
-"
-  fi
-}
 
-mkdir -p "$LOG_DIR"
-` + buildEpicSelector() + buildPromptFunction();
-}
+// src/commands/loop-templates.ts
 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
@@ -11371,7 +11332,6 @@ get_next_epic() {
     done
     return 1
   else
-    # Dynamic: get next ready epic from dependency graph, filtering processed
     local epic_id
     if [ "$HAS_JQ" = true ]; then
       epic_id=$(bd list --type=epic --ready --json --limit=10 2>/dev/null | jq -r '.[].id' 2>/dev/null | while read -r id; do
@@ -11462,12 +11422,14 @@ PROMPT_BODY
 function buildStreamExtractor() {
   return `
 # extract_text() - Extract assistant text from stream-json events
-# Reads JSONL from stdin, outputs plain text lines for marker detection
+# Claude Code stream-json format: {"type":"assistant","message":{"content":[{"type":"text","text":"..."}]}}
 extract_text() {
   if [ "$HAS_JQ" = true ]; then
     jq -j --unbuffered '
-      select(.type == "content_block_delta" and .delta.type == "text_delta") |
-      .delta.text // empty
+      select(.type == "assistant") |
+      .message.content[]? |
+      select(.type == "text") |
+      .text // empty
     ' 2>/dev/null || { echo "WARN: extract_text parser failed" >&2; }
   else
     python3 -c "
@@ -11478,17 +11440,121 @@ for line in sys.stdin:
         continue
     try:
         obj = json.loads(line)
-        if obj.get('type') == 'content_block_delta' and obj.get('delta', {}).get('type') == 'text_delta':
-            text = obj['delta'].get('text', '')
-            if text:
-                print(text, end='', flush=True)
-    except (json.JSONDecodeError, KeyError):
+        if obj.get('type') == 'assistant':
+            for block in obj.get('message', {}).get('content', []):
+                if block.get('type') == 'text':
+                    text = block.get('text', '')
+                    if text:
+                        print(text, end='', flush=True)
+    except (json.JSONDecodeError, KeyError, TypeError):
         pass
 " 2>/dev/null || { echo "WARN: extract_text parser failed" >&2; }
   fi
 }
 `;
 }
+function buildMarkerDetection() {
+  return `
+# detect_marker() - Check for completion markers in log and trace
+# Primary: macro log (anchored patterns). Fallback: trace JSONL (unanchored).
+# Usage: MARKER=$(detect_marker "$LOGFILE" "$TRACEFILE")
+# Returns: "complete", "failed", "human:<reason>", or "none"
+detect_marker() {
+  local logfile="$1" tracefile="$2"
+
+  # Primary: check extracted text with anchored patterns
+  if [ -s "$logfile" ]; then
+    if grep -q "^EPIC_COMPLETE$" "$logfile"; then
+      echo "complete"; return 0
+    elif grep -q "^HUMAN_REQUIRED:" "$logfile"; then
+      local reason
+      reason=$(grep "^HUMAN_REQUIRED:" "$logfile" | head -1 | sed 's/^HUMAN_REQUIRED: *//')
+      echo "human:$reason"; return 0
+    elif grep -q "^EPIC_FAILED$" "$logfile"; then
+      echo "failed"; return 0
+    fi
+  fi
+
+  # Fallback: check raw trace JSONL (unanchored -- markers are inside JSON strings)
+  if [ -s "$tracefile" ]; then
+    if grep -q "EPIC_COMPLETE" "$tracefile"; then
+      echo "complete"; return 0
+    elif grep -q "HUMAN_REQUIRED:" "$tracefile"; then
+      echo "human:detected in trace"; return 0
+    elif grep -q "EPIC_FAILED" "$tracefile"; then
+      echo "failed"; return 0
+    fi
+  fi
+
+  echo "none"
+}
+`;
+}
+function buildObservability() {
+  return `
+# Observability: status file and execution log
+STATUS_FILE="$LOG_DIR/.loop-status.json"
+EXEC_LOG="$LOG_DIR/loop-execution.jsonl"
+
+write_status() {
+  local status="$1"
+  local epic_id="\${2:-}"
+  local attempt="\${3:-0}"
+  if [ "$status" = "idle" ]; then
+    echo "{\\"status\\":\\"idle\\",\\"timestamp\\":\\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\\"}" > "$STATUS_FILE"
+  else
+    echo "{\\"epic_id\\":\\"$epic_id\\",\\"attempt\\":$attempt,\\"started_at\\":\\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\\",\\"status\\":\\"$status\\"}" > "$STATUS_FILE"
+  fi
+}
+
+log_result() {
+  local epic_id="$1" result="$2" attempts="$3" duration="$4"
+  echo "{\\"epic_id\\":\\"$epic_id\\",\\"result\\":\\"$result\\",\\"attempts\\":$attempts,\\"duration_s\\":$duration,\\"timestamp\\":\\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\\"}" >> "$EXEC_LOG"
+}
+`;
+}
+function buildSessionRunner() {
+  return `
+    PROMPT=$(build_prompt "$EPIC_ID")
+
+    # Two-scope logging: stream-json to trace JSONL, extracted text to macro log
+    claude --dangerously-skip-permissions \\
+           --model "$MODEL" \\
+           --output-format stream-json \\
+           --verbose \\
+           -p "$PROMPT" \\
+           2>"$LOGFILE.stderr" | tee "$TRACEFILE" | extract_text > "$LOGFILE" || true
+
+    # Append stderr to macro log
+    [ -f "$LOGFILE.stderr" ] && cat "$LOGFILE.stderr" >> "$LOGFILE" && rm -f "$LOGFILE.stderr"
+
+    # Health check: warn if macro log extraction failed
+    if [ -s "$TRACEFILE" ] && [ ! -s "$LOGFILE" ]; then
+      log "WARN: Macro log is empty but trace has content (extract_text may have failed)"
+    fi
+
+    MARKER=$(detect_marker "$LOGFILE" "$TRACEFILE")
+    case "$MARKER" in
+      (complete)
+        log "Epic $EPIC_ID completed successfully"
+        SUCCESS=true
+        break
+        ;;
+      (human:*)
+        REASON="\${MARKER#human:}"
+        log "Epic $EPIC_ID needs human action: $REASON"
+        bd update "$EPIC_ID" --notes "Human required: $REASON" 2>/dev/null || true
+        SUCCESS=skip
+        break
+        ;;
+      (failed)
+        log "Epic $EPIC_ID reported failure (attempt $ATTEMPT)"
+        ;;
+      (*)
+        log "Epic $EPIC_ID session ended without marker (attempt $ATTEMPT)"
+        ;;
+    esac`;
+}
 function buildMainLoop() {
   return `
 # Main loop
@@ -11496,6 +11562,7 @@ COMPLETED=0
 FAILED=0
 SKIPPED=0
 PROCESSED=""
+LOOP_START=$(date +%s)
 
 log "Infinity loop starting"
 log "Config: max_retries=$MAX_RETRIES model=$MODEL"
@@ -11505,16 +11572,21 @@ while true; do
   EPIC_ID=$(get_next_epic) || break
 
   log "Processing epic: $EPIC_ID"
+  EPIC_START=$(date +%s)
 
   ATTEMPT=0
   SUCCESS=false
 
+  write_status "running" "$EPIC_ID" 1
+
   while [ $ATTEMPT -le $MAX_RETRIES ]; do
     ATTEMPT=$((ATTEMPT + 1))
     TS=$(timestamp)
     LOGFILE="$LOG_DIR/loop_$EPIC_ID-$TS.log"
     TRACEFILE="$LOG_DIR/trace_$EPIC_ID-$TS.jsonl"
 
+    write_status "running" "$EPIC_ID" "$ATTEMPT"
+
     # Update .latest symlink for ca watch (before claude invocation so watch can discover it)
     ln -sf "$(basename "$TRACEFILE")" "$LOG_DIR/.latest"
 
@@ -11525,36 +11597,7 @@ while true; do
       SUCCESS=true
       break
     fi
-
-    PROMPT=$(build_prompt "$EPIC_ID")
-
-    # Two-scope logging: stream-json to trace JSONL, extracted text to macro log
-    claude --dangerously-skip-permissions \\
-           --model "$MODEL" \\
-           --output-format stream-json \\
-           --verbose \\
-           -p "$PROMPT" \\
-           2>"$LOGFILE.stderr" | tee "$TRACEFILE" | extract_text > "$LOGFILE" || true
-
-    # Append stderr to macro log
-    [ -f "$LOGFILE.stderr" ] && cat "$LOGFILE.stderr" >> "$LOGFILE" && rm -f "$LOGFILE.stderr"
-
-    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
+` + buildSessionRunner() + `
 
     if [ $ATTEMPT -le $MAX_RETRIES ]; then
       log "Retrying $EPIC_ID..."
@@ -11562,13 +11605,19 @@ while true; do
     fi
   done
 
+  EPIC_DURATION=$(( $(date +%s) - EPIC_START ))
+
   if [ "$SUCCESS" = true ]; then
     COMPLETED=$((COMPLETED + 1))
+    log_result "$EPIC_ID" "complete" "$ATTEMPT" "$EPIC_DURATION"
     log "Epic $EPIC_ID done. Completed so far: $COMPLETED"
   elif [ "$SUCCESS" = skip ]; then
+    SKIPPED=$((SKIPPED + 1))
+    log_result "$EPIC_ID" "skipped" "$ATTEMPT" "$EPIC_DURATION"
     log "Epic $EPIC_ID skipped (human required). Continuing."
   else
     FAILED=$((FAILED + 1))
+    log_result "$EPIC_ID" "failed" "$ATTEMPT" "$EPIC_DURATION"
     log "Epic $EPIC_ID failed after $((MAX_RETRIES + 1)) attempts. Stopping loop."
     PROCESSED="$PROCESSED $EPIC_ID"
     break
@@ -11577,9 +11626,79 @@ while true; do
   PROCESSED="$PROCESSED $EPIC_ID"
 done
 
+TOTAL_DURATION=$(( $(date +%s) - LOOP_START ))
+echo "{\\"type\\":\\"summary\\",\\"completed\\":$COMPLETED,\\"failed\\":$FAILED,\\"skipped\\":$SKIPPED,\\"total_duration_s\\":$TOTAL_DURATION}" >> "$EXEC_LOG"
+write_status "idle"
 log "Loop finished. Completed: $COMPLETED, Failed: $FAILED, Skipped: $SKIPPED"
 [ $FAILED -eq 0 ] && exit 0 || exit 1`;
 }
+
+// src/commands/loop.ts
+var LOOP_EPIC_ID_PATTERN = /^[a-zA-Z0-9_.-]+$/;
+var MODEL_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 claude >/dev/null || die "claude CLI required"
+command -v bd >/dev/null || die "bd (beads) CLI required"
+
+# Detect JSON parser: prefer jq, fall back to python3
+HAS_JQ=false
+command -v jq >/dev/null 2>&1 && HAS_JQ=true
+if [ "$HAS_JQ" = false ]; then
+  command -v python3 >/dev/null 2>&1 || die "jq or python3 required for JSON parsing"
+fi
+
+# parse_json() - extract a value from JSON stdin
+# Uses jq (primary) with python3 fallback
+# Auto-unwraps single-element arrays (bd show --json returns [...])
+# Usage: echo '[{"status":"open"}]' | parse_json '.status'
+parse_json() {
+  local filter="$1"
+  if [ "$HAS_JQ" = true ]; then
+    jq -r "if type == \\"array\\" then .[0] else . end | $filter"
+  else
+    python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+if isinstance(data, list):
+    data = data[0] if data else {}
+f = '$filter'.strip('.')
+parts = [p for p in f.split('.') if p]
+v = data
+try:
+    for p in parts:
+        v = v[p]
+except (KeyError, IndexError, TypeError):
+    v = None
+print('' if v is None else v)
+"
+  fi
+}
+
+mkdir -p "$LOG_DIR"
+` + buildEpicSelector() + buildPromptFunction();
+}
 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}`);
@@ -11599,7 +11718,7 @@ function generateLoopScript(options) {
   validateOptions(options);
   const epicIds = options.epics?.join(" ") ?? "";
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  return buildScriptHeader(timestamp, options.maxRetries, options.model, epicIds) + buildStreamExtractor() + buildMainLoop();
+  return buildScriptHeader(timestamp, options.maxRetries, options.model, epicIds) + buildStreamExtractor() + buildMarkerDetection() + buildObservability() + buildMainLoop();
 }
 async function handleLoop(cmd, options) {
   const outputPath = resolve(options.output ?? "./infinity-loop.sh");