cool-workflow 0.1.89 → 0.1.91

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

@@ -51,6 +51,129 @@ function trace(line, env = process.env, stderr = process.stderr) {
   stderr.write(`${line}\n`);
 }
 
+// ---- live renderer (zero-dep, hand-rolled — kept self-contained so this wrapper stays a
+//      copyable "config", not a build-coupled dependency) -----------------------------------
+
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+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;
+
+function colorOn(env, stderr) {
+  if ((env.NO_COLOR ?? "") !== "" || (env.CW_NO_COLOR ?? "") !== "") return false;
+  if (env.FORCE_COLOR !== undefined && env.FORCE_COLOR !== "" && env.FORCE_COLOR !== "0") return true;
+  return Boolean(stderr.isTTY);
+}
+// Behaviorally IDENTICAL to src/term.ts truncate() — the two copies exist only because the wrapper
+// is a self-contained plain-JS "config" (no import of the TS build). cli-render-smoke cross-checks
+// them on shared cases so this invariant cannot silently drift: maxWidth<=0 → ""; a string that fits
+// returns the ORIGINAL text (ANSI intact); otherwise stripped + sliced + "…".
+function truncate(text, max) {
+  if (max <= 0) return "";
+  const chars = [...String(text).replace(ANSI_RE, "")];
+  if (chars.length <= max) return String(text);
+  return max <= 1 ? "…" : `${chars.slice(0, max - 1).join("")}…`;
+}
+function fmtElapsed(ms) {
+  const s = ms / 1000;
+  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
+ *  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 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);
+
+  const transcript = [];
+  let live = "";        // current rendered live line (no trailing newline) when interactive
+  let timer = null;
+  let frame = 0;
+  let cursorHidden = false;
+  let current = null;   // { label, startedAt, failed }
+
+  const restoreCursor = () => {
+    if (cursorHidden) { try { stderr.write(ANSI.showCursor); } catch { /* noop */ } cursorHidden = false; }
+  };
+  // Cursor hygiene: ALWAYS restore on exit / Ctrl-C / kill, even on crash.
+  const onSignal = (sig) => { stop(); process.exit(sig === "SIGINT" ? 130 : 143); };
+  if (interactive) {
+    process.once("exit", restoreCursor);
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+  }
+
+  const renderLive = () => {
+    if (!interactive || !current) 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}`);
+  };
+  const clearLive = () => { if (interactive && live) { stderr.write(ANSI.clearLine); live = ""; } };
+  const ensureTimer = () => {
+    if (interactive && !timer) timer = setInterval(() => { frame++; renderLive(); }, 90);
+  };
+
+  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`);
+    current = null;
+  };
+
+  return {
+    /** Begin a new active action (commits + folds the previous one). */
+    action(label) {
+      commit();
+      current = { label: String(label || "working…"), startedAt: Date.now(), failed: false };
+      ensureTimer();
+      if (interactive) renderLive();
+      else if (plain) stderr.write(`→ ${current.label}\n`);
+    },
+    /** Mark the current action as failed (it commits as ✗). */
+    fail() { if (current) current.failed = true; },
+    /** Narration text from the model. Always to the transcript; inline only in --verbose. */
+    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`);
+    },
+    /** A short status note (e.g. provider summary). Transcript always; inline in --verbose. */
+    note(text) { this.text(text); },
+    /** Stop the spinner + restore the terminal. Idempotent. */
+    finishLive() { stop(); },
+    /** Persist the full transcript (narration + tool I/O) regardless of verbosity. */
+    writeTranscript(filePath) {
+      try { fs.writeFileSync(filePath, `# Agent transcript\n\n${transcript.join("\n")}\n`, "utf8"); } catch { /* advisory */ }
+    },
+    isVerbose: () => verbose
+  };
+
+  function stop() {
+    if (timer) { clearInterval(timer); timer = null; }
+    commit();
+    clearLive();
+    restoreCursor();
+  }
+}
+
 function shortText(value, max = 100) {
   const text = String(value || "").replace(/\s+/g, " ").trim();
   if (!text) return "";
@@ -109,20 +232,29 @@ function renderJsonEvent(provider, ev, state) {
   const usage = usageFromEvent(ev);
   if (usage) state.usage = usage;
 
+  const r = state.renderer;
   const type = String(ev.type || ev.event || ev.kind || "");
+  if (ev.is_error === true && r) r.fail();
+
   const toolName = toolNameFromEvent(ev);
   if (toolName || /tool|command/i.test(type)) {
     const arg = shortText(toolArgFromEvent(ev), 80);
-    trace(`  -> ${toolName || type}${arg ? ` ${arg}` : ""}`);
+    const label = `${toolName || type}${arg ? ` ${arg}` : ""}`;
+    if (r) r.action(label);
+    else trace(`  -> ${label}`);
     return;
   }
 
   const text = textFromEvent(ev);
   if (text && /assistant|message|delta|text|response|output/i.test(type || "text")) {
-    trace(`  ${shortText(text, 240)}`);
+    if (r) r.text(text);
+    else trace(`  ${shortText(text, 240)}`);
   } else if (/turn|step|summary|status/i.test(type)) {
     const status = firstString(ev.status, ev.status_detail, ev.summary, ev.message);
-    if (status) trace(`  . ${provider}: ${shortText(status, 160)}`);
+    if (status) {
+      if (r) r.note(`${provider}: ${status}`);
+      else trace(`  . ${provider}: ${shortText(status, 160)}`);
+    }
   }
 }
 
@@ -173,6 +305,8 @@ module.exports = {
   streamEnabled,
   traceEnabled,
   trace,
+  createRenderer,
+  truncate, // exported only so cli-render-smoke can assert it stays identical to term.ts truncate()
   parseJsonLines,
   flushJsonLines,
   writeResult,

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

@@ -28,12 +28,13 @@
 //   CW_AGENT_COMMAND="node $(pwd)/scripts/agents/claude-p-agent.js {{input}} {{result}}"
 
 const fs = require("node:fs");
+const path = require("node:path");
 const { spawn, spawnSync } = require("node:child_process");
 // Share the ONE canonical result contract with the codex/gemini/opencode
 // 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 } = require("./agent-adapter-core");
+const { buildPrompt, createRenderer } = require("./agent-adapter-core");
 
 const inputPath = process.argv[2];
 const resultPath = process.argv[3];
@@ -77,11 +78,6 @@ if (!streamEnabled) {
   process.exit(0);
 }
 
-// Live trace → stderr only. Concise; one line per meaningful event.
-function trace(line) {
-  if (!traceEnabled) return;
-  process.stderr.write(`${line}\n`);
-}
 function shortInput(tool, input) {
   if (!input || typeof input !== "object") return "";
   const v = input.file_path || input.path || input.pattern || input.command || input.query || input.url || "";
@@ -89,20 +85,30 @@ function shortInput(tool, input) {
   return s ? ` ${s.length > 80 ? s.slice(0, 77) + "…" : s}` : "";
 }
 
-// stream-json so claude emits incremental NDJSON events we can render live, while
-// we reconstruct the single {model, usage, result} object CW consumes on stdout.
+// 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 transcriptPath = path.join(path.dirname(resultPath), "transcript.md");
+
+// stream-json so claude emits incremental NDJSON events we render live. We CAPTURE claude's
+// own stderr (do NOT inherit) so it can never corrupt the live region; it's surfaced only on a
+// non-zero exit.
 const child = spawn(
   "claude",
   ["-p", prompt, "--output-format", "stream-json", "--verbose", "--allowedTools", "Read,Grep,Glob,Bash"],
-  { stdio: ["ignore", "pipe", "inherit"] } // claude's own stderr → straight through
+  { stdio: ["ignore", "pipe", "pipe"] }
 );
 
 let model;
 let usage;
 let resultText;
 let buf = "";
+let childStderr = "";
+child.stderr.setEncoding("utf8");
+child.stderr.on("data", (d) => { if (childStderr.length < 1024 * 1024) childStderr += d; });
 
-trace("● claude: reading the repo (read-only)…");
+render.action("claude: reading the repo (read-only)…");
 
 child.stdout.setEncoding("utf8");
 child.stdout.on("data", (chunk) => {
@@ -127,27 +133,31 @@ function renderEvent(ev) {
     if (!model && typeof ev.message.model === "string") model = ev.message.model;
     for (const part of ev.message.content || []) {
       if (part.type === "text" && part.text && part.text.trim()) {
-        trace(`  ${part.text.trim().replace(/\n+/g, "\n  ")}`);
+        render.text(part.text.trim());
       } else if (part.type === "tool_use") {
-        trace(`  → ${part.name}${shortInput(part.name, part.input)}`);
+        render.action(`${part.name}${shortInput(part.name, part.input)}`);
       }
     }
   } else if (ev.type === "system" && ev.subtype === "post_turn_summary" && ev.status_detail) {
-    trace(`  · ${ev.status_detail}`);
+    render.note(ev.status_detail);
   } else if (ev.type === "result") {
     if (typeof ev.result === "string") resultText = ev.result;
     if (ev.usage && typeof ev.usage === "object") usage = ev.usage;
-    if (ev.is_error) trace("  ✗ claude reported an error result");
+    if (ev.is_error) render.fail();
   }
 }
 
 child.on("error", (err) => {
+  render.finishLive(); // restore the terminal before exiting
   process.stderr.write(`claude spawn failed: ${err.message}\n`);
   process.exit(1);
 });
 
 child.on("close", (code) => {
+  render.finishLive(); // stop the spinner + restore the cursor BEFORE any further output
+  render.writeTranscript(transcriptPath); // full narration + tool I/O always saved
   if (code !== 0) {
+    if (childStderr.trim()) process.stderr.write(`${childStderr.trim()}\n`);
     process.stderr.write(`claude exited ${code === null ? "(timeout/killed)" : code}\n`);
     process.exit(code === null ? 1 : code);
   }
@@ -158,7 +168,6 @@ child.on("close", (code) => {
   }
   // Persist the AGENT's final markdown to the worker's result.md (CW is transport).
   fs.writeFileSync(resultPath, resultText, "utf8");
-  trace("● done — result captured");
   // The single JSON CW consumes on STDOUT (data channel): model + usage + result.
   process.stdout.write(JSON.stringify({ model, usage, result: resultText }));
 });

package/scripts/agents/codex-agent.js

@@ -20,10 +20,10 @@ const path = require("node:path");
 const { spawn } = require("node:child_process");
 const {
   buildPrompt,
+  createRenderer,
   emitReport,
   flushJsonLines,
   parseJsonLines,
-  trace,
   writeResult
 } = require("./agent-adapter-core");
 
@@ -42,7 +42,9 @@ try {
 }
 
 const prompt = buildPrompt(inputPath);
-const state = { provider: "codex", buffer: "", model: undefined, usage: undefined };
+const render = createRenderer({ env: process.env, stderr: process.stderr });
+const transcriptPath = path.join(path.dirname(resultPath), "transcript.md");
+const state = { provider: "codex", buffer: "", model: undefined, usage: undefined, renderer: render };
 const capturedStdout = [];
 let childStderr = "";
 function recordJsonLine(line) {
@@ -54,7 +56,7 @@ function recordJsonLine(line) {
   }
 }
 
-trace("* codex: reading the repo (read-only)...");
+render.action("codex: reading the repo (read-only)…");
 
 const args = [
   "exec",
@@ -83,21 +85,23 @@ child.stdout.on("data", (chunk) => {
   parseJsonLines("codex", chunk, state, recordJsonLine);
 });
 
+// Capture codex's own stderr (do NOT inherit) so it can never corrupt the live region; it's
+// surfaced only on a non-zero exit.
 child.stderr.setEncoding("utf8");
 child.stderr.on("data", (chunk) => {
-  childStderr += chunk;
-  if (process.env.CW_AGENT_STREAM !== "0" && process.env.CW_NO_STREAM !== "1" && process.stderr.isTTY) {
-    process.stderr.write(chunk);
-  }
+  if (childStderr.length < 1024 * 1024) childStderr += chunk;
 });
 
 child.on("error", (error) => {
+  render.finishLive();
   process.stderr.write(`codex spawn failed: ${error.message}\n`);
   process.exit(1);
 });
 
 child.on("close", (code) => {
   flushJsonLines("codex", state, recordJsonLine);
+  render.finishLive();
+  render.writeTranscript(transcriptPath);
   if (code !== 0) {
     const detail = childStderr.trim() || `codex exited ${code === null ? "(timeout/killed)" : code}`;
     process.stderr.write(`${detail}\n`);
@@ -129,6 +133,5 @@ child.on("close", (code) => {
     process.exit(1);
   }
 
-  trace("* done - result captured");
   emitReport(state.model, state.usage, resultText);
 });

package/scripts/agents/gemini-agent.js

@@ -14,13 +14,14 @@
 // stdout: one JSON object { model, usage, result } for CW provenance.
 // stderr: optional live trace when CW_AGENT_STREAM=1 and attached to a TTY.
 
+const path = require("node:path");
 const { spawn } = require("node:child_process");
 const {
   buildPrompt,
+  createRenderer,
   emitReport,
   flushJsonLines,
   parseJsonLines,
-  trace,
   writeResult
 } = require("./agent-adapter-core");
 
@@ -32,7 +33,9 @@ if (!inputPath || !resultPath) {
 }
 
 const prompt = buildPrompt(inputPath);
-const state = { provider: "gemini", buffer: "", model: undefined, usage: undefined, textFragments: [], finalResult: undefined };
+const render = createRenderer({ env: process.env, stderr: process.stderr });
+const transcriptPath = path.join(path.dirname(resultPath), "transcript.md");
+const state = { provider: "gemini", buffer: "", model: undefined, usage: undefined, textFragments: [], finalResult: undefined, renderer: render };
 let childStderr = "";
 function recordJsonLine(line) {
   let ev;
@@ -51,7 +54,7 @@ function recordJsonLine(line) {
   }
 }
 
-trace("* gemini: reading the repo (read-only)...");
+render.action("gemini: reading the repo (read-only)…");
 
 const args = [
   "-p",
@@ -72,21 +75,22 @@ child.stdout.on("data", (chunk) => {
   parseJsonLines("gemini", chunk, state, recordJsonLine);
 });
 
+// Capture gemini's own stderr (do NOT inherit) so it can never corrupt the live region.
 child.stderr.setEncoding("utf8");
 child.stderr.on("data", (chunk) => {
-  childStderr += chunk;
-  if (process.env.CW_AGENT_STREAM !== "0" && process.env.CW_NO_STREAM !== "1" && process.stderr.isTTY) {
-    process.stderr.write(chunk);
-  }
+  if (childStderr.length < 1024 * 1024) childStderr += chunk;
 });
 
 child.on("error", (error) => {
+  render.finishLive();
   process.stderr.write(`gemini spawn failed: ${error.message}\n`);
   process.exit(1);
 });
 
 child.on("close", (code) => {
   flushJsonLines("gemini", state, recordJsonLine);
+  render.finishLive();
+  render.writeTranscript(transcriptPath);
   if (code !== 0) {
     const detail = childStderr.trim() || `gemini exited ${code === null ? "(timeout/killed)" : code}`;
     process.stderr.write(`${detail}\n`);
@@ -110,6 +114,5 @@ child.on("close", (code) => {
     process.exit(1);
   }
 
-  trace("* done - result captured");
   emitReport(state.model, state.usage, resultText);
 });

package/scripts/agents/opencode-agent.js

@@ -19,13 +19,14 @@
 // via execution-backend boundary controls. If OpenCode adds a cleaner read-only
 // flag, prefer that here.
 
+const path = require("node:path");
 const { spawn } = require("node:child_process");
 const {
   buildPrompt,
+  createRenderer,
   emitReport,
   flushJsonLines,
   parseJsonLines,
-  trace,
   writeResult
 } = require("./agent-adapter-core");
 
@@ -37,7 +38,9 @@ if (!inputPath || !resultPath) {
 }
 
 const prompt = buildPrompt(inputPath);
-const state = { provider: "opencode", buffer: "", model: undefined, usage: undefined, textFragments: [], finalResult: undefined };
+const render = createRenderer({ env: process.env, stderr: process.stderr });
+const transcriptPath = path.join(path.dirname(resultPath), "transcript.md");
+const state = { provider: "opencode", buffer: "", model: undefined, usage: undefined, textFragments: [], finalResult: undefined, renderer: render };
 let childStderr = "";
 function recordJsonLine(line) {
   let ev;
@@ -55,7 +58,7 @@ function recordJsonLine(line) {
   }
 }
 
-trace("* opencode: reading the repo...");
+render.action("opencode: reading the repo…");
 
 const args = [
   "run",
@@ -76,21 +79,22 @@ child.stdout.on("data", (chunk) => {
   parseJsonLines("opencode", chunk, state, recordJsonLine);
 });
 
+// Capture opencode's own stderr (do NOT inherit) so it can never corrupt the live region.
 child.stderr.setEncoding("utf8");
 child.stderr.on("data", (chunk) => {
-  childStderr += chunk;
-  if (process.env.CW_AGENT_STREAM !== "0" && process.env.CW_NO_STREAM !== "1" && process.stderr.isTTY) {
-    process.stderr.write(chunk);
-  }
+  if (childStderr.length < 1024 * 1024) childStderr += chunk;
 });
 
 child.on("error", (error) => {
+  render.finishLive();
   process.stderr.write(`opencode spawn failed: ${error.message}\n`);
   process.exit(1);
 });
 
 child.on("close", (code) => {
   flushJsonLines("opencode", state, recordJsonLine);
+  render.finishLive();
+  render.writeTranscript(transcriptPath);
   if (code !== 0) {
     const detail = childStderr.trim() || `opencode exited ${code === null ? "(timeout/killed)" : code}`;
     process.stderr.write(`${detail}\n`);
@@ -114,6 +118,5 @@ child.on("close", (code) => {
     process.exit(1);
   }
 
-  trace("* done - result captured");
   emitReport(state.model, state.usage, resultText);
 });

package/scripts/canonical-apps.js

@@ -83,7 +83,7 @@ const canonicalApps = [
       "--source",
       "plugins/cool-workflow/docs/workflow-app-framework.7.md",
       "--scope",
-      "Cool Workflow v0.1.89",
+      "Cool Workflow v0.1.91",
       "--freshness",
       "as of release preparation"
     ]
@@ -117,14 +117,14 @@ function main() {
     assert.ok(summary, `${app.id} must appear in app list`);
     assert.equal(summary.sourceKind, "app-directory");
     assert.equal(summary.legacy, false);
-    assert.equal(summary.version, "0.1.89");
+    assert.equal(summary.version, "0.1.91");
 
     const validation = runJson(["app", "validate", manifestPath]);
     assert.equal(validation.valid, true, `${app.id} manifest must validate`);
 
     const shown = runJson(["app", "show", app.id]);
     assert.equal(shown.app.id, app.id);
-    assert.equal(shown.app.version, "0.1.89");
+    assert.equal(shown.app.version, "0.1.91");
     assert.ok(shown.app.metadata.canonical, `${app.id} must be marked canonical`);
     assert.ok(shown.app.sandboxProfiles.length > 0, `${app.id} must declare sandbox profiles`);
     assertTaskIdsUnique(shown);
@@ -135,7 +135,7 @@ function main() {
     const plan = runJson(["plan", app.id, ...app.args(workspace)]);
     const state = JSON.parse(fs.readFileSync(plan.statePath, "utf8"));
     assert.equal(state.workflow.app.id, app.id);
-    assert.equal(state.workflow.app.version, "0.1.89");
+    assert.equal(state.workflow.app.version, "0.1.91");
     assert.equal(state.workflow.app.metadata.canonical, true);
     assert.ok(state.tasks.some((task) => task.requiresEvidence), `${app.id} plan must include evidence gates`);
     assert.ok(state.tasks.every((task) => task.sandboxProfileId), `${app.id} plan must include sandbox hints`);

package/scripts/dogfood-release.js

@@ -6,7 +6,7 @@ const fs = require("node:fs");
 const path = require("node:path");
 const { CoolWorkflowRunner } = require("../dist/orchestrator.js");
 
-const TARGET_VERSION = "0.1.89";
+const TARGET_VERSION = "0.1.91";
 const PREVIOUS_VERSION = "0.1.31";
 const pluginRoot = path.resolve(__dirname, "..");
 const repoRoot = path.resolve(pluginRoot, "..", "..");

package/scripts/golden-path.js

@@ -33,7 +33,7 @@ function main() {
     const appValidation = runJson(["app", "validate", "end-to-end-golden-path"], pluginRoot);
     assert.equal(appValidation.valid, true);
     assert.equal(appValidation.summary.id, "end-to-end-golden-path");
-    assert.equal(appValidation.summary.version, "0.1.89");
+    assert.equal(appValidation.summary.version, "0.1.91");
 
     const plan = runJson(
       [
@@ -42,7 +42,7 @@ function main() {
         "--repo",
         tmp,
         "--question",
-        "Prove the deterministic v0.1.89 end-to-end golden path."
+        "Prove the deterministic v0.1.91 end-to-end golden path."
       ],
       pluginRoot
     );
@@ -52,7 +52,7 @@ function main() {
 
     let state = readJson(plan.statePath);
     assert.equal(state.workflow.app.id, "end-to-end-golden-path");
-    assert.equal(state.workflow.app.version, "0.1.89");
+    assert.equal(state.workflow.app.version, "0.1.91");
     assert.equal(state.loopStage, "interpret");
 
     const dispatch = runJson(["dispatch", plan.runId, "--limit", "1", "--sandbox", "readonly"], tmp);
@@ -195,7 +195,7 @@ function main() {
     assert.equal(reportPath, plan.reportPath);
     assert.ok(fs.existsSync(reportPath));
     const report = fs.readFileSync(reportPath, "utf8");
-    assert.match(report, /Workflow App: end-to-end-golden-path@0\.1\.89/);
+    assert.match(report, /Workflow App: end-to-end-golden-path@0\.1\.91/);
     assert.match(report, /## Candidates/);
     assert.match(report, /## Trust Audit/);
     assert.match(report, /## Acceptance Rationale/);