karajan-code 2.7.4 → 2.8.0

package/README.md

@@ -23,7 +23,7 @@
 
 ---
 
-> **v2.7.4 released** — Three contract fixes: (1) **Sonar is now intrinsic** to Karajan for code tasks (`sw`/`refactor`/`add-tests`) — `sonarqube.enabled` config and `--no-sonar` flag are ignored with a deprecation warning; a code task without a quality gate is not a job Karajan calls complete, like TDD; Solomon still may skip an iteration at runtime via rules. (2) **Preflight no longer demands API keys Karajan doesn't use** — the bogus `ANTHROPIC_API_KEY not set` check was blocking every Claude Code MCP run; replaced with a real CLI availability check (`claude`, `codex`, `gemini` on PATH). (3) **Orchestrator no longer crashes** with `Cannot read properties of undefined (reading 'push')` on the Solomon init-error path. Adds two architectural invariants (`no-provider-apis`, `sonar-intrinsic`) to CI so the contracts can't silently drift back. New `docs/TESTS.md` test-suite guide with diagrams. See [CHANGELOG.md](./CHANGELOG.md) for full history and [MIGRATION-v2.md](./MIGRATION-v2.md) for v1→v2 breaking changes.
+> **v2.8.0 released** — Audit-driven hardening release. The 2026-04-30 self-audit (`kj audit`) flagged 13 issues across security, code quality, performance, architecture and testing; this release closes all of them in 16 PRs with 0 user-visible API changes. Highlights: (1) **Security**: every `child_process` call in `src/` now uses tokenised arg arrays (no shell expansion) — closed 7 sites that took template strings. (2) **FASE 1 e2e suite**: 7 scenarios + fake-coder/sonar fixtures cover the 5-bug class from the 2026-04-27 demo regression (zombie-HU, saveSession-missing, Repairer unfixable, zombi-status, audit smoke). 23 e2e tests in 6s. (3) **File splits**: `cli.js` 699→113 LOC, `commands/plan.js` 549→14 LOC (shim) + sub-commands, `iteration-loop.js` 513→311 LOC, `pre-loop.js` 626→435 LOC. Each big driver now under the 600-LOC ceiling. (4) **ESLint ratcheted**: 57 warnings closed in `src/`, then `no-unused-vars` / `no-useless-assignment` / `no-useless-escape` / `preserve-caught-error` switched warn→error so regressions fail CI. New rules ban `console.*` outside CLI paths and `globalThis.__KJ_*` outside `test-harness.js`. (5) **BREAKING**: `engines.node` 18→20.10.0 (Node 18 LTS hit EOL 2025-04-30). See [CHANGELOG.md](./CHANGELOG.md) for the full punch list and [MIGRATION-v2.md](./MIGRATION-v2.md) for v1→v2 breaking changes.
 
 You describe what you want to build. Karajan orchestrates multiple AI agents to plan it, implement it, test it, review it with SonarQube, and iterate. No babysitting required.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "2.7.4",
+  "version": "2.8.0",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",
@@ -24,7 +24,13 @@
     "cli"
   ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.10.0"
+  },
+  "imports": {
+    "#utils/*": "./src/utils/*",
+    "#session/*": "./src/session/*",
+    "#hu/*": "./src/hu/*",
+    "#skills/*": "./src/skills/*"
   },
   "files": [
     "src/",
@@ -46,11 +52,19 @@
     "setup": "node scripts/install.js",
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint": "((command -v rg >/dev/null 2>&1 && rg --files src tests | rg '\\.js$') || find src tests -type f -name '*.js') | while IFS= read -r f; do node --check \"$f\"; done",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "lint:syntax": "((command -v rg >/dev/null 2>&1 && rg --files src tests | rg '\\.js$') || find src tests -type f -name '*.js') | while IFS= read -r f; do node --check \"$f\"; done",
     "typecheck": "npx -p typescript@5 tsc --noEmit -p tsconfig.json",
-    "validate": "npm run lint && npm test",
+    "validate": "npm run lint && npm run lint:syntax && npm test",
     "mcp": "node src/mcp/server.js"
   },
+  "simple-git-hooks": {
+    "pre-commit": "npx lint-staged"
+  },
+  "lint-staged": {
+    "src/**/*.js": "eslint --max-warnings=999"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "commander": "^14.0.0",
@@ -60,9 +74,15 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.30.0",
+    "@eslint/js": "^10.0.1",
     "@vitest/coverage-v8": "^4.0.18",
     "esbuild": "^0.28.0",
+    "eslint": "^10.2.1",
+    "eslint-plugin-import-x": "^4.16.2",
+    "globals": "^17.5.0",
+    "lint-staged": "^16.4.0",
     "postject": "^1.0.0-alpha.6",
+    "simple-git-hooks": "^2.13.1",
     "vitest": "^4.0.0"
   }
 }

package/scripts/diet-baseline.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * Test Diet — baseline snapshot generator.
+ *
+ * Captures the *current* state of the unit test suite so subsequent diet
+ * commits (HU plan-20260429094214-0srv_002 .. _008) can prove they did not
+ * blow past the guardrails (wall-clock budget and branch-coverage drop).
+ *
+ * Output file: tests/_diet/baseline.json
+ *
+ * Schema:
+ *   {
+ *     capturedAt:        ISO-8601 timestamp,
+ *     locTotal:          total wc -l across every tests/...test.js file,
+ *     wallClockSec:      number,  // `time npm test` wall-clock
+ *     branchCoveragePct: number,  // src/ branch coverage % from vitest --coverage
+ *     fileCount:         number,  // files.length
+ *     files:             [ { path, loc, architecture } ]
+ *   }
+ *
+ * The script is intentionally *measurement-only*: it never edits source
+ * or test files. Re-running it overwrites the snapshot — but the diet
+ * compares against the committed copy, not the latest run.
+ */
+
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_ROOT = resolve(fileURLToPath(import.meta.url), "..", "..");
+const OUTPUT_PATH = resolve(REPO_ROOT, "tests/_diet/baseline.json");
+const ARCH_PREFIX = "tests/architecture/";
+
+/**
+ * Enumerate every committed `tests/**\/*.test.js` file via `git ls-files`.
+ * Using git rather than fs walk keeps the snapshot reproducible: untracked
+ * scratch files in someone's worktree never leak into the baseline.
+ *
+ * @returns {string[]} repo-relative paths
+ */
+function listTestFiles() {
+  const out = execFileSync(
+    "git",
+    ["ls-files", "tests"],
+    { cwd: REPO_ROOT, encoding: "utf8" }
+  );
+  return out
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.endsWith(".test.js"));
+}
+
+/**
+ * Count lines in a file. Uses readFileSync because the files are small and
+ * spawning `wc -l` 300+ times is wasteful.
+ *
+ * @param {string} absPath
+ * @returns {number}
+ */
+function countLines(absPath) {
+  const content = readFileSync(absPath, "utf8");
+  if (content.length === 0) return 0;
+  // wc -l counts newlines; mimic that so the JSON matches `wc -l` output.
+  let lines = 0;
+  for (let i = 0; i < content.length; i += 1) {
+    if (content.charCodeAt(i) === 10) lines += 1;
+  }
+  return lines;
+}
+
+/**
+ * Run `npm test` once and report wall-clock seconds. The suite has a
+ * pre-existing architecture-budget failure (tests/architecture/dynamic-imports);
+ * its exit code is irrelevant for the wall-clock baseline.
+ *
+ * @returns {number} seconds, rounded to 2 decimals
+ */
+function measureWallClock() {
+  const started = process.hrtime.bigint();
+  spawnSync("npm", ["test", "--silent"], {
+    cwd: REPO_ROOT,
+    stdio: "ignore"
+  });
+  const elapsedNs = process.hrtime.bigint() - started;
+  return Math.round(Number(elapsedNs) / 1e7) / 100;
+}
+
+/**
+ * Run vitest with v8 coverage and parse the `text-summary` reporter output
+ * for the `Branches` percentage of the src/ tree.
+ *
+ * The architecture-budget test fails before the coverage summary is emitted,
+ * so we exclude that single file from this measurement run only. It scans
+ * source files statically and does not exercise src/ runtime code, so its
+ * absence does not move branch coverage in any meaningful way.
+ *
+ * @returns {number} branch coverage % (e.g. 17.23)
+ */
+function measureBranchCoverage() {
+  const result = spawnSync(
+    "npx",
+    [
+      "vitest",
+      "run",
+      "--coverage",
+      "--coverage.provider=v8",
+      "--coverage.reporter=text-summary",
+      "--exclude=tests/architecture/dynamic-imports.test.js"
+    ],
+    { cwd: REPO_ROOT, encoding: "utf8" }
+  );
+  const out = `${result.stdout}\n${result.stderr}`;
+  const match = out.match(/Branches\s*:\s*([\d.]+)%/);
+  if (!match) {
+    throw new Error(
+      "Could not parse branch coverage from vitest output:\n" +
+        out.slice(-2000)
+    );
+  }
+  return Number(match[1]);
+}
+
+/**
+ * Build the files[] array with metadata for every test file.
+ *
+ * @param {string[]} relativePaths
+ * @returns {Array<{path: string, loc: number, architecture: boolean}>}
+ */
+function buildFileEntries(relativePaths) {
+  return relativePaths
+    .map((rel) => ({
+      path: rel,
+      loc: countLines(resolve(REPO_ROOT, rel)),
+      architecture: rel.startsWith(ARCH_PREFIX)
+    }))
+    .sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function main() {
+  const relPaths = listTestFiles();
+  const files = buildFileEntries(relPaths);
+  const locTotal = files.reduce((sum, f) => sum + f.loc, 0);
+
+  // Order matters: cheap measurements first, expensive ones last, so a
+  // wedge in the slow ones is easy to bisect via Ctrl-C.
+  const wallClockSec = measureWallClock();
+  const branchCoveragePct = measureBranchCoverage();
+
+  const baseline = {
+    capturedAt: new Date().toISOString(),
+    locTotal,
+    wallClockSec,
+    branchCoveragePct,
+    fileCount: files.length,
+    files
+  };
+
+  mkdirSync(dirname(OUTPUT_PATH), { recursive: true });
+  writeFileSync(OUTPUT_PATH, `${JSON.stringify(baseline, null, 2)}\n`, "utf8");
+
+  process.stdout.write(
+    `Wrote ${relative(REPO_ROOT, OUTPUT_PATH)} — ` +
+      `${baseline.fileCount} files, ${baseline.locTotal} LOC, ` +
+      `${baseline.wallClockSec}s wall-clock, ` +
+      `${baseline.branchCoveragePct}% branch coverage.\n`
+  );
+}
+
+main();

package/scripts/regen-arch-stats.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# Regenerate the numeric stats in docs/ARCHITECTURE.md from the current tree.
+#
+# Motivation: docs/ARCHITECTURE.md accumulates staleness. The v2.7.4 audit
+# found it claimed "28k LOC, 234 files" when reality was 35.9k LOC / 260
+# files (+28% LOC, +11% files), and pointed at `src/orchestrator.js` as the
+# main pipeline (~1400 LOC) when the real orchestrator is
+# `src/orchestrator/flow-runner.js` (2241 LOC) and `src/orchestrator.js` is
+# a 22-line barrel.
+#
+# This script rewrites the specific lines that contain numeric stats
+# in-place; narrative paragraphs are left alone.
+#
+# Usage:
+#   scripts/regen-arch-stats.sh          # rewrite and exit 0
+#   scripts/regen-arch-stats.sh --check  # exit 1 if the file would change
+#
+# Add to the release checklist: run without --check, commit any diff.
+set -euo pipefail
+
+MODE="${1:-}"
+DOC="docs/ARCHITECTURE.md"
+
+if [[ ! -f "$DOC" ]]; then
+  echo "ARCHITECTURE.md not found at $DOC — run from the repo root." >&2
+  exit 2
+fi
+
+# ── Compute current stats ──────────────────────────────────────────────
+
+SRC_LOC=$(find src -name "*.js" -not -path "*/node_modules/*" | xargs wc -l 2>/dev/null | tail -1 | awk '{print $1}')
+SRC_FILES=$(find src -name "*.js" -not -path "*/node_modules/*" | wc -l)
+TEST_COUNT=$(find tests -name "*.test.js" -not -path "*/worktrees/*" -not -path "*/.kj/*" | wc -l)
+
+# Format LOC with thousands separator ("36038" → "36k" for narrative, raw for table)
+SRC_LOC_SHORT=$(awk -v n="$SRC_LOC" 'BEGIN{ printf "%dk", int(n/1000) }')
+
+# Orchestrator pipeline stats
+FLOW_RUNNER_LOC=$(wc -l < src/orchestrator/flow-runner.js 2>/dev/null | awk '{print $1}')
+BARREL_LOC=$(wc -l < src/orchestrator.js 2>/dev/null | awk '{print $1}')
+
+# ── Build a sed program ────────────────────────────────────────────────
+# Each line targets a specific claim. Patterns are narrow enough to miss
+# unrelated mentions but wide enough to absorb small formatting drifts.
+
+SED_SCRIPT=$(cat <<EOF
+s|Source code ([0-9kKmM.]\\+ LOC, [0-9]\\+ files)|Source code (${SRC_LOC_SHORT} LOC, ${SRC_FILES} files)|g
+s|Test suite ([0-9]\\+ tests)|Test suite (${TEST_COUNT} test files)|g
+s|\`src/orchestrator.js\` (~[0-9]\\+ LOC)|\`src/orchestrator.js\` (${BARREL_LOC}-line barrel) → delegates to \`src/orchestrator/flow-runner.js\` (${FLOW_RUNNER_LOC} LOC)|g
+EOF
+)
+
+if [[ "$MODE" == "--check" ]]; then
+  if sed "$SED_SCRIPT" "$DOC" | diff -q "$DOC" - >/dev/null; then
+    echo "docs/ARCHITECTURE.md stats are up to date."
+    exit 0
+  fi
+  echo "docs/ARCHITECTURE.md stats are STALE. Run scripts/regen-arch-stats.sh to rewrite." >&2
+  sed "$SED_SCRIPT" "$DOC" | diff -u "$DOC" - || true
+  exit 1
+fi
+
+# Real rewrite, in place, with backup we immediately delete to keep the
+# working tree clean.
+sed -i.bak "$SED_SCRIPT" "$DOC"
+rm -f "${DOC}.bak"
+
+echo "docs/ARCHITECTURE.md updated with:"
+echo "  Source code: ${SRC_LOC_SHORT} LOC, ${SRC_FILES} files"
+echo "  Tests:       ${TEST_COUNT} test files"
+echo "  Orchestrator: src/orchestrator.js ${BARREL_LOC}-line barrel → flow-runner.js ${FLOW_RUNNER_LOC} LOC"

package/src/agents/availability.js

@@ -4,16 +4,22 @@ import { getAgentMeta } from "./index.js";
 
 export async function assertAgentsAvailable(agentNames = []) {
   const unique = [...new Set(agentNames.filter(Boolean))];
-  const missing = [];
 
-  for (const name of unique) {
-    const meta = getAgentMeta(name);
-    if (!meta?.bin) continue;
-    const res = await runCommand(resolveBin(meta.bin), ["--version"]);
-    if (res.exitCode !== 0) {
-      missing.push({ name, ...meta });
-    }
-  }
+  // PR-J (audit quick win): probe every agent CLI in parallel via
+  // Promise.all instead of awaiting in a for-of loop. Each probe is
+  // an independent fork+exec with no shared state, so serialising
+  // them was wasted preflight latency: O(n) shell-outs becomes O(1)
+  // (max of all probes). On 4 agents at ~80ms each this drops the
+  // wait from ~320ms to ~80ms.
+  const probes = await Promise.all(
+    unique.map(async (name) => {
+      const meta = getAgentMeta(name);
+      if (!meta?.bin) return null;
+      const res = await runCommand(resolveBin(meta.bin), ["--version"]);
+      return res.exitCode !== 0 ? { name, ...meta } : null;
+    })
+  );
+  const missing = probes.filter(Boolean);
 
   if (missing.length === 0) return;
 

package/src/agents/claude-agent.js

@@ -72,10 +72,10 @@ function collectAssistantText(obj) {
  * Returns an object with tokens_in, tokens_out, cost_usd, model or null if not found.
  */
 function extractUsageFromStreamJson(raw) {
-  const lines = (raw || "").split("\n").filter(Boolean);
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const obj = tryParseJson(lines[i]);
-    if (!obj || obj.type !== "result") continue;
+  const events = parseClaudeEvents(raw);
+  for (let i = events.length - 1; i >= 0; i--) {
+    const obj = events[i];
+    if (obj.type !== "result") continue;
 
     const tokens_in = obj.usage?.input_tokens ?? 0;
     const tokens_out = obj.usage?.output_tokens ?? 0;
@@ -89,25 +89,54 @@ function extractUsageFromStreamJson(raw) {
 }
 
 /**
- * Extract the final text result from stream-json NDJSON output.
- * Each line is a JSON object. We collect assistant text content from
- * "result" messages and fall back to accumulating "content_block_delta" text.
+ * Normalize Claude's output payload to a flat array of event objects.
+ *
+ * Claude 2.x supports two on-disk shapes depending on the output-format flag:
+ *
+ *   --output-format stream-json → NDJSON, one event JSON per line
+ *   --output-format json        → a single JSON array with every event
+ *
+ * The legacy path assumed NDJSON and silently dropped the `json` variant
+ * (split("\n") returned one unparseable "line" containing the whole array,
+ * extract returned empty, caller fell back to the raw string — which made
+ * `kj plan` save the whole stream as `approach` with zero HUs). Handle both
+ * shapes here so callers see a uniform list of events regardless of flag.
+ */
+function parseClaudeEvents(raw) {
+  const trimmed = (raw || "").trim();
+  if (!trimmed) return [];
+  // `--output-format json` → single JSON array.
+  if (trimmed.startsWith("[")) {
+    try {
+      const arr = JSON.parse(trimmed);
+      if (Array.isArray(arr)) return arr.filter((o) => o && typeof o === "object");
+    } catch { /* fall through to NDJSON */ }
+  }
+  // `--output-format stream-json` → NDJSON, one event per line.
+  const events = [];
+  for (const line of trimmed.split("\n")) {
+    const obj = tryParseJson(line);
+    if (obj && typeof obj === "object") events.push(obj);
+  }
+  return events;
+}
+
+/**
+ * Extract the final text result from Claude's output (either stream-json
+ * NDJSON or single-array json — see parseClaudeEvents). We look for the
+ * `result` message first (holds the final text); if missing, concatenate
+ * every assistant text block encountered.
  */
 function extractTextFromStreamJson(raw) {
-  const lines = (raw || "").split("\n").filter(Boolean);
-  // Try to find a "result" message with the final text
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const obj = tryParseJson(lines[i]);
-    if (!obj) continue;
-    const result = extractResultText(obj);
+  const events = parseClaudeEvents(raw);
+  // Walk from the end — the final `result` event is the last one.
+  for (let i = events.length - 1; i >= 0; i--) {
+    const result = extractResultText(events[i]);
     if (result) return result;
   }
-  // Fallback: accumulate all assistant text deltas
+  // Fallback: accumulate every assistant text block in order.
   const parts = [];
-  for (const line of lines) {
-    const obj = tryParseJson(line);
-    if (obj) parts.push(...collectAssistantText(obj));
-  }
+  for (const obj of events) parts.push(...collectAssistantText(obj));
   return parts.join("") || raw;
 }
 
@@ -138,36 +167,105 @@ function summarizeToolCall(name, input = {}) {
   }
 }
 
-function createStreamJsonFilter(onOutput) {
+/**
+ * Translate a Claude stream-json event into a human-readable summary.
+ *
+ * Returns a `{ line, kind }` object for the cli-progress reporter to
+ * display, OR `null` to suppress (the event is structural noise).
+ *
+ * Whitelist semantics on purpose: pre-v2.7.5 the filter ONLY recognised
+ * `assistant` + `result` and forwarded everything else as raw JSON,
+ * which dumped 6 KB of `system/init` + `rate_limit_event` to the user
+ * on every `kj plan`. Now we recognise every event type Claude can
+ * emit and either condense it to one line or drop it. Unknown types
+ * are dropped silently unless DEBUG_KJ_AGENT is set.
+ */
+export function translateStreamJsonEvent(obj) {
+  switch (obj.type) {
+    case "system": {
+      // The init frame announces session id + model. Useful as a single
+      // status line on first connect; the rate_limit subtype on a
+      // healthy session is pure noise — suppress.
+      if (obj.subtype === "init") {
+        const model = typeof obj.model === "string" ? obj.model : "?";
+        return { line: `Claude session ready (model: ${model.replace(/\[.*\]/, "")})`, kind: "text" };
+      }
+      return null;
+    }
+    case "rate_limit_event": {
+      const status = obj.rate_limit_info?.status;
+      // Only surface when actually throttled — "allowed" is the happy
+      // path and surfaces every few seconds during normal runs.
+      if (status && status !== "allowed") {
+        return { line: `Rate limit: ${status}`, kind: "text" };
+      }
+      return null;
+    }
+    case "user": {
+      // Echoes of the previous tool's output coming back into the
+      // conversation. Adding a line per echo would double the noise of
+      // the corresponding tool_use line, which we already render.
+      return null;
+    }
+    case "assistant": {
+      const content = obj.message?.content;
+      if (!Array.isArray(content)) return null;
+      // Each content block becomes a separate line — we return them
+      // through the caller's emit-many path below.
+      return { _multi: true, blocks: content };
+    }
+    case "result": {
+      const summary = typeof obj.result === "string"
+        ? obj.result.split("\n")[0].slice(0, 120)
+        : "result received";
+      return { line: `done: ${summary}` };
+    }
+    default: {
+      if (process.env.DEBUG_KJ_AGENT) {
+        return { line: `[debug] unknown event: ${obj.type}` };
+      }
+      return null;
+    }
+  }
+}
+
+export function createStreamJsonFilter(onOutput) {
   if (!onOutput) return null;
   return ({ stream, line }) => {
+    let obj;
     try {
-      const obj = JSON.parse(line);
-      // Forward assistant content
-      if (obj.type === "assistant" && obj.message?.content) {
-        for (const block of obj.message.content) {
-          if (block.type === "text" && block.text) {
-            // Only emit first line of text for brevity
-            const firstLine = block.text.split("\n")[0].trim().slice(0, 120);
-            if (firstLine) onOutput({ stream, line: firstLine, kind: "text" });
-          } else if (block.type === "tool_use") {
-            onOutput({ stream, line: summarizeToolCall(block.name, block.input), kind: "tool" });
-          } else if (block.type === "thinking" && block.thinking) {
-            onOutput({ stream, line: `thinking: ${block.thinking.slice(0, 80).replace(/\s+/g, " ")}…`, kind: "thinking" });
-          }
-        }
-        return;
+      obj = JSON.parse(line);
+    } catch {
+      // Not JSON — forward verbatim ONLY if it's short and not a partial
+      // JSON chunk (some agents print stderr diagnostics through the
+      // same channel). Anything that smells like JSON-debris gets
+      // dropped to keep the CLI clean.
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("{") && !trimmed.startsWith("[") && trimmed.length < 200) {
+        onOutput({ stream, line: trimmed });
       }
-      // Forward result
-      if (obj.type === "result") {
-        const summary = typeof obj.result === "string"
-          ? obj.result.split("\n")[0].slice(0, 120)
-          : "result received";
-        onOutput({ stream, line: `done: ${summary}` });
-        return;
+      return;
+    }
+
+    const summary = translateStreamJsonEvent(obj);
+    if (!summary) return;
+
+    // Multi-block assistant payload: one line per content block.
+    if (summary._multi) {
+      for (const block of summary.blocks) {
+        if (block.type === "text" && block.text) {
+          const firstLine = block.text.split("\n")[0].trim().slice(0, 120);
+          if (firstLine) onOutput({ stream, line: firstLine, kind: "text" });
+        } else if (block.type === "tool_use") {
+          onOutput({ stream, line: summarizeToolCall(block.name, block.input), kind: "tool" });
+        } else if (block.type === "thinking" && block.thinking) {
+          onOutput({ stream, line: `thinking: ${block.thinking.slice(0, 80).replace(/\s+/g, " ")}…`, kind: "thinking" });
+        }
       }
-    } catch { /* not JSON, forward raw */ }
-    onOutput({ stream, line });
+      return;
+    }
+
+    onOutput({ stream, line: summary.line, kind: summary.kind });
   };
 }
 
@@ -190,7 +288,7 @@ function createStreamJsonFilter(onOutput) {
  *    response data.
  */
 function cleanExecaOpts(extra = {}) {
-  const { CLAUDECODE, ...env } = process.env;
+  const { CLAUDECODE: _CLAUDECODE, ...env } = process.env;
   return { env, stdin: "ignore", ...extra };
 }
 
@@ -235,7 +333,7 @@ export class ClaudeAgent extends BaseAgent {
     return result;
   }
 
-  async _runTaskExec(task, model, role) {
+  async _runTaskExec(task, model, _role) {
     const args = ["-p", task.prompt, "--allowedTools", ...ALLOWED_TOOLS];
     if (model) args.push("--model", model);
 

package/src/agents/model-registry.js

@@ -45,7 +45,7 @@ export function getModelInfo(name) {
 }
 
 export function getRegisteredModels() {
-	return [...modelRegistry.entries()].map(([name, entry]) => ({
+	return [...modelRegistry.entries()].map(([_name, entry]) => ({
 		name: entry.name,
 		provider: entry.provider,
 		pricing: { ...entry.pricing },