@staff0rd/assist 0.220.1 → 0.221.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.220.1",
+  version: "0.221.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -3704,19 +3704,19 @@ function moveCaseInsensitive(absSource, absDest) {
   fs8.renameSync(absSource, tmp);
   fs8.renameSync(tmp, absDest);
 }
-function applyMoves(project, moves, cwd, emit) {
+function applyMoves(project, moves, cwd, emit2) {
   for (const { sourcePath, destPath } of moves) {
     const start3 = performance.now();
     const absSource = path16.resolve(sourcePath);
     const absDest = path16.resolve(destPath);
     for (const r of renameExports(project, absSource, absDest)) {
-      emit(`  Renamed export ${r} in ${sourcePath}`);
+      emit2(`  Renamed export ${r} in ${sourcePath}`);
     }
     const sourceFile = project.getSourceFile(absSource);
     if (sourceFile) sourceFile.move(absDest);
     const ms = (performance.now() - start3).toFixed(0);
     const rel = `${path16.relative(cwd, absSource)} \u2192 ${path16.relative(cwd, absDest)}`;
-    emit(`  Renamed ${rel} (${ms}ms)`);
+    emit2(`  Renamed ${rel} (${ms}ms)`);
   }
   project.saveSync();
   for (const { sourcePath, destPath } of moves) {
@@ -4070,10 +4070,10 @@ function printTaskStatuses(tasks) {
 }
 
 // src/commands/verify/run/createTimerCallback/index.ts
-function logFailedScripts(failed) {
+function logFailedScripts(failed2) {
   console.error(`
-${failed.length} script(s) failed:`);
-  for (const f of failed) {
+${failed2.length} script(s) failed:`);
+  for (const f of failed2) {
     console.error(`  - ${f.script} (exit code ${f.code})`);
   }
 }
@@ -4150,9 +4150,9 @@ function runEntry(entry, onComplete) {
     });
   });
 }
-function exitIfFailed(failed) {
-  if (failed.length === 0) return;
-  logFailedScripts(failed);
+function exitIfFailed(failed2) {
+  if (failed2.length === 0) return;
+  logFailedScripts(failed2);
   process.exit(1);
 }
 function runAllEntries(entries, timer) {
@@ -8392,6 +8392,303 @@ function registerDotnet(program2) {
   cmd.command("in-sln").description("Check whether a .csproj is referenced by any .sln file").argument("<csproj>", "Path to a .csproj file").action(inSln);
 }
 
+// src/commands/handover/archive.ts
+import { existsSync as existsSync30, mkdirSync as mkdirSync7, renameSync as renameSync2 } from "fs";
+import { join as join31 } from "path";
+
+// src/commands/handover/formatArchiveTimestamp.ts
+function formatArchiveTimestamp(date = /* @__PURE__ */ new Date()) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  const yyyy = date.getUTCFullYear().toString();
+  const mm = pad(date.getUTCMonth() + 1);
+  const dd = pad(date.getUTCDate());
+  const hh = pad(date.getUTCHours());
+  const mi = pad(date.getUTCMinutes());
+  const ss = pad(date.getUTCSeconds());
+  return `${yyyy}-${mm}-${dd}T${hh}${mi}${ss}Z`;
+}
+
+// src/commands/handover/getHandoverArchiveDir.ts
+import { join as join29 } from "path";
+function getHandoverArchiveDir(cwd = process.cwd()) {
+  return join29(cwd, ".assist", "handovers", "archive");
+}
+
+// src/commands/handover/getHandoverPath.ts
+import { join as join30 } from "path";
+function getHandoverPath(cwd = process.cwd()) {
+  return join30(cwd, ".assist", "HANDOVER.md");
+}
+
+// src/commands/handover/archive.ts
+var MAX_COLLISION_SUFFIX = 99;
+function buildArchiveFilename(timestamp, suffix) {
+  const base = suffix ? `${timestamp}-${suffix}` : timestamp;
+  return `${base}.md`;
+}
+function resolveCollisionPath(archiveDir, timestamp, suffix) {
+  const initial = join31(archiveDir, buildArchiveFilename(timestamp, suffix));
+  if (!existsSync30(initial)) return initial;
+  for (let i = 1; i <= MAX_COLLISION_SUFFIX; i++) {
+    const collisionSuffix = suffix ? `${suffix}-${i}` : `${i}`;
+    const candidate = join31(
+      archiveDir,
+      buildArchiveFilename(timestamp, collisionSuffix)
+    );
+    if (!existsSync30(candidate)) return candidate;
+  }
+  throw new Error(
+    `Exhausted collision suffixes (1-${MAX_COLLISION_SUFFIX}) for ${timestamp}`
+  );
+}
+function archive(options2 = {}) {
+  const cwd = options2.cwd ?? process.cwd();
+  const handoverPath = getHandoverPath(cwd);
+  if (!existsSync30(handoverPath)) return void 0;
+  const archiveDir = getHandoverArchiveDir(cwd);
+  mkdirSync7(archiveDir, { recursive: true });
+  const timestamp = formatArchiveTimestamp(options2.now);
+  const destination = resolveCollisionPath(
+    archiveDir,
+    timestamp,
+    options2.suffix
+  );
+  renameSync2(handoverPath, destination);
+  return destination;
+}
+
+// src/commands/handover/load.ts
+import { existsSync as existsSync31, readFileSync as readFileSync27 } from "fs";
+
+// src/commands/handover/parseLoadInput.ts
+async function parseLoadInput(stdin) {
+  try {
+    const raw = await stdin();
+    if (!raw.trim()) return {};
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+// src/commands/handover/findRecentSessionJsonl.ts
+import { readdirSync as readdirSync5, statSync as statSync4 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join32 } from "path";
+
+// src/commands/handover/encodeCwdForProjects.ts
+function encodeCwdForProjects(cwd) {
+  return cwd.replace(/[\\/.]/g, "-");
+}
+
+// src/commands/sessions/summarise/iterateUserEntries.ts
+import * as fs17 from "fs";
+
+// src/commands/sessions/summarise/parseUserLine.ts
+function parseUserLine(line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  if (entry.type !== "user") return void 0;
+  const msg = entry.message;
+  const c = msg?.content;
+  let text;
+  if (typeof c === "string") {
+    text = c;
+  } else if (Array.isArray(c)) {
+    const collected = c.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
+    text = collected || void 0;
+  }
+  if (!text) return void 0;
+  return {
+    text,
+    entrypoint: typeof entry.entrypoint === "string" ? entry.entrypoint : void 0
+  };
+}
+
+// src/commands/sessions/summarise/iterateUserEntries.ts
+function* iterateUserEntries(filePath) {
+  let content;
+  try {
+    content = fs17.readFileSync(filePath, "utf8");
+  } catch {
+    return;
+  }
+  for (const line of content.split("\n")) {
+    if (!line) continue;
+    const entry = parseUserLine(line);
+    if (entry) yield entry;
+  }
+}
+
+// src/commands/handover/isSdkCliOnly.ts
+function isSdkCliOnly(jsonlPath) {
+  for (const entry of iterateUserEntries(jsonlPath)) {
+    if (entry.entrypoint !== "sdk-cli") return false;
+  }
+  return true;
+}
+
+// src/commands/handover/findRecentSessionJsonl.ts
+function getProjectDir(cwd) {
+  return join32(homedir8(), ".claude", "projects", encodeCwdForProjects(cwd));
+}
+function findRecentSessionJsonl(cwd, options2 = {}) {
+  const projectDir = options2.projectDir ?? getProjectDir(cwd);
+  let entries;
+  try {
+    entries = readdirSync5(projectDir);
+  } catch {
+    return void 0;
+  }
+  const jsonls = entries.filter((f) => f.endsWith(".jsonl")).map((name) => {
+    const path52 = join32(projectDir, name);
+    let mtime = 0;
+    try {
+      mtime = statSync4(path52).mtimeMs;
+    } catch {
+      return void 0;
+    }
+    return { path: path52, name, mtime };
+  }).filter((x) => !!x).sort((a, b) => b.mtime - a.mtime);
+  for (const { path: path52, name } of jsonls) {
+    const sessionId = name.replace(/\.jsonl$/, "");
+    if (options2.excludeSessionId && sessionId === options2.excludeSessionId)
+      continue;
+    if (isSdkCliOnly(path52)) continue;
+    return path52;
+  }
+  return void 0;
+}
+
+// src/commands/handover/summarise.ts
+import { execFileSync as execFileSync4 } from "child_process";
+var SUMMARISE_RECURSION_GUARD = "_CLAUDE_HOOK_SUMMARISE_RUNNING";
+var MAX_TURNS = 15;
+var MAX_PAYLOAD_BYTES = 8 * 1024;
+var PROMPT_TEMPLATE = [
+  "Summarise what the user has been working on in this Claude Code session in ONE short sentence (under 100 chars).",
+  "Return ONLY the summary, no quotes, prefix, or explanation.",
+  "",
+  "Last user turns (most recent last):"
+].join("\n");
+function summarise(jsonlPath) {
+  const entries = [...iterateUserEntries(jsonlPath)];
+  const humanEntries = entries.filter((e) => e.entrypoint !== "sdk-cli");
+  if (humanEntries.length === 0) return "";
+  const turns = humanEntries.map((e) => stripPreludes(e.text)).filter((t) => t.length > 0).slice(-MAX_TURNS);
+  if (turns.length === 0) return "";
+  const payload = capPayload(turns.join("\n---\n"), MAX_PAYLOAD_BYTES);
+  const prompt = `${PROMPT_TEMPLATE}
+${payload}`;
+  try {
+    const output = execFileSync4("claude", ["-p", "--model", "haiku", prompt], {
+      encoding: "utf8",
+      timeout: 3e4,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: { ...process.env, [SUMMARISE_RECURSION_GUARD]: "1" }
+    });
+    return normaliseOutput(output);
+  } catch {
+    return "";
+  }
+}
+function stripPreludes(text) {
+  return text.replace(/<command-name>[\s\S]*?<\/command-name>/g, "").replace(/<command-message>[\s\S]*?<\/command-message>/g, "").replace(/<command-args>[\s\S]*?<\/command-args>/g, "").replace(/<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g, "").replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
+}
+function capPayload(text, maxBytes) {
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes) return text;
+  return buf.subarray(buf.length - maxBytes).toString("utf8");
+}
+function normaliseOutput(raw) {
+  const firstLine = raw.trim().split("\n")[0] ?? "";
+  return firstLine.replace(/^["']|["']$/g, "").trim();
+}
+
+// src/commands/handover/resolveLoadOptions.ts
+function resolveLoadOptions(options2) {
+  return {
+    stdin: options2.stdin ?? readStdin,
+    env: options2.env ?? process.env,
+    cwdFallback: options2.cwdFallback ?? process.cwd(),
+    summariseFn: options2.summariseFn ?? summarise,
+    findRecentFn: options2.findRecentFn ?? ((cwd, sid) => findRecentSessionJsonl(cwd, { excludeSessionId: sid }))
+  };
+}
+
+// src/commands/handover/load.ts
+function loadFromHandover(cwd) {
+  const handoverPath = getHandoverPath(cwd);
+  if (!existsSync31(handoverPath)) return void 0;
+  const content = readFileSync27(handoverPath, "utf-8");
+  archive({ cwd });
+  return {
+    additionalContext: content,
+    systemMessage: "Loaded handover from previous session"
+  };
+}
+function loadFromPriorTranscript(cwd, sessionId, findRecent, summariseJsonl) {
+  const jsonlPath = findRecent(cwd, sessionId);
+  if (!jsonlPath) return void 0;
+  const summary = summariseJsonl(jsonlPath);
+  if (!summary) return void 0;
+  const message = `Previous session: ${summary}`;
+  return { additionalContext: message, systemMessage: message };
+}
+function emit(context) {
+  const json = JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: context.additionalContext
+    },
+    systemMessage: context.systemMessage
+  });
+  console.log(json);
+  return json;
+}
+async function load(options2 = {}) {
+  const opts = resolveLoadOptions(options2);
+  if (opts.env[SUMMARISE_RECURSION_GUARD]) return null;
+  const input = await parseLoadInput(opts.stdin);
+  const cwd = input.cwd ?? opts.cwdFallback;
+  const context = loadFromHandover(cwd) ?? loadFromPriorTranscript(
+    cwd,
+    input.session_id,
+    opts.findRecentFn,
+    opts.summariseFn
+  );
+  return context ? emit(context) : null;
+}
+
+// src/commands/registerHandover.ts
+function registerHandover(program2) {
+  const cmd = program2.command("handover").description("Session handover utilities");
+  cmd.command("archive").description(
+    "Archive the current .assist/HANDOVER.md to .assist/handovers/archive/"
+  ).option(
+    "--suffix <suffix>",
+    "Optional suffix appended to the archive filename"
+  ).action((options2) => {
+    const dest = archive({ suffix: options2.suffix });
+    if (dest) console.log(dest);
+  });
+  cmd.command("summarise").description(
+    "Print a one-line summary of a session JSONL via claude -p --model haiku"
+  ).argument("<jsonl>", "Path to a session JSONL file").action((jsonl) => {
+    const line = summarise(jsonl);
+    if (line) console.log(line);
+  });
+  cmd.command("load").description(
+    "SessionStart hook: archive prior handover and emit additionalContext (or fall back to prior-session summary)"
+  ).action(async () => {
+    await load();
+  });
+}
+
 // src/commands/jira/acceptanceCriteria.ts
 import chalk97 from "chalk";
 
@@ -8401,52 +8698,52 @@ function renderInline(node) {
   if (node.marks?.some((m) => m.type === "code")) return `\`${text}\``;
   return text;
 }
-function renderChildren(node, indent) {
-  return renderNodes(node.content ?? [], indent);
+function renderChildren(node, indent2) {
+  return renderNodes(node.content ?? [], indent2);
 }
-function renderOrderedList(node, indent) {
+function renderOrderedList(node, indent2) {
   let counter = 0;
   return (node.content ?? []).map((item) => {
     counter++;
-    return renderListItem(item, indent, `${counter}.`);
+    return renderListItem(item, indent2, `${counter}.`);
   }).join("\n");
 }
-function renderBulletList(node, indent) {
-  return (node.content ?? []).map((item) => renderListItem(item, indent, "-")).join("\n");
+function renderBulletList(node, indent2) {
+  return (node.content ?? []).map((item) => renderListItem(item, indent2, "-")).join("\n");
 }
-function renderHeading(node, indent) {
+function renderHeading(node, indent2) {
   const level = node.attrs?.level ?? 1;
-  return `${"#".repeat(level)} ${renderChildren(node, indent)}`;
+  return `${"#".repeat(level)} ${renderChildren(node, indent2)}`;
 }
 var renderers = {
   text: (node) => renderInline(node),
   paragraph: renderChildren,
   orderedList: renderOrderedList,
   bulletList: renderBulletList,
-  listItem: (node, indent) => renderListItem(node, indent, "-"),
+  listItem: (node, indent2) => renderListItem(node, indent2, "-"),
   heading: renderHeading,
   doc: renderChildren
 };
-function renderNode(node, indent) {
+function renderNode(node, indent2) {
   const renderer = renderers[node.type];
-  if (renderer) return renderer(node, indent);
-  return node.content ? renderChildren(node, indent) : "";
+  if (renderer) return renderer(node, indent2);
+  return node.content ? renderChildren(node, indent2) : "";
 }
-function renderNodes(nodes, indent) {
-  return nodes.map((node) => renderNode(node, indent)).join("");
+function renderNodes(nodes, indent2) {
+  return nodes.map((node) => renderNode(node, indent2)).join("");
 }
 function isListNode(node) {
   return node.type === "orderedList" || node.type === "bulletList";
 }
-function renderListChild(child, indent, pad, marker, isFirst) {
-  if (isListNode(child)) return renderNodes([child], indent + 1);
-  if (child.type !== "paragraph") return renderNode(child, indent);
-  const text = renderChildren(child, indent);
+function renderListChild(child, indent2, pad, marker, isFirst) {
+  if (isListNode(child)) return renderNodes([child], indent2 + 1);
+  if (child.type !== "paragraph") return renderNode(child, indent2);
+  const text = renderChildren(child, indent2);
   return isFirst ? `${pad}${marker} ${text}` : `${pad}  ${text}`;
 }
-function renderListItem(node, indent, marker) {
-  const pad = "  ".repeat(indent);
-  return (node.content ?? []).map((child, i) => renderListChild(child, indent, pad, marker, i === 0)).join("\n");
+function renderListItem(node, indent2, marker) {
+  const pad = "  ".repeat(indent2);
+  return (node.content ?? []).map((child, i) => renderListChild(child, indent2, pad, marker, i === 0)).join("\n");
 }
 function adfToText(doc) {
   return renderNodes([doc], 0);
@@ -8507,20 +8804,20 @@ function acceptanceCriteria(issueKey) {
 import { execSync as execSync25 } from "child_process";
 
 // src/shared/loadJson.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync7, readFileSync as readFileSync26, writeFileSync as writeFileSync20 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join29 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync8, readFileSync as readFileSync28, writeFileSync as writeFileSync20 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join33 } from "path";
 function getStoreDir() {
-  return join29(homedir8(), ".assist");
+  return join33(homedir9(), ".assist");
 }
 function getStorePath(filename) {
-  return join29(getStoreDir(), filename);
+  return join33(getStoreDir(), filename);
 }
 function loadJson(filename) {
   const path52 = getStorePath(filename);
-  if (existsSync30(path52)) {
+  if (existsSync32(path52)) {
     try {
-      return JSON.parse(readFileSync26(path52, "utf-8"));
+      return JSON.parse(readFileSync28(path52, "utf-8"));
     } catch {
       return {};
     }
@@ -8529,8 +8826,8 @@ function loadJson(filename) {
 }
 function saveJson(filename, data) {
   const dir = getStoreDir();
-  if (!existsSync30(dir)) {
-    mkdirSync7(dir, { recursive: true });
+  if (!existsSync32(dir)) {
+    mkdirSync8(dir, { recursive: true });
   }
   writeFileSync20(getStorePath(filename), JSON.stringify(data, null, 2));
 }
@@ -8619,12 +8916,12 @@ function registerJira(program2) {
 }
 
 // src/commands/mermaid/index.ts
-import { mkdirSync as mkdirSync8, readdirSync as readdirSync5 } from "fs";
+import { mkdirSync as mkdirSync9, readdirSync as readdirSync6 } from "fs";
 import { resolve as resolve10 } from "path";
 import chalk101 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync21 } from "fs";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync21 } from "fs";
 import { basename as basename7, extname, resolve as resolve9 } from "path";
 import chalk100 from "chalk";
 
@@ -8650,7 +8947,7 @@ async function renderBlock(krokiUrl, source) {
 
 // src/commands/mermaid/exportFile.ts
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
-  const content = readFileSync27(file, "utf8");
+  const content = readFileSync29(file, "utf8");
   const blocks = extractMermaidBlocks(content);
   const stem = basename7(file, extname(file));
   if (onlyIndex !== void 0) {
@@ -8688,7 +8985,7 @@ function extractMermaidBlocks(markdown) {
 async function mermaidExport(file, options2 = {}) {
   const { mermaid } = loadConfig();
   const outDir = resolve10(process.cwd(), options2.out ?? ".");
-  mkdirSync8(outDir, { recursive: true });
+  mkdirSync9(outDir, { recursive: true });
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
       console.error(
@@ -8701,7 +8998,7 @@ async function mermaidExport(file, options2 = {}) {
       process.exit(1);
     }
   }
-  const files = file ? [file] : readdirSync5(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
+  const files = file ? [file] : readdirSync6(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
   if (files.length === 0) {
     console.log(chalk101.gray("No markdown files found in current directory."));
     return;
@@ -9007,7 +9304,7 @@ function registerPrompts(program2) {
 import { spawnSync as spawnSync2 } from "child_process";
 import { unlinkSync as unlinkSync6, writeFileSync as writeFileSync22 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join30 } from "path";
+import { join as join34 } from "path";
 function buildArgs2(queryFile, vars) {
   const args = ["api", "graphql", "-F", `query=@${queryFile}`];
   for (const [key, value] of Object.entries(vars)) {
@@ -9017,7 +9314,7 @@ function buildArgs2(queryFile, vars) {
   return args;
 }
 function runGhGraphql(mutation, vars) {
-  const queryFile = join30(tmpdir4(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join34(tmpdir4(), `gh-query-${Date.now()}.graphql`);
   writeFileSync22(queryFile, mutation);
   try {
     const result = spawnSync2("gh", buildArgs2(queryFile, vars), {
@@ -9211,26 +9508,26 @@ import { execSync as execSync29 } from "child_process";
 import { execSync as execSync28 } from "child_process";
 import { unlinkSync as unlinkSync8, writeFileSync as writeFileSync23 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join32 } from "path";
+import { join as join36 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync31, readFileSync as readFileSync28, unlinkSync as unlinkSync7 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync30, unlinkSync as unlinkSync7 } from "fs";
+import { join as join35 } from "path";
 import { parse as parse2 } from "yaml";
 function getCachePath(prNumber) {
-  return join31(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join35(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (!existsSync31(cachePath)) {
+  if (!existsSync33(cachePath)) {
     return null;
   }
-  const content = readFileSync28(cachePath, "utf-8");
+  const content = readFileSync30(cachePath, "utf-8");
   return parse2(content);
 }
 function deleteCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (existsSync31(cachePath)) {
+  if (existsSync33(cachePath)) {
     unlinkSync7(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
@@ -9245,7 +9542,7 @@ function replyToComment(org, repo, prNumber, commentId, message) {
 }
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join32(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
+  const queryFile = join36(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync23(queryFile, mutation);
   try {
     execSync28(
@@ -9327,18 +9624,18 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments/index.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync9, writeFileSync as writeFileSync25 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync10, writeFileSync as writeFileSync25 } from "fs";
+import { join as join38 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
 import { execSync as execSync30 } from "child_process";
 import { unlinkSync as unlinkSync9, writeFileSync as writeFileSync24 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join33 } from "path";
+import { join as join37 } from "path";
 var THREAD_QUERY = `query($owner: String!, $repo: String!, $prNumber: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $prNumber) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 100) { nodes { databaseId } } } } } } }`;
 function fetchThreadIds(org, repo, prNumber) {
-  const queryFile = join33(tmpdir6(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join37(tmpdir6(), `gh-query-${Date.now()}.graphql`);
   writeFileSync24(queryFile, THREAD_QUERY);
   try {
     const result = execSync30(
@@ -9425,7 +9722,7 @@ function formatForHuman(comment3) {
     ""
   ].join("\n");
 }
-function summarise(comments2) {
+function summarise2(comments2) {
   const lineCount = comments2.filter((c) => c.type === "line").length;
   const reviewCount = comments2.filter((c) => c.type === "review").length;
   const parts = [];
@@ -9444,7 +9741,7 @@ function printComments2(result) {
       console.log(formatForHuman(comment3));
     }
   }
-  console.log(summarise(comments2));
+  console.log(summarise2(comments2));
   if (cachePath) {
     console.log(`Saved to ${cachePath}`);
   }
@@ -9452,16 +9749,16 @@ function printComments2(result) {
 
 // src/commands/prs/listComments/index.ts
 function writeCommentsCache(prNumber, comments2) {
-  const assistDir = join34(process.cwd(), ".assist");
-  if (!existsSync32(assistDir)) {
-    mkdirSync9(assistDir, { recursive: true });
+  const assistDir = join38(process.cwd(), ".assist");
+  if (!existsSync34(assistDir)) {
+    mkdirSync10(assistDir, { recursive: true });
   }
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments2
   };
-  const cachePath = join34(assistDir, `pr-${prNumber}-comments.yaml`);
+  const cachePath = join38(assistDir, `pr-${prNumber}-comments.yaml`);
   writeFileSync25(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
@@ -9494,7 +9791,7 @@ async function listComments() {
     ];
     updateCache(prNumber, allComments);
     const hasLineComments = allComments.some((c) => c.type === "line");
-    const cachePath = hasLineComments ? join34(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
+    const cachePath = hasLineComments ? join38(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
     return { comments: allComments, cachePath };
   } catch (error) {
     const handled = handleKnownErrors(error);
@@ -10178,17 +10475,17 @@ Refactor check failed:
 
 // src/commands/refactor/check/getViolations/index.ts
 import { execSync as execSync36 } from "child_process";
-import fs18 from "fs";
+import fs19 from "fs";
 import { minimatch as minimatch4 } from "minimatch";
 
 // src/commands/refactor/check/getViolations/getIgnoredFiles.ts
-import fs17 from "fs";
+import fs18 from "fs";
 var REFACTOR_YML_PATH = "refactor.yml";
 function parseRefactorYml() {
-  if (!fs17.existsSync(REFACTOR_YML_PATH)) {
+  if (!fs18.existsSync(REFACTOR_YML_PATH)) {
     return [];
   }
-  const content = fs17.readFileSync(REFACTOR_YML_PATH, "utf-8");
+  const content = fs18.readFileSync(REFACTOR_YML_PATH, "utf-8");
   const entries = [];
   const lines = content.split("\n");
   let currentEntry = {};
@@ -10218,7 +10515,7 @@ function getIgnoredFiles() {
 
 // src/commands/refactor/check/getViolations/index.ts
 function countLines(filePath) {
-  const content = fs18.readFileSync(filePath, "utf-8");
+  const content = fs19.readFileSync(filePath, "utf-8");
   return content.split("\n").length;
 }
 function getGitFiles(options2) {
@@ -10283,13 +10580,13 @@ function runScript(script, cwd) {
     });
   });
 }
-function logFailures(failed) {
-  for (const f of failed) {
+function logFailures(failed2) {
+  for (const f of failed2) {
     console.error(f.output);
   }
   console.error(`
-${failed.length} verify script(s) failed:`);
-  for (const f of failed) {
+${failed2.length} verify script(s) failed:`);
+  for (const f of failed2) {
     console.error(`  - ${f.script} (exit code ${f.code})`);
   }
 }
@@ -10300,9 +10597,9 @@ async function runVerifyQuietly() {
   const results = await Promise.all(
     result.verifyScripts.map((script) => runScript(script, packageDir))
   );
-  const failed = results.filter((r) => r.code !== 0);
-  if (failed.length > 0) {
-    logFailures(failed);
+  const failed2 = results.filter((r) => r.code !== 0);
+  if (failed2.length > 0) {
+    logFailures(failed2);
     return false;
   }
   return true;
@@ -10924,12 +11221,12 @@ import chalk121 from "chalk";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
-import fs19 from "fs";
+import fs20 from "fs";
 import path34 from "path";
 import { Project as Project2 } from "ts-morph";
 function findTsConfig(sourcePath) {
   const rootConfig = path34.resolve("tsconfig.json");
-  if (!fs19.existsSync(rootConfig)) return rootConfig;
+  if (!fs20.existsSync(rootConfig)) return rootConfig;
   const tried = /* @__PURE__ */ new Set();
   const candidates = [rootConfig, ...readReferences(rootConfig)];
   for (const candidate of candidates) {
@@ -10937,7 +11234,7 @@ function findTsConfig(sourcePath) {
     tried.add(candidate);
     if (projectIncludes(candidate, sourcePath)) return candidate;
   }
-  const siblings = fs19.readdirSync(path34.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path34.resolve(path34.dirname(rootConfig), f));
+  const siblings = fs20.readdirSync(path34.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path34.resolve(path34.dirname(rootConfig), f));
   for (const sibling of siblings) {
     if (tried.has(sibling)) continue;
     tried.add(sibling);
@@ -10946,8 +11243,8 @@ function findTsConfig(sourcePath) {
   return rootConfig;
 }
 function readReferences(configPath) {
-  if (!fs19.existsSync(configPath)) return [];
-  const raw = fs19.readFileSync(configPath, "utf-8");
+  if (!fs20.existsSync(configPath)) return [];
+  const raw = fs20.readFileSync(configPath, "utf-8");
   const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   let parsed;
   try {
@@ -10959,8 +11256,8 @@ function readReferences(configPath) {
   const cwd = path34.dirname(configPath);
   return parsed.references.map((ref) => {
     const refPath = path34.resolve(cwd, ref.path);
-    return fs19.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path34.join(refPath, "tsconfig.json") : refPath;
-  }).filter((p) => fs19.existsSync(p));
+    return fs20.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path34.join(refPath, "tsconfig.json") : refPath;
+  }).filter((p) => fs20.existsSync(p));
 }
 function projectIncludes(configPath, sourcePath) {
   try {
@@ -11010,25 +11307,25 @@ async function extract(file, functionName, destination, options2 = {}) {
 }
 
 // src/commands/refactor/ignore.ts
-import fs20 from "fs";
+import fs21 from "fs";
 import chalk123 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
-  if (!fs20.existsSync(file)) {
+  if (!fs21.existsSync(file)) {
     console.error(chalk123.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
-  const content = fs20.readFileSync(file, "utf-8");
+  const content = fs21.readFileSync(file, "utf-8");
   const lineCount = content.split("\n").length;
   const maxLines = lineCount + 10;
   const entry = `- file: ${file}
   maxLines: ${maxLines}
 `;
-  if (fs20.existsSync(REFACTOR_YML_PATH2)) {
-    const existing = fs20.readFileSync(REFACTOR_YML_PATH2, "utf-8");
-    fs20.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  if (fs21.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs21.readFileSync(REFACTOR_YML_PATH2, "utf-8");
+    fs21.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
   } else {
-    fs20.writeFileSync(REFACTOR_YML_PATH2, entry);
+    fs21.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
     chalk123.green(
@@ -11276,7 +11573,7 @@ function clusterFiles(graph) {
 import path42 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
-import fs21 from "fs";
+import fs22 from "fs";
 function getOrCreateList(map, key) {
   const list4 = map.get(key) ?? [];
   if (!map.has(key)) map.set(key, list4);
@@ -11295,7 +11592,7 @@ function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
   return content.replace(pattern2, `$1${newSpecifier}$2`);
 }
 function applyFileRewrites(file, fileRewrites) {
-  let content = fs21.readFileSync(file, "utf-8");
+  let content = fs22.readFileSync(file, "utf-8");
   for (const { oldSpecifier, newSpecifier } of fileRewrites) {
     content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
   }
@@ -11423,27 +11720,27 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 }
 
 // src/commands/refactor/restructure/executePlan.ts
-import fs22 from "fs";
+import fs23 from "fs";
 import path44 from "path";
 import chalk127 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
-    fs22.writeFileSync(file, content, "utf-8");
+    fs23.writeFileSync(file, content, "utf-8");
     console.log(
       chalk127.cyan(`  Rewrote imports in ${path44.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
-    fs22.mkdirSync(dir, { recursive: true });
+    fs23.mkdirSync(dir, { recursive: true });
     console.log(chalk127.green(`  Created ${path44.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan2.moves) {
     const targetDir = path44.dirname(move.to);
-    if (!fs22.existsSync(targetDir)) {
-      fs22.mkdirSync(targetDir, { recursive: true });
+    if (!fs23.existsSync(targetDir)) {
+      fs23.mkdirSync(targetDir, { recursive: true });
     }
-    fs22.renameSync(move.from, move.to);
+    fs23.renameSync(move.from, move.to);
     console.log(
       chalk127.white(
         `  Moved ${path44.relative(process.cwd(), move.from)} \u2192 ${path44.relative(process.cwd(), move.to)}`
@@ -11455,10 +11752,10 @@ function executePlan(plan2) {
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
   for (const dir of unique) {
-    if (!fs22.existsSync(dir)) continue;
-    const entries = fs22.readdirSync(dir);
+    if (!fs23.existsSync(dir)) continue;
+    const entries = fs23.readdirSync(dir);
     if (entries.length === 0) {
-      fs22.rmdirSync(dir);
+      fs23.rmdirSync(dir);
       console.log(
         chalk127.dim(
           `  Removed empty directory ${path44.relative(process.cwd(), dir)}`
@@ -11472,18 +11769,18 @@ function removeEmptyDirectories(dirs) {
 import path46 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
-import fs23 from "fs";
+import fs24 from "fs";
 function emptyResult() {
   return { moves: [], directories: [], warnings: [] };
 }
 function checkDirConflict(result, label2, dir) {
-  if (!fs23.existsSync(dir)) return false;
+  if (!fs24.existsSync(dir)) return false;
   result.warnings.push(`Skipping ${label2}: directory ${dir} already exists`);
   return true;
 }
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
-import fs24 from "fs";
+import fs25 from "fs";
 import path45 from "path";
 function collectEntry(results, dir, entry) {
   const full = path45.join(dir, entry.name);
@@ -11491,9 +11788,9 @@ function collectEntry(results, dir, entry) {
   results.push(...items);
 }
 function listFilesRecursive(dir) {
-  if (!fs24.existsSync(dir)) return [];
+  if (!fs25.existsSync(dir)) return [];
   const results = [];
-  for (const entry of fs24.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs25.readdirSync(dir, { withFileTypes: true })) {
     collectEntry(results, dir, entry);
   }
   return results;
@@ -11744,15 +12041,15 @@ ${context.diff.trimEnd()}
 }
 
 // src/commands/review/buildReviewPaths.ts
-import { join as join35 } from "path";
+import { join as join39 } from "path";
 function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join35(repoRoot, ".assist", "reviews", key);
+  const reviewDir = join39(repoRoot, ".assist", "reviews", key);
   return {
     reviewDir,
-    requestPath: join35(reviewDir, "request.md"),
-    claudePath: join35(reviewDir, "claude.md"),
-    codexPath: join35(reviewDir, "codex.md"),
-    synthesisPath: join35(reviewDir, "synthesis.md")
+    requestPath: join39(reviewDir, "request.md"),
+    claudePath: join39(reviewDir, "claude.md"),
+    codexPath: join39(reviewDir, "codex.md"),
+    synthesisPath: join39(reviewDir, "synthesis.md")
   };
 }
 
@@ -11870,7 +12167,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync29 } from "fs";
+import { readFileSync as readFileSync31 } from "fs";
 
 // src/commands/review/parseFindings.ts
 var SEVERITIES = ["blocker", "major", "minor", "nit"];
@@ -12017,21 +12314,21 @@ function buildCommentBody(finding) {
 }
 function postFindings(findings) {
   let posted = 0;
-  let failed = 0;
+  let failed2 = 0;
   for (const finding of findings) {
     const body = buildCommentBody(finding);
     try {
       comment2(finding.file, finding.line, body, finding.startLine);
       posted++;
     } catch (error) {
-      failed++;
+      failed2++;
       const message = error instanceof Error ? error.message : String(error);
       console.error(
         `Failed to post comment on ${finding.file}:${finding.line}: ${message}`
       );
     }
   }
-  return { posted, failed };
+  return { posted, failed: failed2 };
 }
 
 // src/commands/review/submitPendingReview.ts
@@ -12100,7 +12397,7 @@ async function postReviewToPr(synthesisPath, options2) {
     console.log("No PR found for current branch; nothing posted.");
     return;
   }
-  const markdown = readFileSync29(synthesisPath, "utf-8");
+  const markdown = readFileSync31(synthesisPath, "utf-8");
   const findings = parseFindings(markdown);
   if (findings.length === 0) {
     console.log("Synthesis contains no findings; nothing to post.");
@@ -12177,14 +12474,14 @@ async function handlePostSynthesis(synthesisPath, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync10, unlinkSync as unlinkSync10, writeFileSync as writeFileSync26 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync11, unlinkSync as unlinkSync10, writeFileSync as writeFileSync26 } from "fs";
 function clearReviewFiles(paths) {
   for (const path52 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync33(path52)) unlinkSync10(path52);
+    if (existsSync35(path52)) unlinkSync10(path52);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
-  mkdirSync10(paths.reviewDir, { recursive: true });
+  mkdirSync11(paths.reviewDir, { recursive: true });
   if (force) clearReviewFiles(paths);
   writeFileSync26(paths.requestPath, requestBody);
 }
@@ -12225,11 +12522,11 @@ async function runApplySession(synthesisPath) {
 }
 
 // src/commands/review/cachedReviewerResult.ts
-import { statSync as statSync4 } from "fs";
+import { statSync as statSync5 } from "fs";
 function cachedReviewerResult(name, outputPath) {
   let size;
   try {
-    size = statSync4(outputPath).size;
+    size = statSync5(outputPath).size;
   } catch {
     return null;
   }
@@ -12386,8 +12683,63 @@ function skippedCodexResult(outputPath) {
   return { name: "codex", outputPath, exitCode: 0, stderr: "" };
 }
 
+// src/commands/review/formatReviewerFailure.ts
+var FAST_FAIL_MS = 1e3;
+var STDOUT_TAIL_LINES = 20;
+function indent(text) {
+  return text.split(/\r?\n/).map((line) => `  ${line}`);
+}
+function tailLines(text, maxLines) {
+  const lines = text.split(/\r?\n/);
+  return lines.length <= maxLines ? text : lines.slice(-maxLines).join("\n");
+}
+function isFastFail(input) {
+  return input.exitCode !== 0 && input.elapsedMs !== void 0 && input.elapsedMs < FAST_FAIL_MS;
+}
+function fastFailHint(command) {
+  return [
+    `${command} exited almost immediately \u2014 it likely failed to start.`,
+    `Common causes: not installed on PATH, not authenticated, or misconfigured.`,
+    `Try \`${command} --version\` to confirm install, then \`${command} login\` if authentication may be missing.`
+  ];
+}
+function outputDetail(input) {
+  const stderr = input.stderr.trim();
+  if (stderr) return ["stderr:", ...indent(stderr)];
+  const stdout = (input.stdout ?? "").trim();
+  if (stdout) {
+    return [
+      `stdout (no stderr was captured \u2014 showing last ${STDOUT_TAIL_LINES} lines):`,
+      ...indent(tailLines(stdout, STDOUT_TAIL_LINES))
+    ];
+  }
+  return [
+    "No stderr or stdout was captured. Check the review folder for partial output, or rerun with --verbose for full streaming output."
+  ];
+}
+function formatReviewerFailure(input) {
+  const command = input.command ?? input.name;
+  const seconds = Math.round((input.elapsedMs ?? 0) / 1e3);
+  const headerLine = `${command} CLI exited with code ${input.exitCode} after ${seconds}s`;
+  const detailLines = [];
+  if (isFastFail(input)) detailLines.push(...fastFailHint(command));
+  detailLines.push(...outputDetail(input));
+  return { headerLine, detailLines };
+}
+function printReviewerFailure(input) {
+  if (input.exitCode === 0) return;
+  const diagnostic = formatReviewerFailure(input);
+  console.error(`[${input.name}] ${diagnostic.headerLine}`);
+  for (const line of diagnostic.detailLines) console.error(line);
+}
+
+// src/commands/review/printReviewerFailures.ts
+function printReviewerFailures(results) {
+  for (const r of results) printReviewerFailure(r);
+}
+
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync35, unlinkSync as unlinkSync12 } from "fs";
+import { existsSync as existsSync37, unlinkSync as unlinkSync12 } from "fs";
 
 // src/commands/review/buildReviewerStdin.ts
 var REVIEW_PROMPT = `You are acting as a reviewer for a proposed code change made by another engineer. The full review request \u2014 branch, base, changed files, and unified diff \u2014 is in request.md in the current working directory.
@@ -12450,26 +12802,26 @@ The review request is at: ${requestPath}
 `;
 }
 
-// src/commands/review/printReviewerFailures.ts
-function printReviewerFailures(results) {
-  for (const r of results) {
-    if (r.exitCode === 0) continue;
-    console.error(`[${r.name}] exited with code ${r.exitCode}`);
-    if (r.stderr) console.error(r.stderr.trim());
-  }
-}
-
 // src/commands/review/runClaudeReviewer.ts
 import { writeFileSync as writeFileSync27 } from "fs";
 
 // src/commands/review/finaliseReviewerSpinner.ts
-function finaliseReviewerSpinner(spinner, name, exitCode, elapsedMs) {
+var SUMMARY_MAX_LEN = 80;
+function summariseStderr(stderr) {
+  const firstLine = stderr.split(/\r?\n/).find((l) => l.trim().length > 0);
+  if (!firstLine) return "";
+  const trimmed = firstLine.trim();
+  return trimmed.length > SUMMARY_MAX_LEN ? `${trimmed.slice(0, SUMMARY_MAX_LEN - 1)}\u2026` : trimmed;
+}
+function finaliseReviewerSpinner(spinner, name, exitCode, elapsedMs, stderr = "") {
   const elapsed = Math.round(elapsedMs / 1e3);
   if (exitCode === 0) {
     spinner.succeed(`${name} \u2014 done in ${elapsed}s`);
     return;
   }
-  spinner.fail(`${name} \u2014 failed in ${elapsed}s`);
+  const summary = summariseStderr(stderr);
+  const suffix = summary ? `: ${summary}` : "";
+  spinner.fail(`${name} \u2014 failed in ${elapsed}s (exit ${exitCode})${suffix}`);
 }
 
 // src/commands/review/finaliseReviewerRun.ts
@@ -12479,13 +12831,17 @@ function finaliseReviewerRun(spec, spinner, result) {
       spinner,
       spec.name,
       result.exitCode,
-      result.elapsedMs
+      result.elapsedMs,
+      result.stderr
     );
   return {
     name: spec.name,
+    command: spec.command,
     outputPath: spec.outputPath,
     exitCode: result.exitCode,
-    stderr: result.stderr
+    stderr: result.stderr,
+    stdout: result.stdout,
+    elapsedMs: result.elapsedMs
   };
 }
 
@@ -12610,14 +12966,35 @@ function attachStderrCollector(child) {
   return state;
 }
 
+// src/commands/review/attachStdoutTail.ts
+function attachStdoutTail(child, maxBytes = 8192) {
+  const state = { value: "" };
+  child.stdout?.on("data", (chunk) => {
+    state.value += chunk.toString("utf-8");
+    if (state.value.length > maxBytes) {
+      state.value = state.value.slice(state.value.length - maxBytes);
+    }
+  });
+  return state;
+}
+
 // src/commands/review/logChildClose.ts
-function logChildClose(name, code, elapsedSeconds, stderr) {
-  if (code === 0) {
-    console.log(`[${name}] done in ${elapsedSeconds}s`);
+function logChildClose(args) {
+  const elapsedSeconds = Math.round(args.elapsedMs / 1e3);
+  if (args.exitCode === 0) {
+    console.log(`[${args.name}] done in ${elapsedSeconds}s`);
     return;
   }
-  console.error(`[${name}] exited with code ${code} in ${elapsedSeconds}s`);
-  if (stderr) console.error(stderr.trim());
+  const diagnostic = formatReviewerFailure({
+    name: args.name,
+    command: args.command,
+    exitCode: args.exitCode,
+    stderr: args.stderr,
+    stdout: args.stdout,
+    elapsedMs: args.elapsedMs
+  });
+  console.error(`[${args.name}] ${diagnostic.headerLine}`);
+  for (const line of diagnostic.detailLines) console.error(line);
 }
 
 // src/commands/review/handleChildClose.ts
@@ -12625,8 +13002,14 @@ function handleChildClose(args) {
   const elapsedMs = Date.now() - args.startedAt;
   const exitCode = args.code ?? 0;
   if (!args.quiet) {
-    const elapsed = Math.round(elapsedMs / 1e3);
-    logChildClose(args.name, exitCode, elapsed, args.stderr);
+    logChildClose({
+      name: args.name,
+      command: args.command,
+      exitCode,
+      elapsedMs,
+      stderr: args.stderr,
+      stdout: args.stdout
+    });
   }
   return { exitCode, elapsedMs };
 }
@@ -12644,6 +13027,7 @@ ${message}` : message;
   return {
     exitCode: 127,
     stderr,
+    stdout: ctx.stdout,
     elapsedMs: Date.now() - ctx.startedAt
   };
 }
@@ -12656,6 +13040,7 @@ function onErrorResult(ctx, err) {
       command: ctx.command,
       name: ctx.name,
       stderr: ctx.stderr.value,
+      stdout: ctx.stdout.value,
       startedAt: ctx.startedAt,
       quiet: ctx.quiet
     },
@@ -12668,10 +13053,12 @@ function onCloseResult(ctx, code) {
     code,
     startedAt: ctx.startedAt,
     name: ctx.name,
+    command: ctx.command,
     stderr: ctx.stderr.value,
+    stdout: ctx.stdout.value,
     quiet: ctx.quiet
   });
-  return { ...closed, stderr: ctx.stderr.value };
+  return { ...closed, stderr: ctx.stderr.value, stdout: ctx.stdout.value };
 }
 function waitForChildExit(ctx) {
   return new Promise((resolve15) => {
@@ -12698,21 +13085,24 @@ function writeStdinSafely(child, payload) {
 }
 function startChild(spec) {
   const child = spawn6(spec.command, spec.args, {
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: process.platform === "win32"
   });
   const flushPending = attachLineParser(child, spec.onLine);
   const stderr = attachStderrCollector(child);
+  const stdout = attachStdoutTail(child);
   writeStdinSafely(child, spec.stdin);
-  return { child, flushPending, stderr };
+  return { child, flushPending, stderr, stdout };
 }
 function runStreamingChild(spec) {
   const startedAt = Date.now();
   if (!spec.quiet) console.log(`[${spec.name}] starting`);
-  const { child, flushPending, stderr } = startChild(spec);
+  const { child, flushPending, stderr, stdout } = startChild(spec);
   return waitForChildExit({
     child,
     flushPending,
     stderr,
+    stdout,
     name: spec.name,
     command: spec.command,
     startedAt,
@@ -12724,9 +13114,10 @@ function runStreamingChild(spec) {
 async function runClaudeReviewer(spec) {
   let finalText = "";
   const { spinner } = spec;
+  const command = "claude";
   const result = await runStreamingChild({
     name: spec.name,
-    command: "claude",
+    command,
     args: [
       "-p",
       "--add-dir",
@@ -12749,7 +13140,7 @@ async function runClaudeReviewer(spec) {
   });
   if (result.exitCode === 0 && finalText)
     writeFileSync27(spec.outputPath, finalText);
-  return finaliseReviewerRun(spec, spinner, result);
+  return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
 
 // src/commands/review/resolveClaude.ts
@@ -12766,7 +13157,7 @@ function resolveClaude(args) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync34, unlinkSync as unlinkSync11 } from "fs";
+import { existsSync as existsSync36, unlinkSync as unlinkSync11 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -12807,9 +13198,10 @@ function codexArgs(reviewDir, outputPath) {
 }
 async function runCodexReviewer(spec) {
   const { spinner } = spec;
+  const command = "codex";
   const result = await runStreamingChild({
     name: spec.name,
-    command: "codex",
+    command,
     args: codexArgs(spec.reviewDir, spec.outputPath),
     stdin: spec.stdin,
     quiet: Boolean(spinner),
@@ -12819,10 +13211,10 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner);
     }
   });
-  if (result.exitCode !== 0 && existsSync34(spec.outputPath)) {
+  if (result.exitCode !== 0 && existsSync36(spec.outputPath)) {
     unlinkSync11(spec.outputPath);
   }
-  return finaliseReviewerRun(spec, spinner, result);
+  return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
 
 // src/commands/review/resolveCodex.ts
@@ -12858,13 +13250,12 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
     multi: options2.multi
   });
   const results = await Promise.all([claudePromise, codexPromise]);
-  if (options2.multi) printReviewerFailures(results);
   const anyFresh = options2.cachedClaude === null || options2.codexPlan.kind !== "cached";
   return { results, anyFresh };
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync30 } from "fs";
+import { readFileSync as readFileSync32 } from "fs";
 
 // src/commands/review/buildSynthesisStdin.ts
 var SYNTHESIS_PROMPT = `You are consolidating two independent code reviews of the same change. The original review request is in request.md. The two reviews are in claude.md and codex.md in the current working directory.
@@ -12920,7 +13311,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary(synthesisPath) {
-  const markdown = readFileSync30(synthesisPath, "utf-8");
+  const markdown = readFileSync32(synthesisPath, "utf-8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -12946,12 +13337,14 @@ async function synthesise(paths, options2) {
     outputPath: paths.synthesisPath,
     spinner
   });
-  if (multi) printReviewerFailures([result]);
   if (result.exitCode === 0) printSummary(paths.synthesisPath);
   return result;
 }
 
 // src/commands/review/runAndSynthesise.ts
+function failed(results) {
+  return results.filter((r) => r.exitCode !== 0);
+}
 async function runAndSynthesise(args) {
   const { paths, multi } = args;
   const { results, anyFresh } = await runReviewers(
@@ -12961,17 +13354,17 @@ async function runAndSynthesise(args) {
     buildReviewerStdin(paths.requestPath),
     { multi, codexPlan: args.codexPlan, cachedClaude: args.cachedClaude }
   );
+  const failures = failed(results);
   if (results.every((r) => r.exitCode !== 0)) {
-    console.error(
-      "Both reviewers failed; skipping synthesis. See review folder for stderr details."
-    );
-    return false;
+    console.error("Both reviewers failed; skipping synthesis.");
+    return { ok: false, failures };
   }
-  if (anyFresh && existsSync35(paths.synthesisPath)) {
+  if (anyFresh && existsSync37(paths.synthesisPath)) {
     unlinkSync12(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
-  return synthesisResult.exitCode === 0;
+  if (synthesisResult.exitCode !== 0) failures.push(synthesisResult);
+  return { ok: synthesisResult.exitCode === 0, failures };
 }
 
 // src/commands/review/useSpinnerUi.ts
@@ -12994,19 +13387,25 @@ function finishUi(ui, ok) {
   if (ok) ui.elapsed.succeed(label2);
   else ui.elapsed.fail(label2);
 }
+function reportFailures(failures, usingSpinner) {
+  if (failures.length === 0) return;
+  if (!usingSpinner) return;
+  printReviewerFailures(failures);
+}
 async function runReviewPipeline(paths, options2) {
   const cachedClaude = cachedReviewerResult("claude", paths.claudePath);
   const codexPlan = await planCodexReviewer(paths.codexPath);
   const ui = createUi(useSpinnerUi(options2.verbose));
   try {
-    const ok = await runAndSynthesise({
+    const outcome = await runAndSynthesise({
       paths,
       cachedClaude,
       codexPlan,
       multi: ui.multi
     });
-    finishUi(ui, ok);
-    return ok;
+    finishUi(ui, outcome.ok);
+    reportFailures(outcome.failures, ui.multi !== void 0);
+    return outcome.ok;
   } catch (err) {
     ui.multi?.failRemaining();
     throw err;
@@ -13777,8 +14176,8 @@ function registerSql(program2) {
 }
 
 // src/commands/transcript/shared.ts
-import { existsSync as existsSync36, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
-import { basename as basename8, join as join36, relative as relative2 } from "path";
+import { existsSync as existsSync38, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
+import { basename as basename8, join as join40, relative as relative2 } from "path";
 import * as readline2 from "readline";
 var DATE_PREFIX_REGEX = /^\d{4}-\d{2}-\d{2}/;
 function getDatePrefix(daysOffset = 0) {
@@ -13793,11 +14192,11 @@ function isValidDatePrefix(filename) {
   return DATE_PREFIX_REGEX.test(filename);
 }
 function collectFiles(dir, extension) {
-  if (!existsSync36(dir)) return [];
+  if (!existsSync38(dir)) return [];
   const results = [];
-  for (const entry of readdirSync6(dir)) {
-    const fullPath = join36(dir, entry);
-    if (statSync5(fullPath).isDirectory()) {
+  for (const entry of readdirSync7(dir)) {
+    const fullPath = join40(dir, entry);
+    if (statSync6(fullPath).isDirectory()) {
       results.push(...collectFiles(fullPath, extension));
     } else if (entry.endsWith(extension)) {
       results.push(fullPath);
@@ -13890,14 +14289,14 @@ async function configure() {
 }
 
 // src/commands/transcript/format/index.ts
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/index.ts
-import { dirname as dirname20, join as join38 } from "path";
+import { dirname as dirname20, join as join42 } from "path";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/promptForDateFix.ts
-import { renameSync as renameSync2 } from "fs";
-import { join as join37 } from "path";
+import { renameSync as renameSync3 } from "fs";
+import { join as join41 } from "path";
 async function resolveDate(rl, choice) {
   if (choice === "1") return getDatePrefix(0);
   if (choice === "2") return getDatePrefix(-1);
@@ -13912,7 +14311,7 @@ async function resolveDate(rl, choice) {
 }
 function renameWithPrefix(vttDir, vttFile, prefix2) {
   const newFilename = `${prefix2}.${vttFile}`;
-  renameSync2(join37(vttDir, vttFile), join37(vttDir, newFilename));
+  renameSync3(join41(vttDir, vttFile), join41(vttDir, newFilename));
   console.log(`Renamed to: ${newFilename}`);
   return newFilename;
 }
@@ -13946,12 +14345,12 @@ async function fixInvalidDatePrefixes(vttFiles) {
       const vttFileDir = dirname20(vttFile.absolutePath);
       const newFilename = await promptForDateFix(vttFile.filename, vttFileDir);
       if (newFilename) {
-        const newRelativePath = join38(
+        const newRelativePath = join42(
           dirname20(vttFile.relativePath),
           newFilename
         );
         vttFiles[i] = {
-          absolutePath: join38(vttFileDir, newFilename),
+          absolutePath: join42(vttFileDir, newFilename),
           relativePath: newRelativePath,
           filename: newFilename
         };
@@ -13964,8 +14363,8 @@ async function fixInvalidDatePrefixes(vttFiles) {
 }
 
 // src/commands/transcript/format/processVttFile/index.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync11, readFileSync as readFileSync31, writeFileSync as writeFileSync28 } from "fs";
-import { basename as basename9, dirname as dirname21, join as join39 } from "path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync12, readFileSync as readFileSync33, writeFileSync as writeFileSync28 } from "fs";
+import { basename as basename9, dirname as dirname21, join as join43 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text) {
@@ -14175,22 +14574,22 @@ function toMdFilename(vttFilename) {
   return `${basename9(vttFilename, ".vtt").replace(/\s*Transcription\s*/g, " ").trim()}.md`;
 }
 function resolveOutputDir(relativeDir, transcriptsDir) {
-  return relativeDir === "." ? transcriptsDir : join39(transcriptsDir, relativeDir);
+  return relativeDir === "." ? transcriptsDir : join43(transcriptsDir, relativeDir);
 }
 function buildOutputPaths(vttFile, transcriptsDir) {
   const mdFile = toMdFilename(vttFile.filename);
   const relativeDir = dirname21(vttFile.relativePath);
   const outputDir = resolveOutputDir(relativeDir, transcriptsDir);
-  const outputPath = join39(outputDir, mdFile);
+  const outputPath = join43(outputDir, mdFile);
   return { outputDir, outputPath, mdFile, relativeDir };
 }
 function logSkipped(relativeDir, mdFile) {
-  console.log(`Skipping (already exists): ${join39(relativeDir, mdFile)}`);
+  console.log(`Skipping (already exists): ${join43(relativeDir, mdFile)}`);
   return "skipped";
 }
 function ensureDirectory(dir, label2) {
-  if (!existsSync37(dir)) {
-    mkdirSync11(dir, { recursive: true });
+  if (!existsSync39(dir)) {
+    mkdirSync12(dir, { recursive: true });
     console.log(`Created ${label2}: ${dir}`);
   }
 }
@@ -14212,7 +14611,7 @@ function logReduction(cueCount, messageCount) {
 }
 function readAndParseCues(inputPath) {
   console.log(`Reading: ${inputPath}`);
-  return processCues(readFileSync31(inputPath, "utf-8"));
+  return processCues(readFileSync33(inputPath, "utf-8"));
 }
 function writeFormatted(outputPath, content) {
   writeFileSync28(outputPath, content, "utf-8");
@@ -14225,7 +14624,7 @@ function convertVttToMarkdown(inputPath, outputPath) {
   logReduction(cues.length, chatMessages.length);
 }
 function tryProcessVtt(vttFile, paths) {
-  if (existsSync37(paths.outputPath))
+  if (existsSync39(paths.outputPath))
     return logSkipped(paths.relativeDir, paths.mdFile);
   convertVttToMarkdown(vttFile.absolutePath, paths.outputPath);
   return "processed";
@@ -14251,7 +14650,7 @@ function processAllFiles(vttFiles, transcriptsDir) {
   logSummary(counts);
 }
 function requireVttDir(vttDir) {
-  if (!existsSync38(vttDir)) {
+  if (!existsSync40(vttDir)) {
     console.error(`VTT directory not found: ${vttDir}`);
     process.exit(1);
   }
@@ -14283,18 +14682,18 @@ async function format() {
 }
 
 // src/commands/transcript/summarise/index.ts
-import { existsSync as existsSync40 } from "fs";
-import { basename as basename10, dirname as dirname23, join as join41, relative as relative3 } from "path";
+import { existsSync as existsSync42 } from "fs";
+import { basename as basename10, dirname as dirname23, join as join45, relative as relative3 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
 import {
-  existsSync as existsSync39,
-  mkdirSync as mkdirSync12,
-  readFileSync as readFileSync32,
-  renameSync as renameSync3,
+  existsSync as existsSync41,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync34,
+  renameSync as renameSync4,
   rmSync
 } from "fs";
-import { dirname as dirname22, join as join40 } from "path";
+import { dirname as dirname22, join as join44 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
 import chalk142 from "chalk";
@@ -14323,9 +14722,9 @@ function validateStagedContent(filename, content) {
 }
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
-var STAGING_DIR = join40(process.cwd(), ".assist", "transcript");
+var STAGING_DIR = join44(process.cwd(), ".assist", "transcript");
 function processStagedFile() {
-  if (!existsSync39(STAGING_DIR)) {
+  if (!existsSync41(STAGING_DIR)) {
     return false;
   }
   const stagedFiles = findMdFilesRecursive(STAGING_DIR);
@@ -14334,7 +14733,7 @@ function processStagedFile() {
   }
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
   const stagedFile = stagedFiles[0];
-  const content = readFileSync32(stagedFile.absolutePath, "utf-8");
+  const content = readFileSync34(stagedFile.absolutePath, "utf-8");
   validateStagedContent(stagedFile.filename, content);
   const stagedBaseName = getTranscriptBaseName(stagedFile.filename);
   const transcriptFiles = findMdFilesRecursive(transcriptsDir);
@@ -14347,12 +14746,12 @@ function processStagedFile() {
     );
     process.exit(1);
   }
-  const destPath = join40(summaryDir, matchingTranscript.relativePath);
+  const destPath = join44(summaryDir, matchingTranscript.relativePath);
   const destDir = dirname22(destPath);
-  if (!existsSync39(destDir)) {
-    mkdirSync12(destDir, { recursive: true });
+  if (!existsSync41(destDir)) {
+    mkdirSync13(destDir, { recursive: true });
   }
-  renameSync3(stagedFile.absolutePath, destPath);
+  renameSync4(stagedFile.absolutePath, destPath);
   const remaining = findMdFilesRecursive(STAGING_DIR);
   if (remaining.length === 0) {
     rmSync(STAGING_DIR, { recursive: true });
@@ -14363,7 +14762,7 @@ function processStagedFile() {
 // src/commands/transcript/summarise/index.ts
 function buildRelativeKey(relativePath, baseName) {
   const relDir = dirname23(relativePath);
-  return relDir === "." ? baseName : join41(relDir, baseName);
+  return relDir === "." ? baseName : join45(relDir, baseName);
 }
 function buildSummaryIndex(summaryDir) {
   const summaryFiles = findMdFilesRecursive(summaryDir);
@@ -14373,10 +14772,10 @@ function buildSummaryIndex(summaryDir) {
     )
   );
 }
-function summarise2() {
+function summarise3() {
   processStagedFile();
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
-  if (!existsSync40(transcriptsDir)) {
+  if (!existsSync42(transcriptsDir)) {
     console.log("No transcripts directory found.");
     return;
   }
@@ -14397,8 +14796,8 @@ function summarise2() {
   }
   const next3 = missing[0];
   const outputFilename = `${getTranscriptBaseName(next3.filename)}.md`;
-  const outputPath = join41(STAGING_DIR, outputFilename);
-  const summaryFileDir = join41(summaryDir, dirname23(next3.relativePath));
+  const outputPath = join45(STAGING_DIR, outputFilename);
+  const summaryFileDir = join45(summaryDir, dirname23(next3.relativePath));
   const relativeTranscriptPath = encodeURI(
     relative3(summaryFileDir, next3.absolutePath).replace(/\\/g, "/")
   );
@@ -14419,7 +14818,7 @@ function registerTranscript(program2) {
   const transcriptCommand = program2.command("transcript").description("Meeting transcript utilities");
   transcriptCommand.command("configure").description("Configure transcript directories").action(configure);
   transcriptCommand.command("format").description("Convert VTT files to formatted markdown transcripts").action(format);
-  transcriptCommand.command("summarise").description("List transcripts that do not have summaries").action(summarise2);
+  transcriptCommand.command("summarise").description("List transcripts that do not have summaries").action(summarise3);
 }
 
 // src/commands/registerVerify.ts
@@ -14447,50 +14846,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { join as join43 } from "path";
+import { join as join47 } from "path";
 
 // src/commands/voice/shared.ts
-import { homedir as homedir9 } from "os";
-import { dirname as dirname24, join as join42 } from "path";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname24, join as join46 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var __dirname6 = dirname24(fileURLToPath6(import.meta.url));
-var VOICE_DIR = join42(homedir9(), ".assist", "voice");
+var VOICE_DIR = join46(homedir10(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join42(VOICE_DIR, "voice.pid"),
-  log: join42(VOICE_DIR, "voice.log"),
-  venv: join42(VOICE_DIR, ".venv"),
-  lock: join42(VOICE_DIR, "voice.lock")
+  pid: join46(VOICE_DIR, "voice.pid"),
+  log: join46(VOICE_DIR, "voice.log"),
+  venv: join46(VOICE_DIR, ".venv"),
+  lock: join46(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join42(__dirname6, "commands", "voice", "python");
+  return join46(__dirname6, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join42(voicePaths.venv, "Scripts", "python.exe") : join42(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join46(voicePaths.venv, "Scripts", "python.exe") : join46(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join42(getLockDir(), "voice.lock");
+  return join46(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join43(getPythonDir(), "list_devices.py");
+  const script = join47(getPythonDir(), "list_devices.py");
   spawnSync4(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync41, readFileSync as readFileSync33 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync35 } from "fs";
 function logs(options2) {
-  if (!existsSync41(voicePaths.log)) {
+  if (!existsSync43(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync33(voicePaths.log, "utf-8").trim();
+  const content = readFileSync35(voicePaths.log, "utf-8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -14512,13 +14911,13 @@ function logs(options2) {
 
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { mkdirSync as mkdirSync14 } from "fs";
-import { join as join45 } from "path";
+import { mkdirSync as mkdirSync15 } from "fs";
+import { join as join49 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync41 } from "child_process";
-import { existsSync as existsSync42, mkdirSync as mkdirSync13, readFileSync as readFileSync34, writeFileSync as writeFileSync29 } from "fs";
-import { join as join44 } from "path";
+import { existsSync as existsSync44, mkdirSync as mkdirSync14, readFileSync as readFileSync36, writeFileSync as writeFileSync29 } from "fs";
+import { join as join48 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -14529,9 +14928,9 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync42(lockFile)) return;
+  if (!existsSync44(lockFile)) return;
   try {
-    const lock = JSON.parse(readFileSync34(lockFile, "utf-8"));
+    const lock = JSON.parse(readFileSync36(lockFile, "utf-8"));
     if (lock.pid && isProcessAlive2(lock.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock.pid}, env: ${lock.env}). Stop it first with: assist voice stop`
@@ -14542,7 +14941,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync42(getVenvPython())) return;
+  if (existsSync44(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync41(
@@ -14555,7 +14954,7 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync13(join44(lockFile, ".."), { recursive: true });
+  mkdirSync14(join48(lockFile, ".."), { recursive: true });
   writeFileSync29(
     lockFile,
     JSON.stringify({
@@ -14568,10 +14967,10 @@ function writeLockFile(pid) {
 
 // src/commands/voice/setup.ts
 function setup() {
-  mkdirSync14(voicePaths.dir, { recursive: true });
+  mkdirSync15(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join45(getPythonDir(), "setup_models.py");
+  const script = join49(getPythonDir(), "setup_models.py");
   const result = spawnSync5(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -14584,8 +14983,8 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn7 } from "child_process";
-import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync30 } from "fs";
-import { join as join46 } from "path";
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync30 } from "fs";
+import { join as join50 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -14618,12 +15017,12 @@ function spawnBackground(python, script, env) {
   console.log(`Voice daemon started (PID ${pid})`);
 }
 function start2(options2) {
-  mkdirSync15(voicePaths.dir, { recursive: true });
+  mkdirSync16(voicePaths.dir, { recursive: true });
   checkLockFile();
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join46(getPythonDir(), "voice_daemon.py");
+  const script = join50(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -14633,7 +15032,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync43, readFileSync as readFileSync35 } from "fs";
+import { existsSync as existsSync45, readFileSync as readFileSync37 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -14643,16 +15042,16 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count) {
-  if (!existsSync43(voicePaths.log)) return [];
-  const lines = readFileSync35(voicePaths.log, "utf-8").trim().split("\n");
+  if (!existsSync45(voicePaths.log)) return [];
+  const lines = readFileSync37(voicePaths.log, "utf-8").trim().split("\n");
   return lines.slice(-count);
 }
 function status() {
-  if (!existsSync43(voicePaths.pid)) {
+  if (!existsSync45(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync35(voicePaths.pid, "utf-8").trim(), 10);
+  const pid = Number.parseInt(readFileSync37(voicePaths.pid, "utf-8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -14671,13 +15070,13 @@ function status() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync44, readFileSync as readFileSync36, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync38, unlinkSync as unlinkSync13 } from "fs";
 function stop2() {
-  if (!existsSync44(voicePaths.pid)) {
+  if (!existsSync46(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync36(voicePaths.pid, "utf-8").trim(), 10);
+  const pid = Number.parseInt(readFileSync38(voicePaths.pid, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -14690,7 +15089,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync44(lockFile)) unlinkSync13(lockFile);
+    if (existsSync46(lockFile)) unlinkSync13(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -14911,20 +15310,20 @@ async function auth() {
 }
 
 // src/commands/roam/postRoamActivity.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import { readdirSync as readdirSync7, readFileSync as readFileSync37, statSync as statSync6 } from "fs";
-import { join as join47 } from "path";
+import { execFileSync as execFileSync5 } from "child_process";
+import { readdirSync as readdirSync8, readFileSync as readFileSync39, statSync as statSync7 } from "fs";
+import { join as join51 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
-    entries = readdirSync7(roamDir);
+    entries = readdirSync8(roamDir);
   } catch {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path52 = join47(roamDir, name);
+    const path52 = join51(roamDir, name);
     try {
-      return { path: path52, mtimeMs: statSync6(path52).mtimeMs };
+      return { path: path52, mtimeMs: statSync7(path52).mtimeMs };
     } catch {
       return void 0;
     }
@@ -14934,17 +15333,17 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join47(appData, "Roam"));
+  const portFile = findPortFile(join51(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync37(portFile, "utf-8").trim();
+    port = readFileSync39(portFile, "utf-8").trim();
   } catch {
     return;
   }
   const url = `http://127.0.0.1:${port}/api/v1/activity/${app}/${event}?pid=${app === "codex" ? 99998 : 99999}`;
   try {
-    execFileSync4("curl", ["-sf", "--max-time", "0.2", "-X", "POST", url], {
+    execFileSync5("curl", ["-sf", "--max-time", "0.2", "-X", "POST", url], {
       stdio: "ignore"
     });
   } catch {
@@ -15071,16 +15470,16 @@ function runPreCommands(pre, cwd) {
 }
 
 // src/commands/run/spawnRunCommand.ts
-import { execFileSync as execFileSync5, spawn as spawn8 } from "child_process";
-import { existsSync as existsSync45 } from "fs";
-import { dirname as dirname25, join as join48, resolve as resolve11 } from "path";
+import { execFileSync as execFileSync6, spawn as spawn8 } from "child_process";
+import { existsSync as existsSync47 } from "fs";
+import { dirname as dirname25, join as join52, resolve as resolve11 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
-    const gitPath = execFileSync5("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
+    const gitPath = execFileSync6("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve11(dirname25(gitPath), "..");
-    const gitBash = join48(gitRoot, "bin", "bash.exe");
-    if (existsSync45(gitBash)) return gitBash;
+    const gitBash = join52(gitRoot, "bin", "bash.exe");
+    if (existsSync47(gitBash)) return gitBash;
   } catch {
   }
   return command;
@@ -15147,8 +15546,8 @@ function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync31 } from "fs";
-import { join as join49 } from "path";
+import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync31 } from "fs";
+import { join as join53 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -15209,15 +15608,15 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join49(".claude", "commands");
-  mkdirSync16(dir, { recursive: true });
+  const dir = join53(".claude", "commands");
+  mkdirSync17(dir, { recursive: true });
   const content = `---
 description: Run ${name}
 ---
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join49(dir, `${name}.md`);
+  const filePath = join53(dir, `${name}.md`);
   writeFileSync31(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
@@ -15273,8 +15672,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync46, unlinkSync as unlinkSync14 } from "fs";
-import { join as join50 } from "path";
+import { existsSync as existsSync48, unlinkSync as unlinkSync14 } from "fs";
+import { join as join54 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -15289,8 +15688,8 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join50(".claude", "commands", `${name}.md`);
-  if (existsSync46(filePath)) {
+  const filePath = join54(".claude", "commands", `${name}.md`);
+  if (existsSync48(filePath)) {
     unlinkSync14(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -15326,9 +15725,9 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync44 } from "child_process";
-import { existsSync as existsSync47, mkdirSync as mkdirSync17, unlinkSync as unlinkSync15, writeFileSync as writeFileSync32 } from "fs";
+import { existsSync as existsSync49, mkdirSync as mkdirSync18, unlinkSync as unlinkSync15, writeFileSync as writeFileSync32 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join51, resolve as resolve13 } from "path";
+import { join as join55, resolve as resolve13 } from "path";
 import chalk144 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -15458,14 +15857,14 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync47(outputDir)) {
-    mkdirSync17(outputDir, { recursive: true });
+  if (!existsSync49(outputDir)) {
+    mkdirSync18(outputDir, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve13(outputDir, `${processName}-${timestamp}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join51(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
+  const scriptPath = join55(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync32(scriptPath, captureWindowPs1, "utf-8");
   try {
     execSync44(
@@ -15492,58 +15891,45 @@ function screenshot(processName) {
 }
 
 // src/commands/sessions/summarise/index.ts
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 import chalk145 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 function writeSummary(jsonlPath, summary) {
-  fs25.writeFileSync(summaryPathFor(jsonlPath), `${summary.trim()}
+  fs26.writeFileSync(summaryPathFor(jsonlPath), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath) {
-  return fs25.existsSync(summaryPathFor(jsonlPath));
+  return fs26.existsSync(summaryPathFor(jsonlPath));
 }
 function summaryPathFor(jsonlPath) {
   return jsonlPath.replace(/\.jsonl$/, ".summary");
 }
 
 // src/commands/sessions/summarise/summariseSession.ts
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 
 // src/commands/sessions/summarise/iterateUserMessages.ts
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 function* iterateUserMessages(filePath, maxBytes = 65536) {
   let content;
   try {
-    const fd = fs26.openSync(filePath, "r");
+    const fd = fs27.openSync(filePath, "r");
     try {
       const buf = Buffer.alloc(maxBytes);
-      const bytesRead = fs26.readSync(fd, buf, 0, buf.length, 0);
+      const bytesRead = fs27.readSync(fd, buf, 0, buf.length, 0);
       content = buf.toString("utf8", 0, bytesRead);
     } finally {
-      fs26.closeSync(fd);
+      fs27.closeSync(fd);
     }
   } catch {
     return;
   }
   for (const line of content.split("\n")) {
     if (!line) continue;
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (entry.type !== "user") continue;
-    const msg = entry.message;
-    const c = msg?.content;
-    if (typeof c === "string") {
-      yield c;
-    } else if (Array.isArray(c)) {
-      const text = c.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
-      if (text) yield text;
-    }
+    const entry = parseUserLine(line);
+    if (entry) yield entry.text;
   }
 }
 
@@ -15599,7 +15985,7 @@ function summariseSession(jsonlPath) {
   }
   const prompt = buildPrompt2(firstMessage, backlogIds);
   try {
-    const output = execFileSync6("claude", ["-p", "--model", "haiku", prompt], {
+    const output = execFileSync7("claude", ["-p", "--model", "haiku", prompt], {
       encoding: "utf8",
       timeout: 3e4,
       stdio: ["ignore", "pipe", "ignore"]
@@ -15630,7 +16016,7 @@ ${firstMessage}`);
 }
 
 // src/commands/sessions/summarise/index.ts
-async function summarise3(options2) {
+async function summarise4(options2) {
   const files = await discoverSessionJsonlPaths();
   if (files.length === 0) {
     console.log(chalk145.yellow("No sessions found."));
@@ -15646,16 +16032,16 @@ async function summarise3(options2) {
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
-  const { succeeded, failed } = processSessions(toProcess);
+  const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk145.green(`Done: ${succeeded} summarised`) + (failed > 0 ? chalk145.yellow(`, ${failed} skipped`) : "")
+    chalk145.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk145.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs27.statSync(b).mtimeMs - fs27.statSync(a).mtimeMs;
+      return fs28.statSync(b).mtimeMs - fs28.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -15665,7 +16051,7 @@ function selectCandidates(files, options2) {
 }
 function processSessions(files) {
   let succeeded = 0;
-  let failed = 0;
+  let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
     process.stdout.write(chalk145.dim(`  [${i + 1}/${files.length}] `));
@@ -15676,19 +16062,19 @@ function processSessions(files) {
       process.stdout.write(`${chalk145.green("\u2713")} ${summary}
 `);
     } else {
-      failed++;
+      failed2++;
       process.stdout.write(` ${chalk145.yellow("skip")}
 `);
     }
   }
-  return { succeeded, failed };
+  return { succeeded, failed: failed2 };
 }
 
 // src/commands/sessions/registerSessions.ts
 function registerSessions(program2) {
   const cmd = program2.command("sessions").description("Web dashboard for Claude Code sessions").action(() => web({ port: "3100" }));
   cmd.command("web").description("Start the sessions web dashboard").option("-p, --port <number>", "Port to listen on", "3100").action(web);
-  cmd.command("summarise").description("Generate one-line summaries for Claude sessions").option("-f, --force", "Re-generate all summaries, even existing ones").option("-n, --limit <count>", "Maximum number of sessions to summarise").action(summarise3);
+  cmd.command("summarise").description("Generate one-line summaries for Claude sessions").option("-f, --force", "Re-generate all summaries, even existing ones").option("-n, --limit <count>", "Maximum number of sessions to summarise").action(summarise4);
 }
 
 // src/commands/statusLine.ts
@@ -15769,21 +16155,21 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import * as os2 from "os";
 import * as path50 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs28 from "fs";
+import * as fs29 from "fs";
 import * as path48 from "path";
 import chalk148 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path48.join(claudeDir, "CLAUDE.md");
   const target = path48.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs28.readFileSync(source, "utf-8");
-  if (fs28.existsSync(target)) {
-    const targetContent = fs28.readFileSync(target, "utf-8");
+  const sourceContent = fs29.readFileSync(source, "utf-8");
+  if (fs29.existsSync(target)) {
+    const targetContent = fs29.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
         chalk148.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
@@ -15800,21 +16186,21 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs28.copyFileSync(source, target);
+  fs29.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 import * as path49 from "path";
 import chalk149 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path49.join(claudeDir, "settings.json");
   const target = path49.join(targetBase, "settings.json");
-  const sourceContent = fs29.readFileSync(source, "utf-8");
+  const sourceContent = fs30.readFileSync(source, "utf-8");
   const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
-  if (fs29.existsSync(target)) {
-    const targetContent = fs29.readFileSync(target, "utf-8");
+  if (fs30.existsSync(target)) {
+    const targetContent = fs30.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(
       JSON.parse(targetContent),
       null,
@@ -15840,7 +16226,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs29.writeFileSync(target, mergedContent);
+  fs30.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
@@ -15859,10 +16245,10 @@ async function sync(options2) {
 function syncCommands(claudeDir, targetBase) {
   const sourceDir = path50.join(claudeDir, "commands");
   const targetDir = path50.join(targetBase, "commands");
-  fs30.mkdirSync(targetDir, { recursive: true });
-  const files = fs30.readdirSync(sourceDir);
+  fs31.mkdirSync(targetDir, { recursive: true });
+  const files = fs31.readdirSync(sourceDir);
   for (const file of files) {
-    fs30.copyFileSync(path50.join(sourceDir, file), path50.join(targetDir, file));
+    fs31.copyFileSync(path50.join(sourceDir, file), path50.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -15930,6 +16316,7 @@ program.command("coverage").description("Print global statement coverage percent
 program.command("screenshot").description("Capture a screenshot of a running application window").argument("<process>", "Name of the running process (e.g. notepad, code)").action(screenshot);
 registerActivity(program);
 registerCliHook(program);
+registerHandover(program);
 registerJira(program);
 registerMermaid(program);
 registerPrs(program);