cool-workflow 0.1.91 → 0.1.92

package/dist/orchestrator/report.js

@@ -25,6 +25,11 @@ function writeReport(run) {
     (0, dispatch_1.updatePhaseStatuses)(run);
     const workerSummary = (0, worker_isolation_1.summarizeWorkers)(run);
     const candidateSummary = (0, candidate_scoring_1.summarizeCandidates)(run);
+    // A research run reads a local folder of files, not a code repo — label its source line
+    // "Source". Skip the relabel when the run ALSO carries a remote-provenance "- Source: <url>"
+    // line below (run.inputs.sourceUrl set by a --link/URL), so a report never shows two
+    // "- Source:" lines. Every other app keeps the byte-identical "Repository:" (POLA).
+    const sourceLabel = run.workflow.app?.metadata?.domain === "research" && !run.inputs.sourceUrl ? "Source" : "Repository";
     const report = [
         `# ${run.workflow.title}`,
         "",
@@ -38,7 +43,7 @@ function writeReport(run) {
             : []),
         `- Created: ${run.createdAt}`,
         `- Updated: ${run.updatedAt}`,
-        `- Repository: ${String(run.inputs.repo || run.cwd)}`,
+        `- ${sourceLabel}: ${String(run.inputs.repo || run.cwd)}`,
         // Remote provenance (v0.1.91): when the repo was materialized from a --link/URL, record
         // the sanitized origin + resolved commit so the report itself says where the code came
         // from. Conditional — absent for a local-repo run, so existing reports stay byte-identical.

package/dist/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION = exports.LEGACY_RUN_STATE_SCHEMA_VERSION = exports.CURRENT_RUN_STATE_SCHEMA_VERSION = exports.WORKFLOW_APP_SCHEMA_VERSION = exports.CURRENT_COOL_WORKFLOW_VERSION = void 0;
-exports.CURRENT_COOL_WORKFLOW_VERSION = "0.1.91";
+exports.CURRENT_COOL_WORKFLOW_VERSION = "0.1.92";
 exports.WORKFLOW_APP_SCHEMA_VERSION = 1;
 exports.CURRENT_RUN_STATE_SCHEMA_VERSION = 1;
 exports.LEGACY_RUN_STATE_SCHEMA_VERSION = 0;

package/docs/agent-delegation-drive.7.md

@@ -336,3 +336,5 @@ The one-command `cw -q` headline now routes the question and defaults the repo t
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/canonical-workflow-apps.7.md

@@ -98,6 +98,11 @@ node scripts/cw.js plan release-cut \
 Break a research question into claims, look into sources, cross-check
 the evidence, check the claims, and put together a short answer.
 
+When you point it at a folder, it reads the local files there as primary
+sources. So this app works over any corpus — your own docs, notes, or
+papers — not only a git code repo. The working directory is the corpus,
+so the agent can back its answer with your own files.
+
 ```bash
 node scripts/cw.js plan research-synthesis \
   --cwd /tmp/research-run \
@@ -107,6 +112,13 @@ node scripts/cw.js plan research-synthesis \
   --freshness "as of today"
 ```
 
+Over a local corpus folder, point `--repo` at it:
+
+```bash
+cw quickstart research-synthesis --repo /path/to/papers \
+  --question "What do these papers conclude?"
+```
+
 ## Validation Matrix
 
 Run the canonical app matrix from the plugin root directory:

package/docs/cli-mcp-parity.7.md

@@ -528,3 +528,5 @@ CLI golden-path fixes: `cw -q "…"` routes the question (was read as an app id
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/contract-migration-tooling.7.md

@@ -161,3 +161,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/control-plane-scheduling.7.md

@@ -145,3 +145,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/durable-state-and-locking.7.md

@@ -144,3 +144,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/evidence-adoption-reasoning-chain.7.md

@@ -305,3 +305,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/execution-backends.7.md

@@ -335,3 +335,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/multi-agent-cli-mcp-surface.7.md

@@ -303,3 +303,5 @@ The host-facing surface tracks the CLI golden-path fixes (`cw -q` routing + repo
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/multi-agent-eval-replay-harness.7.md

@@ -337,3 +337,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/multi-agent-operator-ux.7.md

@@ -349,3 +349,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/node-snapshot-diff-replay.7.md

@@ -170,3 +170,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/observability-cost-accounting.7.md

@@ -229,3 +229,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/project-index.md

@@ -5,11 +5,11 @@ Generated from the current repository code on 2026-06-21 by `npm run sync:projec
 ## Snapshot
 
 - Package: `cool-workflow`
-- Version: `0.1.91`
+- Version: `0.1.92`
 - Source modules: `68`
 - Workflow apps: `7`
 - Docs: `53`
-- Smoke tests: `137`
+- Smoke tests: `139`
 - Repository: https://github.com/coo1white/cool-workflow
 
 ## Architecture
@@ -272,9 +272,11 @@ Smoke tests mirror the public contracts. The high-signal suites are:
 - [project-index-sync-smoke.js](../test/project-index-sync-smoke.js)
 - [quickstart-bundle-smoke.js](../test/quickstart-bundle-smoke.js)
 - [quickstart-check-smoke.js](../test/quickstart-check-smoke.js)
+- [quickstart-corpus-smoke.js](../test/quickstart-corpus-smoke.js)
 - [quickstart-no-agent-smoke.js](../test/quickstart-no-agent-smoke.js)
 - [quickstart-readme-path-smoke.js](../test/quickstart-readme-path-smoke.js)
 - [quickstart-smoke.js](../test/quickstart-smoke.js)
+- [readme-sync-smoke.js](../test/readme-sync-smoke.js)
 - [readme-trust-claim-smoke.js](../test/readme-trust-claim-smoke.js)
 - [real-execution-backends-smoke.js](../test/real-execution-backends-smoke.js)
 - [registry-corrupt-fail-closed-smoke.js](../test/registry-corrupt-fail-closed-smoke.js)

package/docs/real-execution-backends.7.md

@@ -177,3 +177,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/release-and-migration.7.md

@@ -317,3 +317,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/release-tooling.7.md

@@ -62,6 +62,15 @@ keeps full coverage while cutting the doubled wall time. The steps that stay
 are the ones NOT covered by `npm test`: build, type check, `npm test`,
 canonical-apps, golden-path, parity, vendor-manifest drift, and `version:sync`.
 
+The drift gates `index:check` (`docs/project-index.md`) and `readme:check`
+(`plugins/cool-workflow/README.md`) also run here. The npm package README is
+GENERATED from the repo-root `README.md` by `scripts/sync-readme.js` — it changes
+only the relative image/link URLs npm cannot render (`docs/assets/*` to
+`raw.githubusercontent.com`, `](LICENSE)`/`](plugins/...)` to `.../blob/main/...`),
+so the npm page and the GitHub page stay identical. Edit the GitHub `README.md`,
+then run `npm run sync:readme`; `readme:check` fails the gate if they drift. The
+teeth live in `test/readme-sync-smoke.js`.
+
 For timing work, the smoke runner can write a JSON timing report without changing
 the normal output:
 
@@ -255,3 +264,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/run-registry-control-plane.7.md

@@ -438,3 +438,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/run-retention-reclamation.7.md

@@ -228,3 +228,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/state-explosion-management.7.md

@@ -306,3 +306,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/team-collaboration.7.md

@@ -242,3 +242,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/docs/web-desktop-workbench.7.md

@@ -250,3 +250,5 @@ _No behavioral change in v0.1.89 (CLI-surface golden-path + help-output fixes on
 0.1.90
 
 0.1.91
+
+0.1.92

package/manifest/plugin.manifest.json

@@ -2,7 +2,7 @@
   "_comment": "SINGLE SOURCE OF TRUTH for every vendor manifest. Edit THIS file, then run `npm run gen:manifests`. Do NOT hand-edit the generated vendor manifests (.claude-plugin/, .codex-plugin/, .agents/, .mcp.json) — `npm run gen:manifests -- --check` (run by release:check) will fail if they drift from this source.",
   "identity": {
     "name": "cool-workflow",
-    "version": "0.1.91",
+    "version": "0.1.92",
     "license": "BSD-2-Clause",
     "homepage": "https://github.com/coo1white/cool-workflow",
     "author": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cool-workflow",
-  "version": "0.1.91",
+  "version": "0.1.92",
   "bin": {
     "cool-workflow": "scripts/cw.js",
     "cw": "scripts/cw.js"
@@ -49,6 +49,8 @@
     "fixture-compat": "node test/run-fixture-compat-smoke.js",
     "sync:project-index": "node scripts/sync-project-index.js",
     "index:check": "node scripts/sync-project-index.js --check",
+    "sync:readme": "node scripts/sync-readme.js",
+    "readme:check": "node scripts/sync-readme.js --check",
     "bump:version": "node scripts/bump-version.js",
     "new:feature": "node scripts/new-feature.js",
     "forward-ref": "node scripts/forward-ref-docs.js",

package/scripts/agents/agent-adapter-core.js

@@ -54,7 +54,8 @@ function trace(line, env = process.env, stderr = process.stderr) {
 // ---- live renderer (zero-dep, hand-rolled — kept self-contained so this wrapper stays a
 //      copyable "config", not a build-coupled dependency) -----------------------------------
 
-const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+// The live "thinking" glyph cycles a sparkle (Claude-Code feel), not a generic braille spinner.
+const SPARKLE = ["✶", "✸", "✹", "✺", "✹", "✸"];
 const ANSI = { reset: "\x1b[0m", dim: "\x1b[2m", green: "\x1b[32m", red: "\x1b[31m", cyan: "\x1b[36m", hideCursor: "\x1b[?25l", showCursor: "\x1b[?25h", clearLine: "\r\x1b[2K" };
 const ANSI_RE = /\x1b\[[0-9;]*m/g;
 
@@ -78,23 +79,34 @@ function fmtElapsed(ms) {
   return s < 60 ? `${s.toFixed(1)}s` : `${Math.floor(s / 60)}m${String(Math.round(s % 60)).padStart(2, "0")}s`;
 }
 
-/** A single live status line (interactive) or append-only lines (non-TTY), plus an always-on
- *  transcript buffer. `action(label)` commits the PREVIOUS action as ✓/✗ then makes `label` the
+/** A calm, FOLDING live view (interactive) or append-only lines (non-TTY), plus an always-on
+ *  transcript buffer. Interactive: a rolling window redrawn IN PLACE — the current action (spinner)
+ *  plus the last WINDOW completed tools (dimmed). Older tools fold away (the full trail is always in
+ *  the transcript), so the region stays a few rows and never grows into a wall; at the end it
+ *  collapses to ONE summary line. `action(label)` commits the PREVIOUS action then makes `label` the
  *  current spinning action — vendor-neutral folding without needing reliable start/end pairing. */
 function createRenderer(opts = {}) {
   const env = opts.env || process.env;
   const stderr = opts.stderr || process.stderr;
+  const label = String(opts.label || "agent"); // provider name, only for the end-of-run summary line
   const interactive = streamEnabled(env) && Boolean(stderr.isTTY);
   // Non-TTY default stays SILENT (CW's Rule of Silence). Plain append-only logging in non-TTY
   // is an explicit opt-in for CI debuggability — `CW_AGENT_STREAM=1`, mirroring CW_DRIVE_PROGRESS=1.
   const plain = streamEnabled(env) && !stderr.isTTY && env.CW_AGENT_STREAM === "1";
   const verbose = env.CW_VERBOSE === "1" || env.CW_VERBOSE === "true" || env.CW_OUTPUT === "full";
   const color = colorOn(env, stderr);
-  const width = Math.max(20, Math.min(120, Number(stderr.columns) || 80));
   const paint = (code, text) => (color ? `${code}${text}${ANSI.reset}` : text);
 
+  // How many completed tools stay visible above the spinner (the rolling window). Env-tunable.
+  const WINDOW = Math.max(0, Math.min(20, Number(env.CW_LIVE_ROWS) || 4));
+  const INDENT = "  ";
+  const cols = () => Math.max(20, Math.min(200, Number(stderr.columns) || 80));
+
   const transcript = [];
-  let live = "";        // current rendered live line (no trailing newline) when interactive
+  const recent = [];    // [{ label, ms, failed }] — last WINDOW completed actions (interactive)
+  let blockRows = 0;    // terminal rows the live block occupied last frame (for in-place erase)
+  let steps = 0;        // total completed actions (for the summary line)
+  const runStart = Date.now();
   let timer = null;
   let frame = 0;
   let cursorHidden = false;
@@ -111,49 +123,133 @@ function createRenderer(opts = {}) {
     process.once("SIGTERM", onSignal);
   }
 
-  const renderLive = () => {
-    if (!interactive || !current) return;
+  // One completed-tool row, Claude-tree style: `  ● Read(foo.ts)` — the bullet is green (red on
+  // failure), the tool name bold + its (arg) dimmed; no per-tool duration. Width-truncated.
+  const styledLabel = (label, width) => {
+    const text = truncate(label, width - 4);
+    const m = /^(\w+)\((.*)\)$/.exec(text);
+    if (m) return `${m[1]}${paint(ANSI.dim, `(${m[2]})`)}`;
+    return text;
+  };
+  const doneLine = (item, width) => {
+    const bullet = paint(item.failed ? ANSI.red : ANSI.green, "●");
+    return `${INDENT}${bullet} ${styledLabel(item.label, width)}`;
+  };
+  // The live "thinking" row, Claude-tree style: `  ✶ Reading foo.ts… (4s)` — a sparkle + a
+  // tool-derived verb phrase + dim elapsed. A non-tool status label is shown as-is (sans trailing …).
+  const livePhrase = () => {
+    const m = /^(\w+)\((.*)\)$/.exec(current.label);
+    if (m) return `${verbFor(m[1])} ${m[2]}`;
+    return current.label.replace(/…+$/, "");
+  };
+  const liveLine = (width) => {
+    const elapsed = `(${fmtElapsed(Date.now() - current.startedAt)})`;
+    const el = paint(ANSI.dim, elapsed);
+    const sp = paint(ANSI.cyan, SPARKLE[frame % SPARKLE.length]);
+    // Reserve EXACT room for the fixed decorations + the VARIABLE elapsed string (which grows from 6
+    // chars `(4.0s)` to 9 `(100m00s)`): indent(2) + sparkle+space(2) + ellipsis+space(2) + elapsed,
+    // minus 1 column of margin. A fixed `width - N` budget overflowed past 1 minute and wrapped.
+    const budget = width - 6 - elapsed.length - 1;
+    return `${INDENT}${sp} ${truncate(livePhrase(), budget)}${paint(ANSI.dim, "…")} ${el}`;
+  };
+
+  // Erase the previously-drawn block in place: go to its first row, clear to end of screen.
+  const eraseBlock = () => {
+    if (!interactive || blockRows <= 0) return;
+    stderr.write("\r");
+    if (blockRows > 1) stderr.write(`\x1b[${blockRows - 1}A`);
+    stderr.write("\x1b[0J");
+    blockRows = 0;
+  };
+
+  // The `⎿ result` tree line under a completed tool (dimmed), e.g. `    ⎿ 245 lines`.
+  const resultLine = (result, width) => `${INDENT}  ${paint(ANSI.dim, `⎿ ${truncate(result, width - 6)}`)}`;
+
+  // Redraw the rolling window (recent ● rows + their ⎿ results + the live spinner) in place.
+  const renderBlock = () => {
+    if (!interactive) return;
     if (!cursorHidden) { stderr.write(ANSI.hideCursor); cursorHidden = true; }
-    const el = paint(ANSI.dim, fmtElapsed(Date.now() - current.startedAt));
-    const sp = paint(ANSI.cyan, SPINNER[frame % SPINNER.length]);
-    live = `${sp} ${truncate(current.label, width - 10)} ${el}`;
-    stderr.write(`${ANSI.clearLine}${live}`);
+    eraseBlock();
+    const width = cols();
+    const lines = [];
+    for (const item of recent.slice(-WINDOW)) {
+      lines.push(doneLine(item, width));
+      if (item.result) lines.push(resultLine(item.result, width));
+    }
+    if (current) lines.push(liveLine(width));
+    if (!lines.length) return;
+    // HARD GUARD: cap EVERY emitted line to the terminal width so none can wrap to a 2nd physical
+    // row. A wrapped row would make blockRows (logical count) under-count the real cursor movement,
+    // so eraseBlock's cursor-up would land a row short and corrupt/creep the block. This also closes
+    // the resize path: each frame caps to the CURRENT width, so a narrowed terminal can't desync.
+    const safe = lines.map((l) => truncate(l, width));
+    stderr.write(safe.join("\n"));
+    blockRows = safe.length;
   };
-  const clearLive = () => { if (interactive && live) { stderr.write(ANSI.clearLine); live = ""; } };
+
   const ensureTimer = () => {
-    if (interactive && !timer) timer = setInterval(() => { frame++; renderLive(); }, 90);
+    if (interactive && !timer) timer = setInterval(() => { frame++; renderBlock(); }, 90);
   };
 
+  // Commit the current action: record it to the transcript + roll it into the window (interactive)
+  // or append a plain line (CI). The interactive REDRAW happens in the caller (action/stop), so a
+  // commit never leaves a permanent per-tool line — that was the 0.1.91 "wall".
   const commit = () => {
     if (!current) return;
     const ms = Date.now() - current.startedAt;
-    const glyph = current.failed ? paint(ANSI.red, "✗") : paint(ANSI.green, "✓");
-    const doneLine = `${glyph} ${paint(ANSI.dim, `${truncate(current.label, width - 12)} (${fmtElapsed(ms)})`)}`;
     transcript.push(`- ${current.failed ? "✗" : "✓"} ${current.label} (${fmtElapsed(ms)})`);
-    if (interactive) { clearLive(); stderr.write(`${doneLine}\n`); }
-    else if (plain) stderr.write(`${current.failed ? "✗" : "✓"} ${current.label} (${fmtElapsed(ms)})\n`);
+    steps += 1;
+    if (interactive) {
+      recent.push({ label: current.label, id: current.id, result: current.result, failed: current.failed });
+      while (recent.length > WINDOW) recent.shift();
+    } else if (plain) {
+      stderr.write(`${current.failed ? "✗" : "✓"} ${current.label} (${fmtElapsed(ms)})\n`);
+    }
     current = null;
   };
 
   return {
-    /** Begin a new active action (commits + folds the previous one). */
-    action(label) {
+    /** Begin a new active action (folds the previous one into the rolling window). `id` (a vendor
+     *  tool_use id) lets a later result() attach to THIS tool even after it has folded — needed when
+     *  one assistant turn dispatches several tools before their results arrive. */
+    action(label, id) {
       commit();
-      current = { label: String(label || "working…"), startedAt: Date.now(), failed: false };
+      current = { label: String(label || "working…"), id, startedAt: Date.now(), failed: false };
       ensureTimer();
-      if (interactive) renderLive();
+      if (interactive) renderBlock();
       else if (plain) stderr.write(`→ ${current.label}\n`);
     },
-    /** Mark the current action as failed (it commits as ✗). */
+    /** Mark the current action as failed (it folds in as a red ●). */
     fail() { if (current) current.failed = true; },
-    /** Narration text from the model. Always to the transcript; inline only in --verbose. */
+    /** Attach a short result summary to a tool — rendered as a dim `⎿ summary` tree line. `id` keys
+     *  it to a SPECIFIC tool_use so a batch of tools dispatched in one turn each keep their own result
+     *  (without an id it falls back to the current tool). Always recorded to the transcript. */
+    result(summary, failed, id) {
+      const s = String(summary || "").replace(/\s+/g, " ").trim();
+      if (!s && !failed) return;
+      // Find the target: prefer the matching id (current, else the most-recent committed item with
+      // that id); otherwise the current tool. This keeps earlier batched tools' ⎿ from being lost.
+      let target = null;
+      if (id != null) {
+        if (current && current.id === id) target = current;
+        else for (let k = recent.length - 1; k >= 0; k -= 1) { if (recent[k].id === id) { target = recent[k]; break; } }
+      }
+      if (!target) target = current;
+      if (target) { if (s) target.result = s; if (failed) target.failed = true; }
+      if (s) transcript.push(`  ⎿ ${s}`);
+      if (plain && s) stderr.write(`  ⎿ ${s}\n`);
+      // A result attached to an ALREADY-folded item must redraw the block to show its new ⎿.
+      if (interactive && target && target !== current) renderBlock();
+    },
+    /** Narration text from the model. Always to the transcript; inline only in --verbose (printed
+     *  ABOVE the live window, which then redraws below it). */
     text(chunk) {
       const t = String(chunk || "").trim();
       if (!t) return;
       transcript.push(t);
       if (!verbose) return;
-      if (interactive) { clearLive(); stderr.write(`${paint(ANSI.dim, truncate(t, width))}\n`); renderLive(); }
-      else if (plain) stderr.write(`${truncate(t, width)}\n`);
+      if (interactive) { eraseBlock(); stderr.write(`${INDENT}${paint(ANSI.dim, truncate(t, cols() - 2))}\n`); renderBlock(); }
+      else if (plain) stderr.write(`${truncate(t, cols())}\n`);
     },
     /** A short status note (e.g. provider summary). Transcript always; inline in --verbose. */
     note(text) { this.text(text); },
@@ -166,10 +262,18 @@ function createRenderer(opts = {}) {
     isVerbose: () => verbose
   };
 
+  // Stop: fold the last action in, erase the live window, and collapse to ONE permanent summary
+  // line (`  ✓ <provider> — N steps · 2m41s`) so the worker leaves a single calm trace.
   function stop() {
     if (timer) { clearInterval(timer); timer = null; }
     commit();
-    clearLive();
+    if (interactive) {
+      eraseBlock();
+      if (steps > 0) {
+        const summary = `${paint(ANSI.green, "●")} ${paint(ANSI.dim, `${label} · ${steps} step${steps === 1 ? "" : "s"} · ${fmtElapsed(Date.now() - runStart)}`)}`;
+        stderr.write(`${INDENT}${summary}\n`);
+      }
+    }
     restoreCursor();
   }
 }
@@ -219,6 +323,52 @@ function toolArgFromEvent(ev) {
   return firstString(input.file_path, input.path, input.pattern, input.command, input.query, input.url, input.cmd) || "";
 }
 
+// ---- Claude-Code-style tool labels: `ToolName(compactArg)` -------------------------------------
+// File tools show the BASENAME (Read(foo.ts), not Read(/Users/…/foo.ts)); everything else (Bash
+// commands, Grep/Glob patterns) is collapsed + truncated. Shared by every wrapper so the look can't
+// drift per vendor.
+const FILE_TOOLS = /^(Read|Write|Edit|MultiEdit|NotebookEdit|NotebookRead)$/i;
+function compactToolArg(name, rawArg) {
+  const s = String(rawArg || "").replace(/\s+/g, " ").trim();
+  if (!s) return "";
+  if (FILE_TOOLS.test(String(name || "")) && s.includes("/")) return s.split("/").filter(Boolean).pop() || s;
+  return s.length > 40 ? `${s.slice(0, 39)}…` : s;
+}
+function toolLabel(name, rawArg) {
+  const n = String(name || "").trim();
+  const arg = compactToolArg(n, rawArg);
+  return arg ? `${n}(${arg})` : n;
+}
+// The present-tense verb for the live "thinking" line, derived from the tool.
+function verbFor(name) {
+  const t = String(name || "").toLowerCase();
+  if (/read|cat|notebookread/.test(t)) return "Reading";
+  if (/write|edit/.test(t)) return "Editing";
+  if (/bash|shell|exec|run|command/.test(t)) return "Running";
+  if (/grep|glob|search|find|ls|list/.test(t)) return "Searching";
+  if (/fetch|web|http|download/.test(t)) return "Fetching";
+  if (/task|agent|sub/.test(t)) return "Delegating";
+  return "Working";
+}
+
+// A short result summary for the `⎿` tree line, derived from the tool + its raw output (Claude-Code
+// feel: `⎿ 245 lines` / `⎿ 12 matches` / `⎿ error`). Heuristic + tool-aware; never throws.
+function summarizeToolResult(name, text, isError) {
+  if (isError) return "error";
+  const raw = String(text || "");
+  const lines = raw.split("\n").filter((l) => l.trim().length).length;
+  const t = String(name || "").toLowerCase();
+  let s;
+  if (/read|cat/.test(t)) s = `${lines} line${lines === 1 ? "" : "s"}`;
+  else if (/glob|ls|find/.test(t)) s = `${lines} file${lines === 1 ? "" : "s"}`;
+  else if (/grep|search/.test(t)) s = `${lines} match${lines === 1 ? "" : "es"}`;
+  else if (/bash|shell|exec|run/.test(t)) {
+    const first = raw.split("\n").map((l) => l.trim()).find(Boolean) || "";
+    s = lines <= 1 && first ? first : `${lines} line${lines === 1 ? "" : "s"}`;
+  } else s = `${lines} line${lines === 1 ? "" : "s"}`;
+  return s.length > 40 ? `${s.slice(0, 39)}…` : s;
+}
+
 function textFromEvent(ev) {
   const delta = maybeObject(ev.delta);
   const msg = maybeObject(ev.message);
@@ -238,8 +388,7 @@ function renderJsonEvent(provider, ev, state) {
 
   const toolName = toolNameFromEvent(ev);
   if (toolName || /tool|command/i.test(type)) {
-    const arg = shortText(toolArgFromEvent(ev), 80);
-    const label = `${toolName || type}${arg ? ` ${arg}` : ""}`;
+    const label = toolLabel(toolName || type, toolArgFromEvent(ev));
     if (r) r.action(label);
     else trace(`  -> ${label}`);
     return;
@@ -307,6 +456,8 @@ module.exports = {
   trace,
   createRenderer,
   truncate, // exported only so cli-render-smoke can assert it stays identical to term.ts truncate()
+  toolLabel, // `ToolName(compactArg)` — shared by the claude wrapper so the label format can't drift
+  summarizeToolResult, // `⎿` result summary — shared so vendors derive it identically
   parseJsonLines,
   flushJsonLines,
   writeResult,

package/scripts/agents/claude-p-agent.js

@@ -34,7 +34,7 @@ const { spawn, spawnSync } = require("node:child_process");
 // wrappers instead of carrying a private copy. A drifted inline copy (ASCII
 // hyphens silently became em-dashes here) meant claude was sent a different
 // instruction text than the other providers for the same contract.
-const { buildPrompt, createRenderer } = require("./agent-adapter-core");
+const { buildPrompt, createRenderer, toolLabel, summarizeToolResult } = require("./agent-adapter-core");
 
 const inputPath = process.argv[2];
 const resultPath = process.argv[3];
@@ -78,17 +78,17 @@ if (!streamEnabled) {
   process.exit(0);
 }
 
-function shortInput(tool, input) {
+// The shared `toolLabel` (from the core) renders `ToolName(basename)` — the Claude-tree label format
+// every vendor uses, so the look can't drift between wrappers.
+function pickInput(input) {
   if (!input || typeof input !== "object") return "";
-  const v = input.file_path || input.path || input.pattern || input.command || input.query || input.url || "";
-  const s = String(v).replace(/\s+/g, " ").trim();
-  return s ? ` ${s.length > 80 ? s.slice(0, 77) + "…" : s}` : "";
+  return input.file_path || input.path || input.pattern || input.command || input.query || input.url || "";
 }
 
 // The live view (spinner + folding actions on a TTY, plain append-only when piped, silent when
 // CW_AGENT_STREAM=0) + cursor hygiene + an always-on-disk transcript live in the shared core.
 void traceEnabled; // superseded by the renderer (which does its own TTY/stream gating)
-const render = createRenderer({ env: process.env, stderr: process.stderr });
+const render = createRenderer({ env: process.env, stderr: process.stderr, label: "claude" });
 const transcriptPath = path.join(path.dirname(resultPath), "transcript.md");
 
 // stream-json so claude emits incremental NDJSON events we render live. We CAPTURE claude's
@@ -128,6 +128,13 @@ child.stdout.on("data", (chunk) => {
   }
 });
 
+const toolIds = new Map(); // tool_use id -> tool name, so a later tool_result can name its tool
+function toolResultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.map((b) => (b && typeof b.text === "string" ? b.text : "")).join("\n");
+  return "";
+}
+
 function renderEvent(ev) {
   if (ev.type === "assistant" && ev.message) {
     if (!model && typeof ev.message.model === "string") model = ev.message.model;
@@ -135,7 +142,17 @@ function renderEvent(ev) {
       if (part.type === "text" && part.text && part.text.trim()) {
         render.text(part.text.trim());
       } else if (part.type === "tool_use") {
-        render.action(`${part.name}${shortInput(part.name, part.input)}`);
+        if (part.id) toolIds.set(part.id, part.name);
+        render.action(toolLabel(part.name, pickInput(part.input)), part.id);
+      }
+    }
+  } else if (ev.type === "user" && ev.message) {
+    // claude runs the tools itself (headless -p) and echoes each result back as a tool_result block;
+    // summarize it into the `⎿` tree line for the tool it belongs to.
+    for (const part of ev.message.content || []) {
+      if (part && part.type === "tool_result") {
+        const name = toolIds.get(part.tool_use_id) || "";
+        render.result(summarizeToolResult(name, toolResultText(part.content), part.is_error), part.is_error, part.tool_use_id);
       }
     }
   } else if (ev.type === "system" && ev.subtype === "post_turn_summary" && ev.status_detail) {

package/scripts/agents/codex-agent.js

@@ -42,7 +42,7 @@ try {
 }
 
 const prompt = buildPrompt(inputPath);
-const render = createRenderer({ env: process.env, stderr: process.stderr });
+const render = createRenderer({ env: process.env, stderr: process.stderr, label: "codex" });
 const transcriptPath = path.join(path.dirname(resultPath), "transcript.md");
 const state = { provider: "codex", buffer: "", model: undefined, usage: undefined, renderer: render };
 const capturedStdout = [];