@staff0rd/assist 0.306.0 → 0.308.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.306.0",
+  version: "0.308.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -124,10 +124,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path58) {
-  if (!existsSync(path58)) return {};
+function loadRawYaml(path57) {
+  if (!existsSync(path57)) return {};
   try {
-    const content = readFileSync(path58, "utf8");
+    const content = readFileSync(path57, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -2912,10 +2912,10 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path58 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname12(path58), { recursive: true });
-  writeFileSync14(path58, JSON.stringify(hooksSettings, null, 2));
-  return path58;
+  const path57 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname12(path57), { recursive: true });
+  writeFileSync14(path57, JSON.stringify(hooksSettings, null, 2));
+  return path57;
 }
 
 // src/shared/spawnClaude.ts
@@ -2974,9 +2974,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path58 = join12(dir, ".assist", name);
-    if (existsSync15(path58)) {
-      renameSync(path58, `${path58}.bak`);
+    const path57 = join12(dir, ".assist", name);
+    if (existsSync15(path57)) {
+      renameSync(path57, `${path57}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -3393,8 +3393,8 @@ var backlogItemSchema = z3.strictObject({
 var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path58) {
-  const content = readFileSync12(path58, "utf8").trim();
+function parseBacklogJsonl(path57) {
+  const content = readFileSync12(path57, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -3674,8 +3674,8 @@ function findBacklogUp(startDir) {
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
-function stripLeadingSlashes(path58) {
-  return path58.replace(/^\/+/, "");
+function stripLeadingSlashes(path57) {
+  return path57.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -3958,13 +3958,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path58 = activityPath(sessionId);
-  mkdirSync7(dirname14(path58), { recursive: true });
-  writeFileSync16(path58, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path57 = activityPath(sessionId);
+  mkdirSync7(dirname14(path57), { recursive: true });
+  writeFileSync16(path57, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path58) {
+function readActivity(path57) {
   try {
-    return JSON.parse(readFileSync13(path58, "utf8"));
+    return JSON.parse(readFileSync13(path57, "utf8"));
   } catch {
     return void 0;
   }
@@ -3974,9 +3974,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path58 = activityPath(sessionId);
-  mkdirSync7(dirname14(path58), { recursive: true });
-  writeFileSync16(path58, JSON.stringify(activity2));
+  const path57 = activityPath(sessionId);
+  mkdirSync7(dirname14(path57), { recursive: true });
+  writeFileSync16(path57, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -4133,10 +4133,10 @@ function writeSignal(event, data) {
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path58 = getSignalPath();
-  if (!existsSync19(path58)) return void 0;
+  const path57 = getSignalPath();
+  if (!existsSync19(path57)) return void 0;
   try {
-    return JSON.parse(readFileSync14(path58, "utf8"));
+    return JSON.parse(readFileSync14(path57, "utf8"));
   } catch {
     return void 0;
   }
@@ -6553,8 +6553,8 @@ import chalk59 from "chalk";
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path58 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path58.split("/").filter(Boolean);
+    const path57 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path57.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -6849,6 +6849,9 @@ function registerPlanCommands(cmd) {
 import chalk67 from "chalk";
 import enquirer7 from "enquirer";
 
+// src/commands/backlog/launchMode.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
 // src/commands/backlog/handleLaunchSignal.ts
 import chalk66 from "chalk";
 
@@ -6923,15 +6926,17 @@ function buildSlashCommand(slashCommand, description) {
 async function launchMode(slashCommand, options2) {
   pullIfConfigured();
   process.env.ASSIST_SESSION_ID ??= String(process.pid);
+  const claudeSessionId = randomUUID2();
   emitActivity({
     kind: "command",
     name: slashCommand,
     itemId: options2?.itemId,
-    itemName: options2?.itemName
+    itemName: options2?.itemName,
+    claudeSessionId
   });
   const { child, done: done2 } = spawnClaude(
     buildSlashCommand(slashCommand, options2?.description),
-    { allowEdits: true }
+    { allowEdits: true, sessionId: claudeSessionId }
   );
   watchForMarker(child, { actOnDone: options2?.once });
   const launched = await awaitClaude(done2, `/${slashCommand}`);
@@ -7892,9 +7897,9 @@ var __dirname4 = dirname17(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path58) {
-  if (!existsSync22(path58)) return [];
-  return readFileSync18(path58, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path57) {
+  if (!existsSync22(path57)) return [];
+  return readFileSync18(path57, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -8359,14 +8364,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path58, description, depth, p) {
-  showProgress(p, path58.join(" "));
-  const subHelp = await runHelp([cli, ...path58]);
+async function resolveCommand(cli, path57, description, depth, p) {
+  showProgress(p, path57.join(" "));
+  const subHelp = await runHelp([cli, ...path57]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path58, description }];
+    return [{ path: path57, description }];
   }
-  const children = await discoverAt(cli, path58, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path58, description }];
+  const children = await discoverAt(cli, path57, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path57, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -8514,9 +8519,9 @@ function logPath(cli) {
   return join22(homedir9(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path58 = logPath(cli);
-  if (!existsSync24(path58)) return void 0;
-  return readFileSync20(path58, "utf8");
+  const path57 = logPath(cli);
+  if (!existsSync24(path57)) return void 0;
+  return readFileSync20(path57, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join22(homedir9(), ".assist");
@@ -9211,8 +9216,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path58, value) {
-  const keys = path58.split(".");
+function setNestedValue(obj, path57, value) {
+  const keys = path57.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -9292,9 +9297,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path58) {
+function getNestedValue(obj, path57) {
   let current = obj;
-  for (const key of path58.split(".")) current = stepInto(current, key);
+  for (const key of path57.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -11076,10 +11081,10 @@ function getStorePath(filename) {
   return join33(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path58 = getStorePath(filename);
-  if (existsSync32(path58)) {
+  const path57 = getStorePath(filename);
+  if (existsSync32(path57)) {
     try {
-      return JSON.parse(readFileSync28(path58, "utf8"));
+      return JSON.parse(readFileSync28(path57, "utf8"));
     } catch {
       return {};
     }
@@ -11179,6 +11184,7 @@ function registerJira(program2) {
 
 // src/commands/reviewComments.ts
 import { execFileSync as execFileSync5 } from "child_process";
+import { randomUUID as randomUUID3 } from "crypto";
 import chalk119 from "chalk";
 async function reviewComments(number) {
   if (number) {
@@ -11189,8 +11195,11 @@ async function reviewComments(number) {
       process.exit(1);
     }
   }
+  const claudeSessionId = randomUUID3();
+  emitActivity({ kind: "command", name: "review-comments", claudeSessionId });
   const { done: done2 } = spawnClaude("/review-comments", {
-    permissionMode: "acceptEdits"
+    permissionMode: "acceptEdits",
+    sessionId: claudeSessionId
   });
   await done2;
 }
@@ -11411,25 +11420,18 @@ function createNetcapHandler(options2) {
   };
 }
 
-// src/commands/netcap/defaultCapturePath.ts
-import { homedir as homedir12 } from "os";
-import { join as join34 } from "path";
-function defaultCapturePath() {
-  return join34(homedir12(), ".assist", "netcap", "capture.jsonl");
-}
-
 // src/commands/netcap/prepareExtensionForLoad.ts
 import { cp, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { networkInterfaces } from "os";
-import { join as join36 } from "path";
+import { join as join35 } from "path";
 import chalk123 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname19, join as join35 } from "path";
+import { dirname as dirname19, join as join34 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var moduleDir = dirname19(fileURLToPath5(import.meta.url));
 function netcapExtensionDir() {
-  return join35(moduleDir, "commands", "netcap", "netcap-extension");
+  return join34(moduleDir, "commands", "netcap", "netcap-extension");
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
@@ -11443,21 +11445,24 @@ function lanIPv4() {
   }
   return void 0;
 }
-async function setReceiverHost(dir, host, port) {
-  const file = join36(dir, "background.js");
+async function configureBackground(dir, host, port, filter) {
+  const file = join35(dir, "background.js");
   const source = await readFile2(file, "utf8");
   await writeFile2(
     file,
     source.replace(
       /const RECEIVER = "[^"]*";/,
       `const RECEIVER = "http://${host}:${port}/";`
+    ).replace(
+      /const FILTER = "[^"]*";/,
+      `const FILTER = ${JSON.stringify(filter)};`
     )
   );
 }
-async function prepareExtensionForLoad(port) {
+async function prepareExtensionForLoad(port, filter = "") {
   const source = netcapExtensionDir();
   if (detectPlatform() !== "wsl") {
-    await setReceiverHost(source, "127.0.0.1", port);
+    await configureBackground(source, "127.0.0.1", port, filter);
     return source;
   }
   const host = lanIPv4();
@@ -11465,12 +11470,12 @@ async function prepareExtensionForLoad(port) {
     console.log(
       chalk123.yellow("could not determine the WSL IP for the extension")
     );
-    await setReceiverHost(source, "127.0.0.1", port);
+    await configureBackground(source, "127.0.0.1", port, filter);
     return source;
   }
   try {
     await cp(source, WSL_WINDOWS_DIR, { recursive: true });
-    await setReceiverHost(WSL_WINDOWS_DIR, host, port);
+    await configureBackground(WSL_WINDOWS_DIR, host, port, filter);
     return WSL_WINDOWS_PATH;
   } catch {
     console.log(
@@ -11480,12 +11485,30 @@ async function prepareExtensionForLoad(port) {
   }
 }
 
+// src/commands/netcap/resolveNetcapOutPath.ts
+import { isAbsolute, join as join37, resolve as resolve11 } from "path";
+
+// src/commands/netcap/defaultCapturePath.ts
+import { homedir as homedir12 } from "os";
+import { join as join36 } from "path";
+function defaultCapturePath() {
+  return join36(homedir12(), ".assist", "netcap", "capture.jsonl");
+}
+
+// src/commands/netcap/resolveNetcapOutPath.ts
+function resolveNetcapOutPath(out) {
+  if (!out) return defaultCapturePath();
+  const dir = isAbsolute(out) ? out : resolve11(process.cwd(), out);
+  return join37(dir, "capture.jsonl");
+}
+
 // src/commands/netcap/netcap.ts
 async function netcap(options2) {
   const port = Number(options2.port);
-  const outPath = defaultCapturePath();
+  const outPath = resolveNetcapOutPath(options2.out);
+  const filter = options2.filter ?? "";
   await mkdir(dirname20(outPath), { recursive: true });
-  const extensionPath = await prepareExtensionForLoad(port);
+  const extensionPath = await prepareExtensionForLoad(port, filter);
   let count6 = 0;
   const handler = createNetcapHandler({
     outPath,
@@ -11504,24 +11527,480 @@ async function netcap(options2) {
       chalk124.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
     );
     console.log(chalk124.dim(`appending captures to ${outPath}`));
+    if (filter)
+      console.log(chalk124.dim(`forwarding only URLs matching "${filter}"`));
     console.log(chalk124.dim(`load the unpacked extension from ${extensionPath}`));
     console.log(chalk124.dim("press Ctrl-C to stop"));
   });
   process.on("SIGINT", () => {
     server.close();
+    console.log(
+      chalk124.bold(
+        `
+netcap stopped \u2014 captured ${count6} ${count6 === 1 ? "entry" : "entries"} to ${outPath}`
+      )
+    );
     process.exit(0);
   });
 }
 
+// src/commands/netcap/netcapExtract.ts
+import { writeFileSync as writeFileSync26 } from "fs";
+import { join as join38 } from "path";
+import chalk125 from "chalk";
+
+// src/commands/netcap/extractPostsFromCapture.ts
+import { readFileSync as readFileSync30 } from "fs";
+
+// src/commands/netcap/parseRscRows.ts
+var isRscRef = (v) => typeof v === "string" && /^\$[0-9a-fL@]/.test(v);
+function parseRscRows(flight) {
+  const rows = {};
+  for (const line of flight.split("\n")) {
+    const m = line.match(/^([0-9a-f]+):(.*)$/s);
+    if (!m) continue;
+    let payload = m[2];
+    if (payload && !/^[[{"\d\-tfn]/.test(payload[0]))
+      payload = payload.slice(1);
+    try {
+      rows[m[1]] = JSON.parse(payload);
+    } catch {
+      rows[m[1]] = m[2];
+    }
+  }
+  return rows;
+}
+function makeRscResolver(rows) {
+  return (ref) => {
+    const [id2, ...path57] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    let v = rows[id2];
+    for (const key of path57) {
+      if (v == null || typeof v !== "object") return void 0;
+      v = v[key];
+    }
+    return v;
+  };
+}
+
+// src/commands/netcap/collectRscText.ts
+function isVisibleText(t) {
+  if (/^(proto\.|com\.linkedin|react\.)/.test(t)) return false;
+  if (!/\s/.test(t.trim())) return false;
+  return /[a-zA-Z]{3,}/.test(t);
+}
+var isHashtag = (t) => /^#[A-Za-z0-9_]+$/.test(t);
+function collectRscText(v, resolve16, sink, seen) {
+  if (v == null) return;
+  if (typeof v === "string") {
+    if (isRscRef(v)) {
+      if (!seen.has(v)) {
+        seen.add(v);
+        collectRscText(resolve16(v), resolve16, sink, seen);
+      }
+    } else if (isHashtag(v)) sink.hashtags.push(v);
+    else if (isVisibleText(v)) sink.text.push(v);
+    return;
+  }
+  if (Array.isArray(v)) {
+    for (const x of v) collectRscText(x, resolve16, sink, seen);
+    return;
+  }
+  if (typeof v === "object") {
+    for (const val of Object.values(v)) {
+      collectRscText(val, resolve16, sink, seen);
+    }
+  }
+}
+
+// src/commands/netcap/buildMentionMap.ts
+function asObject(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function profileActionUrl(o) {
+  const actions = asObject(o.action)?.actions;
+  if (!Array.isArray(actions)) return void 0;
+  for (const a of actions) {
+    const url = asObject(asObject(asObject(a)?.value)?.content)?.url;
+    const target = asObject(url)?.url;
+    if (typeof target === "string" && /\/in\//.test(target)) return target;
+  }
+  return void 0;
+}
+var slugFromProfileUrl = (url) => url.match(/\/in\/([^/?]+)/)?.[1];
+function visitObjects(root, fn) {
+  const stack = [root];
+  while (stack.length) {
+    const v = stack.pop();
+    if (v == null || typeof v !== "object") continue;
+    const o = asObject(v);
+    if (o) fn(o);
+    for (const child of Array.isArray(v) ? v : Object.values(v)) {
+      if (child && typeof child === "object") stack.push(child);
+    }
+  }
+}
+function buildMentionMap(rows, resolve16) {
+  const map = /* @__PURE__ */ new Map();
+  visitObjects(rows, (o) => {
+    const url = profileActionUrl(o);
+    if (!url || o.children == null) return;
+    const slug = slugFromProfileUrl(url);
+    if (!slug || map.has(slug)) return;
+    const sink = { text: [], hashtags: [] };
+    collectRscText(o.children, resolve16, sink, /* @__PURE__ */ new Set());
+    const name = sink.text.join(" ").replace(/\s+/g, " ").trim();
+    map.set(slug, name ? { slug, name, url } : { slug, url });
+  });
+  return map;
+}
+
+// src/commands/netcap/activityUrnDate.ts
+function activityUrnDate(urn) {
+  if (!urn) return void 0;
+  const id2 = urn.split(":").pop();
+  if (!id2 || !/^\d+$/.test(id2)) return void 0;
+  return new Date(Number(BigInt(id2) >> 22n)).toISOString();
+}
+
+// src/commands/netcap/dedupeLinks.ts
+function decodeSafetyLink(url) {
+  try {
+    const wrapped = new URL(url).searchParams.get("url");
+    return wrapped ? decodeURIComponent(wrapped) : url;
+  } catch {
+    return url;
+  }
+}
+function dedupeLinks(links2) {
+  return [
+    ...new Set(
+      links2.map((l) => /\/safety\/go\//.test(l) ? decodeSafetyLink(l) : l)
+    )
+  ];
+}
+
+// src/commands/netcap/linkifyMentions.ts
+function linkifyMentions(text5, mentions) {
+  let out = text5;
+  for (const m of mentions) {
+    if (m.name && out.includes(m.name)) {
+      out = out.replace(m.name, `[${m.name}](${m.url})`);
+    }
+  }
+  return out;
+}
+
+// src/commands/netcap/buildPost.ts
+var profileUrl = (slug) => `https://www.linkedin.com/in/${slug}/`;
+var joinText = (parts) => parts.join(" ").replace(/\s+/g, " ").replace(/\s+([.,!?])/g, "$1").trim();
+function resolveMentions(raw, mentionMap, author) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const url of raw.profileUrls) {
+    const slug = slugFromProfileUrl(url);
+    if (slug && slug !== author) slugs.add(slug);
+  }
+  return [...slugs].map(
+    (slug) => mentionMap.get(slug) ?? { slug, url: profileUrl(slug) }
+  );
+}
+function resolveAuthor(mentionMap, author) {
+  if (!author) return void 0;
+  return mentionMap.get(author) ?? { slug: author, url: profileUrl(author) };
+}
+function buildPost(raw, mentionMap, author) {
+  const text5 = joinText(raw.text);
+  if (!text5) return void 0;
+  const mentions = resolveMentions(raw, mentionMap, author);
+  const relatedPosts = [...new Set(raw.related)];
+  return {
+    text: text5,
+    markdown: linkifyMentions(text5, mentions),
+    mentions,
+    hashtags: [...new Set(raw.hashtags)],
+    links: dedupeLinks(raw.links),
+    relatedPosts,
+    activityUrn: relatedPosts[0],
+    postedAt: activityUrnDate(relatedPosts[0]),
+    author: resolveAuthor(mentionMap, author)
+  };
+}
+
+// src/commands/netcap/walkPostRow.ts
+var isCommentary = (o) => asObject(o.viewTrackingSpecs)?.viewName === "feed-commentary";
+function walkPostRow(v, resolve16, raw) {
+  if (v == null || typeof v !== "object") return;
+  if (Array.isArray(v)) {
+    for (const x of v) walkPostRow(x, resolve16, raw);
+    return;
+  }
+  const o = v;
+  if (o.$type === "proto.sdui.actions.core.NavigateToUrl" && typeof o.url === "string") {
+    if (/\/in\//.test(o.url)) raw.profileUrls.push(o.url);
+    else raw.links.push(o.url);
+  }
+  if (o.$type === "proto.sdui.actions.requests.RequestedArguments") {
+    const a = JSON.stringify(o).match(/urn:li:activity:\d+/);
+    if (a) raw.related.push(a[0]);
+  }
+  if (isCommentary(o)) {
+    const sink = { text: raw.text, hashtags: raw.hashtags };
+    collectRscText(o.children, resolve16, sink, /* @__PURE__ */ new Set());
+  }
+  for (const val of Object.values(o)) walkPostRow(val, resolve16, raw);
+}
+
+// src/commands/netcap/extractLinkedInPosts.ts
+function findAuthorSlug(flight) {
+  return flight.match(/profile-activity-load-([A-Za-z0-9-]+)/)?.[1];
+}
+function findCommentaryRows(rows) {
+  return Object.keys(rows).filter(
+    (id2) => /"componentkey":"feed-commentary_/.test(JSON.stringify(rows[id2]))
+  );
+}
+function extractLinkedInPosts(flight, author = findAuthorSlug(flight)) {
+  const rows = parseRscRows(flight);
+  const resolve16 = makeRscResolver(rows);
+  const mentionMap = buildMentionMap(rows, resolve16);
+  const posts = [];
+  for (const id2 of findCommentaryRows(rows)) {
+    const raw = {
+      text: [],
+      hashtags: [],
+      profileUrls: [],
+      links: [],
+      related: []
+    };
+    walkPostRow(rows[id2], resolve16, raw);
+    const post = buildPost(raw, mentionMap, author);
+    if (post) posts.push(post);
+  }
+  return posts;
+}
+
+// src/commands/netcap/collectVoyagerAttributes.ts
+function attributeDetails(update3) {
+  const attrs = asObject(asObject(update3.commentary)?.text)?.attributesV2;
+  if (!Array.isArray(attrs)) return [];
+  return attrs.map((a) => asObject(asObject(a)?.detailData)).filter((d) => d !== void 0);
+}
+function mentionsFrom(details, profiles, authorSlug) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const detail of details) {
+    const urn = detail["*profileMention"];
+    if (typeof urn !== "string") continue;
+    const mention = profiles.get(urn);
+    if (mention && mention.slug !== authorSlug)
+      bySlug.set(mention.slug, mention);
+  }
+  return [...bySlug.values()];
+}
+function hashtagsFrom(details) {
+  const tags = [];
+  for (const detail of details) {
+    const urn = detail["*hashtag"];
+    const tag = typeof urn === "string" ? urn.match(/\(([^,]+),/)?.[1] : void 0;
+    if (tag) tags.push(`#${tag}`);
+  }
+  return [...new Set(tags)];
+}
+function linksFrom(details) {
+  const links2 = details.map((detail) => asObject(detail.textLink)?.url).filter((url) => typeof url === "string");
+  return dedupeLinks(links2);
+}
+function collectVoyagerAttributes(update3, profiles, authorSlug) {
+  const details = attributeDetails(update3);
+  return {
+    mentions: mentionsFrom(details, profiles, authorSlug),
+    hashtags: hashtagsFrom(details),
+    links: linksFrom(details)
+  };
+}
+
+// src/commands/netcap/resolveVoyagerAuthor.ts
+var profileUrl2 = (slug) => `https://www.linkedin.com/in/${slug}/`;
+function profileSlug(actor) {
+  const target = asObject(actor?.navigationContext)?.actionTarget;
+  if (typeof target !== "string") return void 0;
+  return target.match(/\/in\/([^/?]+)/)?.[1];
+}
+function resolveVoyagerAuthor(update3) {
+  const actor = asObject(update3.actor);
+  const slug = profileSlug(actor);
+  if (!slug) return void 0;
+  const name = asObject(actor?.name)?.text;
+  const mention = { slug, url: profileUrl2(slug) };
+  if (typeof name === "string" && name.trim()) mention.name = name.trim();
+  return mention;
+}
+
+// src/commands/netcap/buildVoyagerPost.ts
+function commentaryText(update3) {
+  const body = asObject(asObject(update3.commentary)?.text)?.text;
+  return typeof body === "string" && body.trim() ? body.trim() : void 0;
+}
+function activityUrnOf(update3) {
+  const urn = asObject(update3.metadata)?.backendUrn;
+  return typeof urn === "string" ? urn : void 0;
+}
+function buildVoyagerPost(update3, profiles) {
+  const text5 = commentaryText(update3);
+  if (!text5) return void 0;
+  const author = resolveVoyagerAuthor(update3);
+  const { mentions, hashtags, links: links2 } = collectVoyagerAttributes(
+    update3,
+    profiles,
+    author?.slug
+  );
+  const activityUrn = activityUrnOf(update3);
+  return {
+    text: text5,
+    markdown: linkifyMentions(text5, mentions),
+    mentions,
+    hashtags,
+    links: links2,
+    relatedPosts: activityUrn ? [activityUrn] : [],
+    activityUrn,
+    postedAt: activityUrnDate(activityUrn),
+    author
+  };
+}
+
+// src/commands/netcap/voyagerProfileMentions.ts
+var PROFILE_TYPE = "com.linkedin.voyager.dash.identity.profile.Profile";
+var profileUrl3 = (slug) => `https://www.linkedin.com/in/${slug}/`;
+function profileName(o) {
+  return [o.firstName, o.lastName].filter((s) => typeof s === "string" && s.length > 0).join(" ");
+}
+function voyagerProfileMentions(included) {
+  const map = /* @__PURE__ */ new Map();
+  for (const o of included) {
+    const urn = o.entityUrn;
+    const slug = o.publicIdentifier;
+    if (o.$type !== PROFILE_TYPE) continue;
+    if (typeof urn !== "string" || typeof slug !== "string") continue;
+    const name = profileName(o);
+    const url = profileUrl3(slug);
+    map.set(urn, name ? { slug, name, url } : { slug, url });
+  }
+  return map;
+}
+
+// src/commands/netcap/extractVoyagerPosts.ts
+function includedObjects(root) {
+  const included = root.included;
+  if (!Array.isArray(included)) return [];
+  return included.map((item) => asObject(item)).filter((o) => o !== void 0);
+}
+function elementUrns(root) {
+  const data = asObject(asObject(root.data)?.data);
+  if (!data) return [];
+  for (const value of Object.values(data)) {
+    const elements = asObject(value)?.["*elements"];
+    if (Array.isArray(elements))
+      return elements.filter((e) => typeof e === "string");
+  }
+  return [];
+}
+function extractVoyagerPosts(body) {
+  let root;
+  try {
+    root = JSON.parse(body);
+  } catch {
+    return [];
+  }
+  const rootObj = asObject(root);
+  if (!rootObj) return [];
+  const included = includedObjects(rootObj);
+  const byUrn = /* @__PURE__ */ new Map();
+  for (const o of included) {
+    if (typeof o.entityUrn === "string") byUrn.set(o.entityUrn, o);
+  }
+  const profiles = voyagerProfileMentions(included);
+  const posts = [];
+  for (const ref of elementUrns(rootObj)) {
+    const update3 = byUrn.get(ref);
+    if (!update3) continue;
+    const post = buildVoyagerPost(update3, profiles);
+    if (post) posts.push(post);
+  }
+  return posts;
+}
+
+// src/commands/netcap/extractPostsFromCapture.ts
+function captureEntries(captureFile) {
+  const lines = readFileSync30(captureFile, "utf8").split("\n").filter(Boolean);
+  const entries = [];
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof entry.url !== "string" || typeof entry.responseBody !== "string")
+      continue;
+    entries.push({ url: entry.url, responseBody: entry.responseBody });
+  }
+  return entries;
+}
+function dedupeByActivity(posts) {
+  const byUrn = /* @__PURE__ */ new Map();
+  const noUrn = [];
+  for (const post of posts) {
+    if (!post.activityUrn) {
+      noUrn.push(post);
+      continue;
+    }
+    const existing = byUrn.get(post.activityUrn);
+    if (!existing || post.text.length > existing.text.length)
+      byUrn.set(post.activityUrn, post);
+  }
+  return [...byUrn.values(), ...noUrn];
+}
+function extractPostsFromCapture(captureFile) {
+  const entries = captureEntries(captureFile);
+  const rscBodies = entries.filter((e) => /rsc-action/.test(e.url)).map((e) => e.responseBody);
+  const voyagerBodies = entries.filter((e) => /voyagerFeedDashProfileUpdates/.test(e.url)).map((e) => e.responseBody);
+  const author = rscBodies.map(findAuthorSlug).find(Boolean);
+  const all = [
+    ...rscBodies.flatMap((body) => extractLinkedInPosts(body, author)),
+    ...voyagerBodies.flatMap(extractVoyagerPosts)
+  ];
+  return dedupeByActivity(all);
+}
+
+// src/commands/netcap/netcapExtract.ts
+function netcapExtract(file) {
+  const captureFile = file ?? defaultCapturePath();
+  const posts = extractPostsFromCapture(captureFile);
+  const outFile = join38(captureFile, "..", "posts.json");
+  writeFileSync26(outFile, `${JSON.stringify(posts, null, 2)}
+`);
+  console.log(
+    chalk125.green(`extracted ${posts.length} posts`),
+    chalk125.dim(`-> ${outFile}`)
+  );
+}
+
 // src/commands/registerNetcap.ts
 function registerNetcap(program2) {
-  program2.command("netcap").description(
+  const command = program2.command("netcap").description(
     "Start a local receiver that captures browser network traffic (fetch/XHR) to a JSONL file via the netcap browser extension"
-  ).option("-p, --port <port>", "Port to listen on", "8723").action((options2) => netcap(options2));
+  ).option("-p, --port <port>", "Port to listen on", "8723").option(
+    "-o, --out <dir>",
+    "Directory to write the capture file into (default ~/.assist/netcap)"
+  ).option(
+    "-f, --filter <pattern>",
+    "Only forward requests whose URL contains this substring"
+  ).action((options2) => netcap(options2));
+  command.command("extract [file]").description(
+    "Extract LinkedIn posts (text, author, mentions, links) from a netcap capture file to posts.json"
+  ).action((file) => netcapExtract(file));
 }
 
 // src/commands/news/add/index.ts
-import chalk125 from "chalk";
+import chalk126 from "chalk";
 import enquirer8 from "enquirer";
 async function add2(url) {
   if (!url) {
@@ -11543,10 +12022,10 @@ async function add2(url) {
   const { orm } = await getReady();
   const added = await addFeed(orm, url);
   if (!added) {
-    console.log(chalk125.yellow("Feed already exists"));
+    console.log(chalk126.yellow("Feed already exists"));
     return;
   }
-  console.log(chalk125.green(`Added feed: ${url}`));
+  console.log(chalk126.green(`Added feed: ${url}`));
 }
 
 // src/commands/registerNews.ts
@@ -11556,7 +12035,7 @@ function registerNews(program2) {
 }
 
 // src/commands/prompts/printPromptsTable.ts
-import chalk126 from "chalk";
+import chalk127 from "chalk";
 function truncate(str, max) {
   if (str.length <= max) return str;
   return `${str.slice(0, max - 1)}\u2026`;
@@ -11574,14 +12053,14 @@ function printPromptsTable(rows) {
     "Command".padEnd(commandWidth),
     "Repos"
   ].join("  ");
-  console.log(chalk126.dim(header));
-  console.log(chalk126.dim("-".repeat(header.length)));
+  console.log(chalk127.dim(header));
+  console.log(chalk127.dim("-".repeat(header.length)));
   for (const row of rows) {
     const count6 = String(row.count).padStart(countWidth);
     const tool = row.tool.padEnd(toolWidth);
     const command = truncate(row.command, 60).padEnd(commandWidth);
     console.log(
-      `${chalk126.yellow(count6)}  ${tool}  ${command}  ${chalk126.dim(row.repos)}`
+      `${chalk127.yellow(count6)}  ${tool}  ${command}  ${chalk127.dim(row.repos)}`
     );
   }
 }
@@ -11725,15 +12204,15 @@ function postComment(vars) {
   const stdout = startLine === void 0 ? runGhGraphql(MUTATION_SINGLE, base) : runGhGraphql(MUTATION_MULTI, { ...base, startLine });
   assertThreadCreated(stdout);
 }
-function comment2(path58, line, body, startLine) {
+function comment2(path57, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path58, line, startLine });
+    postComment({ prId, body, path: path57, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path58}:${range}`);
+    console.log(`Added review comment on ${path57}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -11925,27 +12404,27 @@ function edit(options2) {
 }
 
 // src/commands/prs/fixed.ts
-import { execSync as execSync33 } from "child_process";
+import { execSync as execSync34 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
-import { execSync as execSync32 } from "child_process";
-import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync26 } from "fs";
+import { execSync as execSync33 } from "child_process";
+import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync27 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join38 } from "path";
+import { join as join40 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync33, readFileSync as readFileSync30, unlinkSync as unlinkSync9 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync31, unlinkSync as unlinkSync9 } from "fs";
+import { join as join39 } from "path";
 import { parse as parse2 } from "yaml";
 function getCachePath(prNumber) {
-  return join37(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join39(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
   if (!existsSync33(cachePath)) {
     return null;
   }
-  const content = readFileSync30(cachePath, "utf8");
+  const content = readFileSync31(cachePath, "utf8");
   return parse2(content);
 }
 function deleteCommentsCache(prNumber) {
@@ -11956,19 +12435,22 @@ function deleteCommentsCache(prNumber) {
   }
 }
 
-// src/commands/prs/resolveCommentWithReply.ts
+// src/commands/prs/replyToComment.ts
+import { execSync as execSync32 } from "child_process";
 function replyToComment(org, repo, prNumber, commentId, message) {
   execSync32(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/comments -f body="${message.replace(/"/g, String.raw`\"`)}" -F in_reply_to=${commentId}`,
     { stdio: ["inherit", "pipe", "inherit"] }
   );
 }
+
+// src/commands/prs/resolveCommentWithReply.ts
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join38(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
-  writeFileSync26(queryFile, mutation);
+  const queryFile = join40(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
+  writeFileSync27(queryFile, mutation);
   try {
-    execSync32(
+    execSync33(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
       { stdio: ["inherit", "pipe", "inherit"] }
     );
@@ -12020,7 +12502,7 @@ function resolveCommentWithReply(commentId, message) {
 // src/commands/prs/fixed.ts
 function verifySha(sha) {
   try {
-    return execSync33(`git rev-parse --verify ${sha}`, {
+    return execSync34(`git rev-parse --verify ${sha}`, {
       encoding: "utf8"
     }).trim();
   } catch {
@@ -12034,7 +12516,7 @@ function fixed(commentId, sha) {
     const { org, repo } = getRepoInfo();
     const repoUrl = `https://github.com/${org}/${repo}`;
     const message = `Fixed in [${fullSha}](${repoUrl}/commit/${fullSha})`;
-    execSync33("git push", { stdio: "inherit" });
+    execSync34("git push", { stdio: "inherit" });
     resolveCommentWithReply(commentId, message);
   } catch (error) {
     if (isGhNotInstalled(error)) {
@@ -12047,21 +12529,21 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments/index.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync13, writeFileSync as writeFileSync28 } from "fs";
-import { join as join40 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync13, writeFileSync as writeFileSync29 } from "fs";
+import { join as join42 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
-import { execSync as execSync34 } from "child_process";
-import { unlinkSync as unlinkSync11, writeFileSync as writeFileSync27 } from "fs";
+import { execSync as execSync35 } from "child_process";
+import { unlinkSync as unlinkSync11, writeFileSync as writeFileSync28 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join39 } from "path";
+import { join as join41 } 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 = join39(tmpdir6(), `gh-query-${Date.now()}.graphql`);
-  writeFileSync27(queryFile, THREAD_QUERY);
+  const queryFile = join41(tmpdir6(), `gh-query-${Date.now()}.graphql`);
+  writeFileSync28(queryFile, THREAD_QUERY);
   try {
-    const result = execSync34(
+    const result = execSync35(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
       { encoding: "utf8" }
     );
@@ -12083,9 +12565,9 @@ function fetchThreadIds(org, repo, prNumber) {
 }
 
 // src/commands/prs/listComments/fetchReviewComments.ts
-import { execSync as execSync35 } from "child_process";
+import { execSync as execSync36 } from "child_process";
 function fetchJson(endpoint) {
-  const result = execSync35(`gh api --paginate ${endpoint}`, {
+  const result = execSync36(`gh api --paginate ${endpoint}`, {
     encoding: "utf8"
   });
   if (!result.trim()) return [];
@@ -12127,20 +12609,20 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 }
 
 // src/commands/prs/listComments/printComments.ts
-import chalk127 from "chalk";
+import chalk128 from "chalk";
 function formatForHuman(comment3) {
   if (comment3.type === "review") {
-    const stateColor = comment3.state === "APPROVED" ? chalk127.green : comment3.state === "CHANGES_REQUESTED" ? chalk127.red : chalk127.yellow;
+    const stateColor = comment3.state === "APPROVED" ? chalk128.green : comment3.state === "CHANGES_REQUESTED" ? chalk128.red : chalk128.yellow;
     return [
-      `${chalk127.cyan("Review")} by ${chalk127.bold(comment3.user)} ${stateColor(`[${comment3.state}]`)}`,
+      `${chalk128.cyan("Review")} by ${chalk128.bold(comment3.user)} ${stateColor(`[${comment3.state}]`)}`,
       comment3.body,
       ""
     ].join("\n");
   }
   const location = comment3.line ? `:${comment3.line}` : "";
   return [
-    `${chalk127.cyan("Line comment")} by ${chalk127.bold(comment3.user)} on ${chalk127.dim(`${comment3.path}${location}`)}`,
-    chalk127.dim(comment3.diff_hunk.split("\n").slice(-3).join("\n")),
+    `${chalk128.cyan("Line comment")} by ${chalk128.bold(comment3.user)} on ${chalk128.dim(`${comment3.path}${location}`)}`,
+    chalk128.dim(comment3.diff_hunk.split("\n").slice(-3).join("\n")),
     comment3.body,
     ""
   ].join("\n");
@@ -12172,7 +12654,7 @@ function printComments2(result) {
 
 // src/commands/prs/listComments/index.ts
 function writeCommentsCache(prNumber, comments3) {
-  const assistDir = join40(process.cwd(), ".assist");
+  const assistDir = join42(process.cwd(), ".assist");
   if (!existsSync34(assistDir)) {
     mkdirSync13(assistDir, { recursive: true });
   }
@@ -12181,8 +12663,8 @@ function writeCommentsCache(prNumber, comments3) {
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  const cachePath = join40(assistDir, `pr-${prNumber}-comments.yaml`);
-  writeFileSync28(cachePath, stringify(cacheData));
+  const cachePath = join42(assistDir, `pr-${prNumber}-comments.yaml`);
+  writeFileSync29(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
   if (isGhNotInstalled(error)) {
@@ -12214,7 +12696,7 @@ async function listComments() {
     ];
     updateCache(prNumber, allComments);
     const hasLineComments = allComments.some((c) => c.type === "line");
-    const cachePath = hasLineComments ? join40(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
+    const cachePath = hasLineComments ? join42(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
     return { comments: allComments, cachePath };
   } catch (error) {
     const handled = handleKnownErrors(error);
@@ -12224,19 +12706,19 @@ async function listComments() {
 }
 
 // src/commands/prs/prs/index.ts
-import { execSync as execSync36 } from "child_process";
+import { execSync as execSync37 } from "child_process";
 
 // src/commands/prs/prs/displayPaginated/index.ts
 import enquirer9 from "enquirer";
 
 // src/commands/prs/prs/displayPaginated/printPr.ts
-import chalk128 from "chalk";
+import chalk129 from "chalk";
 var STATUS_MAP = {
-  MERGED: (pr) => pr.mergedAt ? { label: chalk128.magenta("merged"), date: pr.mergedAt } : null,
-  CLOSED: (pr) => pr.closedAt ? { label: chalk128.red("closed"), date: pr.closedAt } : null
+  MERGED: (pr) => pr.mergedAt ? { label: chalk129.magenta("merged"), date: pr.mergedAt } : null,
+  CLOSED: (pr) => pr.closedAt ? { label: chalk129.red("closed"), date: pr.closedAt } : null
 };
 function defaultStatus(pr) {
-  return { label: chalk128.green("opened"), date: pr.createdAt };
+  return { label: chalk129.green("opened"), date: pr.createdAt };
 }
 function getStatus2(pr) {
   return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -12245,11 +12727,11 @@ function formatDate(dateStr) {
   return new Date(dateStr).toISOString().split("T")[0];
 }
 function formatPrHeader(pr, status2) {
-  return `${chalk128.cyan(`#${pr.number}`)} ${pr.title} ${chalk128.dim(`(${pr.author.login},`)} ${status2.label} ${chalk128.dim(`${formatDate(status2.date)})`)}`;
+  return `${chalk129.cyan(`#${pr.number}`)} ${pr.title} ${chalk129.dim(`(${pr.author.login},`)} ${status2.label} ${chalk129.dim(`${formatDate(status2.date)})`)}`;
 }
 function logPrDetails(pr) {
   console.log(
-    chalk128.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
+    chalk129.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
   console.log();
 }
@@ -12331,7 +12813,7 @@ async function prs(options2) {
   const state = options2.open ? "open" : options2.closed ? "closed" : "all";
   try {
     const { org, repo } = getRepoInfo();
-    const result = execSync36(
+    const result = execSync37(
       `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100 -R ${org}/${repo}`,
       { encoding: "utf8" }
     );
@@ -12354,7 +12836,7 @@ async function prs(options2) {
 }
 
 // src/commands/prs/raise.ts
-import { execSync as execSync37 } from "child_process";
+import { execSync as execSync38 } from "child_process";
 
 // src/commands/prs/buildCreateArgs.ts
 function buildCreateArgs(title, body, options2) {
@@ -12414,14 +12896,39 @@ function raise(options2) {
     `--body ${shellQuote(body)}`
   ] : buildCreateArgs(options2.title, body, options2);
   try {
-    execSync37(args.join(" "), { stdio: "inherit" });
+    execSync38(args.join(" "), { stdio: "inherit" });
   } catch {
     process.exit(1);
   }
 }
 
+// src/commands/prs/reply.ts
+function validateBody2(body) {
+  const lowerBody = body.toLowerCase();
+  if (lowerBody.includes("claude") || lowerBody.includes("opus")) {
+    console.error('Error: Body must not contain "claude" or "opus"');
+    process.exit(1);
+  }
+}
+function reply(commentId, body) {
+  validateBody2(body);
+  try {
+    const prNumber = getCurrentPrNumber();
+    const { org, repo } = getRepoInfo();
+    replyToComment(org, repo, prNumber, commentId, body);
+    console.log("Reply posted successfully.");
+  } catch (error) {
+    if (isGhNotInstalled(error)) {
+      console.error("Error: GitHub CLI (gh) is not installed.");
+      console.error("Install it from https://cli.github.com/");
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
 // src/commands/prs/wontfix.ts
-import { execSync as execSync38 } from "child_process";
+import { execSync as execSync39 } from "child_process";
 function validateReason(reason) {
   const lowerReason = reason.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
@@ -12438,7 +12945,7 @@ function validateShaReferences(reason) {
   const invalidShas = [];
   for (const sha of shas) {
     try {
-      execSync38(`git cat-file -t ${sha}`, { stdio: "pipe" });
+      execSync39(`git cat-file -t ${sha}`, { stdio: "pipe" });
     } catch {
       invalidShas.push(sha);
     }
@@ -12522,16 +13029,19 @@ function registerPrs(program2) {
   prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason) => {
     wontfix(Number.parseInt(commentId, 10), reason);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path58, line, body) => {
-    comment2(path58, Number.parseInt(line, 10), body);
+  prsCommand.command("reply <comment-id> <body>").description("Reply to a comment thread without resolving it").action((commentId, body) => {
+    reply(Number.parseInt(commentId, 10), body);
+  });
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path57, line, body) => {
+    comment2(path57, Number.parseInt(line, 10), body);
   });
 }
 
 // src/commands/ravendb/ravendbAuth.ts
-import chalk134 from "chalk";
+import chalk135 from "chalk";
 
 // src/shared/createConnectionAuth.ts
-import chalk129 from "chalk";
+import chalk130 from "chalk";
 function listConnections(connections, format2) {
   if (connections.length === 0) {
     console.log("No connections configured.");
@@ -12544,7 +13054,7 @@ function listConnections(connections, format2) {
 function removeConnection(connections, name, save) {
   const filtered = connections.filter((c) => c.name !== name);
   if (filtered.length === connections.length) {
-    console.error(chalk129.red(`Connection "${name}" not found.`));
+    console.error(chalk130.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   save(filtered);
@@ -12590,17 +13100,17 @@ function saveConnections(connections) {
 }
 
 // src/commands/ravendb/promptConnection.ts
-import chalk132 from "chalk";
+import chalk133 from "chalk";
 
 // src/commands/ravendb/selectOpSecret.ts
-import chalk131 from "chalk";
+import chalk132 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
-import { execSync as execSync39 } from "child_process";
-import chalk130 from "chalk";
+import { execSync as execSync40 } from "child_process";
+import chalk131 from "chalk";
 function opExec(args) {
-  return execSync39(`op ${args}`, {
+  return execSync40(`op ${args}`, {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "pipe"]
   }).trim();
@@ -12611,7 +13121,7 @@ function searchItems(search2) {
     items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
-      chalk130.red(
+      chalk131.red(
         "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
       )
     );
@@ -12625,7 +13135,7 @@ function getItemFields(itemId) {
     const item = JSON.parse(opExec(`item get "${itemId}" --format=json`));
     return item.fields.filter((f) => f.reference && f.label);
   } catch {
-    console.error(chalk130.red("Failed to get item details from 1Password."));
+    console.error(chalk131.red("Failed to get item details from 1Password."));
     process.exit(1);
   }
 }
@@ -12644,7 +13154,7 @@ async function selectOpSecret(searchTerm) {
   }).run();
   const items2 = searchItems(search2);
   if (items2.length === 0) {
-    console.error(chalk131.red(`No items found matching "${search2}".`));
+    console.error(chalk132.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId = await selectOne(
@@ -12653,7 +13163,7 @@ async function selectOpSecret(searchTerm) {
   );
   const fields = getItemFields(itemId);
   if (fields.length === 0) {
-    console.error(chalk131.red("No fields with references found on this item."));
+    console.error(chalk132.red("No fields with references found on this item."));
     process.exit(1);
   }
   const ref = await selectOne(
@@ -12667,7 +13177,7 @@ async function selectOpSecret(searchTerm) {
 async function promptConnection(existingNames) {
   const name = await promptInput("name", "Connection name:");
   if (existingNames.includes(name)) {
-    console.error(chalk132.red(`Connection "${name}" already exists.`));
+    console.error(chalk133.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput(
@@ -12676,22 +13186,22 @@ async function promptConnection(existingNames) {
   );
   const database = await promptInput("database", "Database name:");
   if (!name || !url || !database) {
-    console.error(chalk132.red("All fields are required."));
+    console.error(chalk133.red("All fields are required."));
     process.exit(1);
   }
   const apiKeyRef = await selectOpSecret();
-  console.log(chalk132.dim(`Using: ${apiKeyRef}`));
+  console.log(chalk133.dim(`Using: ${apiKeyRef}`));
   return { name, url, database, apiKeyRef };
 }
 
 // src/commands/ravendb/ravendbSetConnection.ts
-import chalk133 from "chalk";
+import chalk134 from "chalk";
 function ravendbSetConnection(name) {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb ?? {};
   const connections = ravendb.connections ?? [];
   if (!connections.some((c) => c.name === name)) {
-    console.error(chalk133.red(`Connection "${name}" not found.`));
+    console.error(chalk134.red(`Connection "${name}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -12707,16 +13217,16 @@ function ravendbSetConnection(name) {
 var ravendbAuth = createConnectionAuth({
   load: loadConnections,
   save: saveConnections,
-  format: (c) => `${chalk134.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
+  format: (c) => `${chalk135.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
   promptNew: promptConnection,
   onFirst: (c) => ravendbSetConnection(c.name)
 });
 
 // src/commands/ravendb/ravendbCollections.ts
-import chalk138 from "chalk";
+import chalk139 from "chalk";
 
 // src/commands/ravendb/ravenFetch.ts
-import chalk136 from "chalk";
+import chalk137 from "chalk";
 
 // src/commands/ravendb/getAccessToken.ts
 var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -12752,21 +13262,21 @@ ${errorText}`
 }
 
 // src/commands/ravendb/resolveOpSecret.ts
-import { execSync as execSync40 } from "child_process";
-import chalk135 from "chalk";
+import { execSync as execSync41 } from "child_process";
+import chalk136 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
-    console.error(chalk135.red(`Invalid secret reference: must start with op://`));
+    console.error(chalk136.red(`Invalid secret reference: must start with op://`));
     process.exit(1);
   }
   try {
-    return execSync40(`op read "${reference}"`, {
+    return execSync41(`op read "${reference}"`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
   } catch {
     console.error(
-      chalk135.red(
+      chalk136.red(
         "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
       )
     );
@@ -12775,10 +13285,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path58) {
+async function ravenFetch(connection, path57) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path58}`;
+  const url = `${connection.url}${path57}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -12793,7 +13303,7 @@ async function ravenFetch(connection, path58) {
   if (!response.ok) {
     const body = await response.text();
     console.error(
-      chalk136.red(`RavenDB error: ${response.status} ${response.statusText}`)
+      chalk137.red(`RavenDB error: ${response.status} ${response.statusText}`)
     );
     console.error(body.substring(0, 500));
     process.exit(1);
@@ -12802,7 +13312,7 @@ async function ravenFetch(connection, path58) {
 }
 
 // src/commands/ravendb/resolveConnection.ts
-import chalk137 from "chalk";
+import chalk138 from "chalk";
 function loadRavendb() {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb;
@@ -12816,7 +13326,7 @@ function resolveConnection(name) {
   const connectionName = name ?? defaultConnection;
   if (!connectionName) {
     console.error(
-      chalk137.red(
+      chalk138.red(
         "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
       )
     );
@@ -12824,7 +13334,7 @@ function resolveConnection(name) {
   }
   const connection = connections.find((c) => c.name === connectionName);
   if (!connection) {
-    console.error(chalk137.red(`Connection "${connectionName}" not found.`));
+    console.error(chalk138.red(`Connection "${connectionName}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -12855,29 +13365,29 @@ async function ravendbCollections(connectionName) {
     return;
   }
   for (const c of collections) {
-    console.log(`${chalk138.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+    console.log(`${chalk139.bold(c.Name)}  ${c.CountOfDocuments} docs`);
   }
 }
 
 // src/commands/ravendb/ravendbQuery.ts
-import chalk140 from "chalk";
+import chalk141 from "chalk";
 
 // src/commands/ravendb/fetchAllPages.ts
-import chalk139 from "chalk";
+import chalk140 from "chalk";
 
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path58;
+  let path57;
   if (opts.collection) {
-    path58 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path57 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path58 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path57 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path58 += `&query=${encodeURIComponent(opts.query)}`;
+    path57 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path58;
+  return path57;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -12886,7 +13396,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path58 = buildQueryPath({
+    const path57 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -12894,14 +13404,14 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path58);
+    const data = await ravenFetch(connection, path57);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
     allResults.push(...results);
     start3 += results.length;
     process.stderr.write(
-      `\r${chalk139.dim(`Fetched ${allResults.length}/${totalResults}`)}`
+      `\r${chalk140.dim(`Fetched ${allResults.length}/${totalResults}`)}`
     );
     if (start3 >= totalResults) break;
     if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
@@ -12916,7 +13426,7 @@ async function fetchAllPages(connection, opts) {
 async function ravendbQuery(connectionName, collection, options2) {
   const resolved = resolveArgs(connectionName, collection);
   if (!resolved.collection && !options2.query) {
-    console.error(chalk140.red("Provide a collection name or --query filter."));
+    console.error(chalk141.red("Provide a collection name or --query filter."));
     process.exit(1);
   }
   const { collection: col } = resolved;
@@ -12954,7 +13464,7 @@ import { spawn as spawn5 } from "child_process";
 import * as path28 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk141 from "chalk";
+import chalk142 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -12963,43 +13473,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk141.red(`
+  console.error(chalk142.red(`
 Refactor check failed:
 `));
-  console.error(chalk141.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk142.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk141.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk142.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk141.yellow(
+    chalk142.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk141.gray(`    assist refactor ignore <file>
+  console.error(chalk142.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk141.cyan(`
+    console.error(chalk142.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk141.cyan(
+      chalk142.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk141.cyan(
+      chalk142.cyan(
         `  1. Keep related logic together: If the extracted code is tightly coupled to the
      original file's domain, create a new folder containing both the original and extracted files.
 `
       )
     );
     console.error(
-      chalk141.cyan(
+      chalk142.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -13009,7 +13519,7 @@ Refactor check failed:
 }
 
 // src/commands/refactor/check/getViolations/index.ts
-import { execSync as execSync41 } from "child_process";
+import { execSync as execSync42 } from "child_process";
 import fs20 from "fs";
 import { minimatch as minimatch5 } from "minimatch";
 
@@ -13059,7 +13569,7 @@ function getGitFiles(options2) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options2.staged || options2.modified) {
-    const staged = execSync41("git diff --cached --name-only", {
+    const staged = execSync42("git diff --cached --name-only", {
       encoding: "utf8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -13067,7 +13577,7 @@ function getGitFiles(options2) {
     }
   }
   if (options2.unstaged || options2.modified) {
-    const unstaged = execSync41("git diff --name-only", { encoding: "utf8" });
+    const unstaged = execSync42("git diff --name-only", { encoding: "utf8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -13155,7 +13665,7 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/extract/index.ts
 import path35 from "path";
-import chalk144 from "chalk";
+import chalk145 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
@@ -13730,23 +14240,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 
 // src/commands/refactor/extract/displayPlan.ts
 import path32 from "path";
-import chalk142 from "chalk";
+import chalk143 from "chalk";
 function section(title) {
   return `
-  ${chalk142.cyan(title)}`;
+  ${chalk143.cyan(title)}`;
 }
 function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
     const rel = path32.relative(cwd, imp.file.getFilePath());
-    console.log(`    ${chalk142.dim(rel)}: \u2192 import from "${imp.relPath}"`);
+    console.log(`    ${chalk143.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
 function displayPlan(functionName, relDest, plan2, cwd) {
-  console.log(chalk142.bold(`Extract: ${functionName} \u2192 ${relDest}
+  console.log(chalk143.bold(`Extract: ${functionName} \u2192 ${relDest}
 `));
-  console.log(`  ${chalk142.cyan("Functions to move:")}`);
+  console.log(`  ${chalk143.cyan("Functions to move:")}`);
   for (const name of plan2.extractedNames) {
     console.log(`    ${name}`);
   }
@@ -13780,7 +14290,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import path34 from "path";
-import chalk143 from "chalk";
+import chalk144 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
@@ -13840,7 +14350,7 @@ function loadProjectFile(file) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk143.red(`File not found in project: ${file}`));
+    console.log(chalk144.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   return { project, sourceFile };
@@ -13863,19 +14373,19 @@ async function extract(file, functionName, destination, options2 = {}) {
   displayPlan(functionName, relDest, plan2, cwd);
   if (options2.apply) {
     await applyExtraction(functionName, sourceFile, destPath, plan2, project);
-    console.log(chalk144.green("\nExtraction complete"));
+    console.log(chalk145.green("\nExtraction complete"));
   } else {
-    console.log(chalk144.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk145.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/ignore.ts
 import fs22 from "fs";
-import chalk145 from "chalk";
+import chalk146 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
   if (!fs22.existsSync(file)) {
-    console.error(chalk145.red(`Error: File does not exist: ${file}`));
+    console.error(chalk146.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs22.readFileSync(file, "utf8");
@@ -13891,7 +14401,7 @@ function ignore(file) {
     fs22.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk145.green(
+    chalk146.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -13900,12 +14410,12 @@ function ignore(file) {
 // src/commands/refactor/rename/index.ts
 import fs25 from "fs";
 import path40 from "path";
-import chalk148 from "chalk";
+import chalk149 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs24 from "fs";
 import path37 from "path";
-import chalk146 from "chalk";
+import chalk147 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
 import path36 from "path";
@@ -14010,13 +14520,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs24.writeFileSync(file, content, "utf8");
-    console.log(chalk146.cyan(`  Updated imports in ${path37.relative(cwd, file)}`));
+    console.log(chalk147.cyan(`  Updated imports in ${path37.relative(cwd, file)}`));
   }
   const destDir = path37.dirname(destPath);
   if (!fs24.existsSync(destDir)) fs24.mkdirSync(destDir, { recursive: true });
   fs24.renameSync(sourcePath, destPath);
   console.log(
-    chalk146.white(
+    chalk147.white(
       `  Moved ${path37.relative(cwd, sourcePath)} \u2192 ${path37.relative(cwd, destPath)}`
     )
   );
@@ -14103,16 +14613,16 @@ function computeRenameRewrites(sourcePath, destPath) {
 
 // src/commands/refactor/rename/printRenamePreview.ts
 import path39 from "path";
-import chalk147 from "chalk";
+import chalk148 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
-      chalk147.dim(
+      chalk148.dim(
         `  ${path39.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
-  console.log(chalk147.dim("Dry run. Use --apply to execute."));
+  console.log(chalk148.dim("Dry run. Use --apply to execute."));
 }
 
 // src/commands/refactor/rename/index.ts
@@ -14123,20 +14633,20 @@ async function rename(source, destination, options2 = {}) {
   const relSource = path40.relative(cwd, sourcePath);
   const relDest = path40.relative(cwd, destPath);
   if (!fs25.existsSync(sourcePath)) {
-    console.log(chalk148.red(`File not found: ${source}`));
+    console.log(chalk149.red(`File not found: ${source}`));
     process.exit(1);
   }
   if (destPath !== sourcePath && fs25.existsSync(destPath)) {
-    console.log(chalk148.red(`Destination already exists: ${destination}`));
+    console.log(chalk149.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
-  console.log(chalk148.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  console.log(chalk148.dim("Loading project..."));
-  console.log(chalk148.dim("Scanning imports across the project..."));
+  console.log(chalk149.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk149.dim("Loading project..."));
+  console.log(chalk149.dim("Scanning imports across the project..."));
   const rewrites = computeRenameRewrites(sourcePath, destPath);
   const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
   console.log(
-    chalk148.dim(
+    chalk149.dim(
       `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
     )
   );
@@ -14145,11 +14655,11 @@ async function rename(source, destination, options2 = {}) {
     return;
   }
   applyRename(rewrites, sourcePath, destPath, cwd);
-  console.log(chalk148.green("Done"));
+  console.log(chalk149.green("Done"));
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import chalk149 from "chalk";
+import chalk150 from "chalk";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
 import { SyntaxKind as SyntaxKind14 } from "ts-morph";
@@ -14195,33 +14705,33 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const { project, sourceFile } = loadProjectFile(file);
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk149.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk150.red(`Symbol "${oldName}" not found in ${file}`));
     process.exit(1);
   }
   const grouped = groupReferences(symbol, cwd);
   const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
   console.log(
-    chalk149.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk150.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines] of grouped) {
     console.log(
-      `  ${chalk149.dim(refFile)}: lines ${chalk149.cyan(lines.join(", "))}`
+      `  ${chalk150.dim(refFile)}: lines ${chalk150.cyan(lines.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk149.green(`
+    console.log(chalk150.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk149.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk150.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
 import path48 from "path";
-import chalk152 from "chalk";
+import chalk153 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
 import path42 from "path";
@@ -14300,50 +14810,50 @@ function clusterFiles(graph) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path44 from "path";
-import chalk150 from "chalk";
+import chalk151 from "chalk";
 function relPath(filePath) {
   return path44.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk150.bold("\nFile moves:"));
+  console.log(chalk151.bold("\nFile moves:"));
   for (const move of plan2.moves) {
     console.log(
-      `  ${chalk150.red(relPath(move.from))} \u2192 ${chalk150.green(relPath(move.to))}`
+      `  ${chalk151.red(relPath(move.from))} \u2192 ${chalk151.green(relPath(move.to))}`
     );
-    console.log(chalk150.dim(`    ${move.reason}`));
+    console.log(chalk151.dim(`    ${move.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk150.bold(`
+  console.log(chalk151.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk150.cyan(relPath(file))}:`);
+    console.log(`  ${chalk151.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk150.red(`"${oldSpecifier}"`)} \u2192 ${chalk150.green(`"${newSpecifier}"`)}`
+        `    ${chalk151.red(`"${oldSpecifier}"`)} \u2192 ${chalk151.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk150.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk150.yellow(`  ${w}`));
+    console.log(chalk151.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk151.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk150.bold("\nNew directories:"));
+    console.log(chalk151.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk150.green(`  ${dir}/`));
+      console.log(chalk151.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk150.dim(
+    chalk151.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -14353,18 +14863,18 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 // src/commands/refactor/restructure/executePlan.ts
 import fs26 from "fs";
 import path45 from "path";
-import chalk151 from "chalk";
+import chalk152 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs26.writeFileSync(file, content, "utf8");
     console.log(
-      chalk151.cyan(`  Rewrote imports in ${path45.relative(process.cwd(), file)}`)
+      chalk152.cyan(`  Rewrote imports in ${path45.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs26.mkdirSync(dir, { recursive: true });
-    console.log(chalk151.green(`  Created ${path45.relative(process.cwd(), dir)}/`));
+    console.log(chalk152.green(`  Created ${path45.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan2.moves) {
     const targetDir = path45.dirname(move.to);
@@ -14373,7 +14883,7 @@ function executePlan(plan2) {
     }
     fs26.renameSync(move.from, move.to);
     console.log(
-      chalk151.white(
+      chalk152.white(
         `  Moved ${path45.relative(process.cwd(), move.from)} \u2192 ${path45.relative(process.cwd(), move.to)}`
       )
     );
@@ -14388,7 +14898,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs26.rmdirSync(dir);
       console.log(
-        chalk151.dim(
+        chalk152.dim(
           `  Removed empty directory ${path45.relative(process.cwd(), dir)}`
         )
       );
@@ -14521,22 +15031,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk152.yellow("No files found matching pattern"));
+    console.log(chalk153.yellow("No files found matching pattern"));
     return;
   }
   const tsConfigPath = path48.resolve("tsconfig.json");
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk152.green("No restructuring needed"));
+    console.log(chalk153.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk152.bold("\nApplying changes..."));
+    console.log(chalk153.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk152.green("\nRestructuring complete"));
+    console.log(chalk153.green("\nRestructuring complete"));
   } else {
-    console.log(chalk152.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk153.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -14692,9 +15202,9 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 
 // src/commands/review/buildReviewPaths.ts
 import { homedir as homedir13 } from "os";
-import { basename as basename7, join as join41 } from "path";
+import { basename as basename7, join as join43 } from "path";
 function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join41(
+  const reviewDir = join43(
     homedir13(),
     ".assist",
     "reviews",
@@ -14703,17 +15213,17 @@ function buildReviewPaths(repoRoot, key) {
   );
   return {
     reviewDir,
-    requestPath: join41(reviewDir, "request.md"),
-    claudePath: join41(reviewDir, "claude.md"),
-    codexPath: join41(reviewDir, "codex.md"),
-    synthesisPath: join41(reviewDir, "synthesis.md")
+    requestPath: join43(reviewDir, "request.md"),
+    claudePath: join43(reviewDir, "claude.md"),
+    codexPath: join43(reviewDir, "codex.md"),
+    synthesisPath: join43(reviewDir, "synthesis.md")
   };
 }
 
 // src/commands/review/fetchExistingComments.ts
-import { execSync as execSync42 } from "child_process";
+import { execSync as execSync43 } from "child_process";
 function fetchRawComments(org, repo, prNumber) {
-  const out = execSync42(
+  const out = execSync43(
     `gh api --paginate repos/${org}/${repo}/pulls/${prNumber}/comments`,
     { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }
   );
@@ -14744,14 +15254,14 @@ function fetchExistingComments() {
 }
 
 // src/commands/review/gatherContext.ts
-import { execSync as execSync45 } from "child_process";
+import { execSync as execSync46 } from "child_process";
 
 // src/commands/review/fetchPrDiff.ts
-import { execSync as execSync43 } from "child_process";
+import { execSync as execSync44 } from "child_process";
 function fetchPrDiff(prNumber, baseSha, headSha) {
   const { org, repo } = getRepoInfo();
   try {
-    return execSync43(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
+    return execSync44(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
       encoding: "utf8",
       maxBuffer: 256 * 1024 * 1024,
       stdio: ["ignore", "pipe", "pipe"]
@@ -14766,19 +15276,19 @@ function isDiffTooLarge(error) {
 }
 function fetchDiffViaGit(baseSha, headSha) {
   try {
-    execSync43(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
+    execSync44(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
   } catch {
   }
-  return execSync43(`git diff ${baseSha}...${headSha}`, {
+  return execSync44(`git diff ${baseSha}...${headSha}`, {
     encoding: "utf8",
     maxBuffer: 256 * 1024 * 1024
   });
 }
 
 // src/commands/review/fetchPrDiffInfo.ts
-import { execSync as execSync44 } from "child_process";
+import { execSync as execSync45 } from "child_process";
 function getCurrentBranch2() {
-  return execSync44("git rev-parse --abbrev-ref HEAD", {
+  return execSync45("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
 }
@@ -14788,7 +15298,7 @@ function fetchPrDiffInfo() {
   const fields = "number,baseRefName,baseRefOid,headRefName,headRefOid";
   let raw;
   try {
-    raw = execSync44(`gh pr view ${branch} --json ${fields} -R ${org}/${repo}`, {
+    raw = execSync45(`gh pr view ${branch} --json ${fields} -R ${org}/${repo}`, {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -14812,7 +15322,7 @@ function fetchPrDiffInfo() {
 }
 function fetchPrChangedFiles(prNumber) {
   const { org, repo } = getRepoInfo();
-  const out = execSync44(
+  const out = execSync45(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/files --paginate --jq ".[].filename"`,
     {
       encoding: "utf8",
@@ -14824,11 +15334,11 @@ function fetchPrChangedFiles(prNumber) {
 
 // src/commands/review/gatherContext.ts
 function gatherContext() {
-  const branch = execSync45("git rev-parse --abbrev-ref HEAD", {
+  const branch = execSync46("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
-  const sha = execSync45("git rev-parse HEAD", { encoding: "utf8" }).trim();
-  const shortSha = execSync45("git rev-parse --short=7 HEAD", {
+  const sha = execSync46("git rev-parse HEAD", { encoding: "utf8" }).trim();
+  const shortSha = execSync46("git rev-parse --short=7 HEAD", {
     encoding: "utf8"
   }).trim();
   const prInfo = fetchPrDiffInfo();
@@ -14849,7 +15359,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync31 } from "fs";
+import { readFileSync as readFileSync32 } from "fs";
 
 // src/commands/review/parseFindings.ts
 var SEVERITIES = ["blocker", "major", "minor", "nit"];
@@ -15105,18 +15615,18 @@ function partitionFindingsByDiff(findings, index3) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk153 from "chalk";
+import chalk154 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk153.yellow(
+    chalk154.yellow(
       `Skipped ${outOfDiff.length} finding(s) whose lines fall outside the PR diff (GitHub would silently drop these):`
     )
   );
   for (const finding of outOfDiff) {
     const range = finding.startLine !== void 0 ? `${finding.startLine}-${finding.line}` : `${finding.line}`;
     console.warn(
-      `  ${chalk153.yellow("\xB7")} ${finding.title} ${chalk153.dim(
+      `  ${chalk154.yellow("\xB7")} ${finding.title} ${chalk154.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -15135,18 +15645,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk154 from "chalk";
+import chalk155 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk154.yellow(
+    chalk155.yellow(
       `Skipped ${unlocated.length} finding(s) without a parseable file:line:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk154.dim("missing");
+    const where = finding.location || chalk155.dim("missing");
     console.warn(
-      `  ${chalk154.yellow("\xB7")} ${finding.title} ${chalk154.dim(`(${where})`)}`
+      `  ${chalk155.yellow("\xB7")} ${finding.title} ${chalk155.dim(`(${where})`)}`
     );
   }
 }
@@ -15159,7 +15669,7 @@ async function confirmPost(prNumber, count6, options2) {
 async function postReviewToPr(synthesisPath, options2) {
   const prInfo = fetchPrDiffInfo();
   const prNumber = prInfo.prNumber;
-  const markdown = readFileSync31(synthesisPath, "utf8");
+  const markdown = readFileSync32(synthesisPath, "utf8");
   const findings = parseFindings(markdown);
   if (findings.length === 0) {
     console.log("Synthesis contains no findings; nothing to post.");
@@ -15241,16 +15751,16 @@ async function handlePostSynthesis(synthesisPath, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync14, unlinkSync as unlinkSync12, writeFileSync as writeFileSync29 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync14, unlinkSync as unlinkSync12, writeFileSync as writeFileSync30 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path58 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync35(path58)) unlinkSync12(path58);
+  for (const path57 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync35(path57)) unlinkSync12(path57);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
   mkdirSync14(paths.reviewDir, { recursive: true });
   if (force) clearReviewFiles(paths);
-  writeFileSync29(paths.requestPath, requestBody);
+  writeFileSync30(paths.requestPath, requestBody);
 }
 
 // src/commands/review/runApplySession.ts
@@ -15595,7 +16105,7 @@ The review request is at: ${requestPath}
 }
 
 // src/commands/review/runClaudeReviewer.ts
-import { writeFileSync as writeFileSync30 } from "fs";
+import { writeFileSync as writeFileSync31 } from "fs";
 
 // src/commands/review/finaliseReviewerSpinner.ts
 var SUMMARY_MAX_LEN = 80;
@@ -15931,7 +16441,7 @@ async function runClaudeReviewer(spec) {
     }
   });
   if (result.exitCode === 0 && finalText)
-    writeFileSync30(spec.outputPath, finalText);
+    writeFileSync31(spec.outputPath, finalText);
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
 
@@ -16043,7 +16553,7 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync32 } from "fs";
+import { readFileSync as readFileSync33 } 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.
@@ -16099,7 +16609,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary2(synthesisPath) {
-  const markdown = readFileSync32(synthesisPath, "utf8");
+  const markdown = readFileSync33(synthesisPath, "utf8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -16317,7 +16827,7 @@ function registerReview(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk156 from "chalk";
+import chalk157 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -16346,10 +16856,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk155 from "chalk";
+import chalk156 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk155.red(`Connection "${name}" already exists.`));
+    console.error(chalk156.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -16367,18 +16877,18 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk156.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk157.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk160 from "chalk";
+import chalk161 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk157 from "chalk";
-async function fetchSeq(conn, path58, params) {
-  const url = `${conn.url}${path58}?${params}`;
+import chalk158 from "chalk";
+async function fetchSeq(conn, path57, params) {
+  const url = `${conn.url}${path57}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -16387,7 +16897,7 @@ async function fetchSeq(conn, path58, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk157.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk158.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -16446,23 +16956,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk158 from "chalk";
+import chalk159 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk158.bgRed.white;
+      return chalk159.bgRed.white;
     case "Error":
-      return chalk158.red;
+      return chalk159.red;
     case "Warning":
-      return chalk158.yellow;
+      return chalk159.yellow;
     case "Information":
-      return chalk158.cyan;
+      return chalk159.cyan;
     case "Debug":
-      return chalk158.gray;
+      return chalk159.gray;
     case "Verbose":
-      return chalk158.dim;
+      return chalk159.dim;
     default:
-      return chalk158.white;
+      return chalk159.white;
   }
 }
 function levelAbbrev(level) {
@@ -16503,12 +17013,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk158.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk159.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines.push(chalk158.red(`  ${line}`));
+      lines.push(chalk159.red(`  ${line}`));
     }
   }
   return lines.join("\n");
@@ -16541,11 +17051,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk159 from "chalk";
+import chalk160 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk159.red(
+      chalk160.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -16554,7 +17064,7 @@ function resolveNamedConnection(connections, requested, defaultName, kind, authC
   const target = requested ?? defaultName ?? connections[0].name;
   const connection = connections.find((c) => c.name === target);
   if (!connection) {
-    console.error(chalk159.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk160.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -16583,7 +17093,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count6) })
   );
   if (events.length === 0) {
-    console.log(chalk160.yellow("No events found."));
+    console.log(chalk161.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -16594,11 +17104,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk160.dim(`
+  console.log(chalk161.dim(`
 ${events.length} events`));
   if (events.length >= count6) {
     console.log(
-      chalk160.yellow(
+      chalk161.yellow(
         `Results limited to ${count6}. Use --count to retrieve more.`
       )
     );
@@ -16606,10 +17116,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk161 from "chalk";
+import chalk162 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk161.red(`Connection "${name}" not found.`));
+    console.error(chalk162.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -16657,7 +17167,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk163 from "chalk";
+import chalk164 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -16686,7 +17196,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk162 from "chalk";
+import chalk163 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -16694,7 +17204,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk162.red(`Invalid port "${portStr}".`));
+    console.error(chalk163.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -16707,13 +17217,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk163.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk164.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk164 from "chalk";
+import chalk165 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -16722,7 +17232,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk164.yellow("(no rows)"));
+    console.log(chalk165.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -16730,13 +17240,13 @@ function printTable(rows) {
     (col) => Math.max(col.length, ...rows.map((r) => formatCell(r[col]).length))
   );
   const header = columns.map((c, i) => c.padEnd(widths[i])).join("  ");
-  console.log(chalk164.dim(header));
-  console.log(chalk164.dim("-".repeat(header.length)));
+  console.log(chalk165.dim(header));
+  console.log(chalk165.dim("-".repeat(header.length)));
   for (const row of rows) {
     const line = columns.map((c, i) => formatCell(row[c]).padEnd(widths[i])).join("  ");
     console.log(line);
   }
-  console.log(chalk164.dim(`
+  console.log(chalk165.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -16796,7 +17306,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk165 from "chalk";
+import chalk166 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -16830,7 +17340,7 @@ function isMutation(sql6) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk165.red(
+      chalk166.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -16840,18 +17350,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk165.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk166.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk166 from "chalk";
+import chalk167 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk166.red(
+      chalk167.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -16866,7 +17376,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk166.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk167.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -16927,7 +17437,7 @@ function registerSql(program2) {
 
 // src/commands/transcript/shared.ts
 import { existsSync as existsSync38, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
-import { basename as basename8, join as join42, relative as relative2 } from "path";
+import { basename as basename8, join as join44, relative as relative2 } from "path";
 import * as readline2 from "readline";
 var DATE_PREFIX_REGEX = /^\d{4}-\d{2}-\d{2}/;
 function getDatePrefix(daysOffset = 0) {
@@ -16945,7 +17455,7 @@ function collectFiles(dir, extension) {
   if (!existsSync38(dir)) return [];
   const results = [];
   for (const entry of readdirSync7(dir)) {
-    const fullPath = join42(dir, entry);
+    const fullPath = join44(dir, entry);
     if (statSync5(fullPath).isDirectory()) {
       results.push(...collectFiles(fullPath, extension));
     } else if (entry.endsWith(extension)) {
@@ -17042,11 +17552,11 @@ async function configure() {
 import { existsSync as existsSync40 } from "fs";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/index.ts
-import { dirname as dirname22, join as join44 } from "path";
+import { dirname as dirname22, join as join46 } from "path";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/promptForDateFix.ts
 import { renameSync as renameSync2 } from "fs";
-import { join as join43 } from "path";
+import { join as join45 } from "path";
 async function resolveDate(rl, choice) {
   if (choice === "1") return getDatePrefix(0);
   if (choice === "2") return getDatePrefix(-1);
@@ -17061,7 +17571,7 @@ async function resolveDate(rl, choice) {
 }
 function renameWithPrefix(vttDir, vttFile, prefix2) {
   const newFilename = `${prefix2}.${vttFile}`;
-  renameSync2(join43(vttDir, vttFile), join43(vttDir, newFilename));
+  renameSync2(join45(vttDir, vttFile), join45(vttDir, newFilename));
   console.log(`Renamed to: ${newFilename}`);
   return newFilename;
 }
@@ -17095,12 +17605,12 @@ async function fixInvalidDatePrefixes(vttFiles) {
       const vttFileDir = dirname22(vttFile.absolutePath);
       const newFilename = await promptForDateFix(vttFile.filename, vttFileDir);
       if (newFilename) {
-        const newRelativePath = join44(
+        const newRelativePath = join46(
           dirname22(vttFile.relativePath),
           newFilename
         );
         vttFiles[i] = {
-          absolutePath: join44(vttFileDir, newFilename),
+          absolutePath: join46(vttFileDir, newFilename),
           relativePath: newRelativePath,
           filename: newFilename
         };
@@ -17113,8 +17623,8 @@ async function fixInvalidDatePrefixes(vttFiles) {
 }
 
 // src/commands/transcript/format/processVttFile/index.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync15, readFileSync as readFileSync33, writeFileSync as writeFileSync31 } from "fs";
-import { basename as basename9, dirname as dirname23, join as join45 } from "path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync15, readFileSync as readFileSync34, writeFileSync as writeFileSync32 } from "fs";
+import { basename as basename9, dirname as dirname23, join as join47 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text5) {
@@ -17324,17 +17834,17 @@ function toMdFilename(vttFilename) {
   return `${basename9(vttFilename, ".vtt").replace(/\s*Transcription\s*/g, " ").trim()}.md`;
 }
 function resolveOutputDir(relativeDir, transcriptsDir) {
-  return relativeDir === "." ? transcriptsDir : join45(transcriptsDir, relativeDir);
+  return relativeDir === "." ? transcriptsDir : join47(transcriptsDir, relativeDir);
 }
 function buildOutputPaths(vttFile, transcriptsDir) {
   const mdFile = toMdFilename(vttFile.filename);
   const relativeDir = dirname23(vttFile.relativePath);
   const outputDir = resolveOutputDir(relativeDir, transcriptsDir);
-  const outputPath = join45(outputDir, mdFile);
+  const outputPath = join47(outputDir, mdFile);
   return { outputDir, outputPath, mdFile, relativeDir };
 }
 function logSkipped(relativeDir, mdFile) {
-  console.log(`Skipping (already exists): ${join45(relativeDir, mdFile)}`);
+  console.log(`Skipping (already exists): ${join47(relativeDir, mdFile)}`);
   return "skipped";
 }
 function ensureDirectory(dir, label2) {
@@ -17361,10 +17871,10 @@ function logReduction(cueCount, messageCount) {
 }
 function readAndParseCues(inputPath) {
   console.log(`Reading: ${inputPath}`);
-  return processCues(readFileSync33(inputPath, "utf8"));
+  return processCues(readFileSync34(inputPath, "utf8"));
 }
 function writeFormatted(outputPath, content) {
-  writeFileSync31(outputPath, content, "utf8");
+  writeFileSync32(outputPath, content, "utf8");
   console.log(`Written: ${outputPath}`);
 }
 function convertVttToMarkdown(inputPath, outputPath) {
@@ -17433,27 +17943,27 @@ async function format() {
 
 // src/commands/transcript/summarise/index.ts
 import { existsSync as existsSync42 } from "fs";
-import { basename as basename10, dirname as dirname25, join as join47, relative as relative3 } from "path";
+import { basename as basename10, dirname as dirname25, join as join49, relative as relative3 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
 import {
   existsSync as existsSync41,
   mkdirSync as mkdirSync16,
-  readFileSync as readFileSync34,
+  readFileSync as readFileSync35,
   renameSync as renameSync3,
   rmSync as rmSync4
 } from "fs";
-import { dirname as dirname24, join as join46 } from "path";
+import { dirname as dirname24, join as join48 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk167 from "chalk";
+import chalk168 from "chalk";
 var FULL_TRANSCRIPT_REGEX = /^\[Full Transcript\]\(([^)]+)\)/;
 function validateStagedContent(filename, content) {
   const firstLine = content.split("\n")[0];
   const match = firstLine.match(FULL_TRANSCRIPT_REGEX);
   if (!match) {
     console.error(
-      chalk167.red(
+      chalk168.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -17462,7 +17972,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk167.red(
+      chalk168.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -17472,7 +17982,7 @@ function validateStagedContent(filename, content) {
 }
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
-var STAGING_DIR = join46(process.cwd(), ".assist", "transcript");
+var STAGING_DIR = join48(process.cwd(), ".assist", "transcript");
 function processStagedFile() {
   if (!existsSync41(STAGING_DIR)) {
     return false;
@@ -17483,7 +17993,7 @@ function processStagedFile() {
   }
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
   const stagedFile = stagedFiles[0];
-  const content = readFileSync34(stagedFile.absolutePath, "utf8");
+  const content = readFileSync35(stagedFile.absolutePath, "utf8");
   validateStagedContent(stagedFile.filename, content);
   const stagedBaseName = getTranscriptBaseName(stagedFile.filename);
   const transcriptFiles = findMdFilesRecursive(transcriptsDir);
@@ -17496,7 +18006,7 @@ function processStagedFile() {
     );
     process.exit(1);
   }
-  const destPath = join46(summaryDir, matchingTranscript.relativePath);
+  const destPath = join48(summaryDir, matchingTranscript.relativePath);
   const destDir = dirname24(destPath);
   if (!existsSync41(destDir)) {
     mkdirSync16(destDir, { recursive: true });
@@ -17512,7 +18022,7 @@ function processStagedFile() {
 // src/commands/transcript/summarise/index.ts
 function buildRelativeKey(relativePath, baseName) {
   const relDir = dirname25(relativePath);
-  return relDir === "." ? baseName : join47(relDir, baseName);
+  return relDir === "." ? baseName : join49(relDir, baseName);
 }
 function buildSummaryIndex(summaryDir) {
   const summaryFiles = findMdFilesRecursive(summaryDir);
@@ -17546,8 +18056,8 @@ function summarise2() {
   }
   const next3 = missing[0];
   const outputFilename = `${getTranscriptBaseName(next3.filename)}.md`;
-  const outputPath = join47(STAGING_DIR, outputFilename);
-  const summaryFileDir = join47(summaryDir, dirname25(next3.relativePath));
+  const outputPath = join49(STAGING_DIR, outputFilename);
+  const summaryFileDir = join49(summaryDir, dirname25(next3.relativePath));
   const relativeTranscriptPath = encodeURI(
     relative3(summaryFileDir, next3.absolutePath).replace(/\\/g, "/")
   );
@@ -17597,50 +18107,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { join as join49 } from "path";
+import { join as join51 } from "path";
 
 // src/commands/voice/shared.ts
 import { homedir as homedir14 } from "os";
-import { dirname as dirname26, join as join48 } from "path";
+import { dirname as dirname26, join as join50 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var __dirname5 = dirname26(fileURLToPath6(import.meta.url));
-var VOICE_DIR = join48(homedir14(), ".assist", "voice");
+var VOICE_DIR = join50(homedir14(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join48(VOICE_DIR, "voice.pid"),
-  log: join48(VOICE_DIR, "voice.log"),
-  venv: join48(VOICE_DIR, ".venv"),
-  lock: join48(VOICE_DIR, "voice.lock")
+  pid: join50(VOICE_DIR, "voice.pid"),
+  log: join50(VOICE_DIR, "voice.log"),
+  venv: join50(VOICE_DIR, ".venv"),
+  lock: join50(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join48(__dirname5, "commands", "voice", "python");
+  return join50(__dirname5, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join48(voicePaths.venv, "Scripts", "python.exe") : join48(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join50(voicePaths.venv, "Scripts", "python.exe") : join50(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join48(getLockDir(), "voice.lock");
+  return join50(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join49(getPythonDir(), "list_devices.py");
+  const script = join51(getPythonDir(), "list_devices.py");
   spawnSync5(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync43, readFileSync as readFileSync35 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync36 } from "fs";
 function logs(options2) {
   if (!existsSync43(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count6 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync35(voicePaths.log, "utf8").trim();
+  const content = readFileSync36(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -17663,12 +18173,12 @@ function logs(options2) {
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync6 } from "child_process";
 import { mkdirSync as mkdirSync18 } from "fs";
-import { join as join51 } from "path";
+import { join as join53 } from "path";
 
 // src/commands/voice/checkLockFile.ts
-import { execSync as execSync46 } from "child_process";
-import { existsSync as existsSync44, mkdirSync as mkdirSync17, readFileSync as readFileSync36, writeFileSync as writeFileSync32 } from "fs";
-import { join as join50 } from "path";
+import { execSync as execSync47 } from "child_process";
+import { existsSync as existsSync44, mkdirSync as mkdirSync17, readFileSync as readFileSync37, writeFileSync as writeFileSync33 } from "fs";
+import { join as join52 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -17681,7 +18191,7 @@ function checkLockFile() {
   const lockFile = getLockFile();
   if (!existsSync44(lockFile)) return;
   try {
-    const lock = JSON.parse(readFileSync36(lockFile, "utf8"));
+    const lock = JSON.parse(readFileSync37(lockFile, "utf8"));
     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`
@@ -17695,7 +18205,7 @@ function bootstrapVenv() {
   if (existsSync44(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
-  execSync46(
+  execSync47(
     `uv sync --project "${pythonDir}" --extra runtime --no-install-project`,
     {
       stdio: "inherit",
@@ -17705,8 +18215,8 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync17(join50(lockFile, ".."), { recursive: true });
-  writeFileSync32(
+  mkdirSync17(join52(lockFile, ".."), { recursive: true });
+  writeFileSync33(
     lockFile,
     JSON.stringify({
       pid,
@@ -17721,7 +18231,7 @@ function setup() {
   mkdirSync18(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join51(getPythonDir(), "setup_models.py");
+  const script = join53(getPythonDir(), "setup_models.py");
   const result = spawnSync6(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -17734,8 +18244,8 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn7 } from "child_process";
-import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync33 } from "fs";
-import { join as join52 } from "path";
+import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync34 } from "fs";
+import { join as join54 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -17763,7 +18273,7 @@ function spawnBackground(python, script, env) {
     console.error("Failed to start voice daemon");
     process.exit(1);
   }
-  writeFileSync33(voicePaths.pid, String(pid));
+  writeFileSync34(voicePaths.pid, String(pid));
   writeLockFile(pid);
   console.log(`Voice daemon started (PID ${pid})`);
 }
@@ -17773,7 +18283,7 @@ function start2(options2) {
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join52(getPythonDir(), "voice_daemon.py");
+  const script = join54(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -17783,7 +18293,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync45, readFileSync as readFileSync37 } from "fs";
+import { existsSync as existsSync45, readFileSync as readFileSync38 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -17794,7 +18304,7 @@ function isProcessAlive3(pid) {
 }
 function readRecentLogs(count6) {
   if (!existsSync45(voicePaths.log)) return [];
-  const lines = readFileSync37(voicePaths.log, "utf8").trim().split("\n");
+  const lines = readFileSync38(voicePaths.log, "utf8").trim().split("\n");
   return lines.slice(-count6);
 }
 function status() {
@@ -17802,7 +18312,7 @@ function status() {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync37(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync38(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -17821,13 +18331,13 @@ function status() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync46, readFileSync as readFileSync38, unlinkSync as unlinkSync15 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync39, unlinkSync as unlinkSync15 } from "fs";
 function stop2() {
   if (!existsSync46(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync38(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync39(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -17859,7 +18369,7 @@ function registerVoice(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk168 from "chalk";
+import chalk169 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -17990,13 +18500,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk168.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk169.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk168.white("http://localhost:14523/callback\n"));
-  console.log(chalk168.blue("Opening browser for authorization..."));
-  console.log(chalk168.dim("Waiting for authorization callback..."));
+  console.log(chalk169.white("http://localhost:14523/callback\n"));
+  console.log(chalk169.blue("Opening browser for authorization..."));
+  console.log(chalk169.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk168.dim("Exchanging code for tokens..."));
+  console.log(chalk169.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -18012,14 +18522,14 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk168.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk169.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { readdirSync as readdirSync8, readFileSync as readFileSync39, statSync as statSync6 } from "fs";
-import { join as join53 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync40, statSync as statSync6 } from "fs";
+import { join as join55 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
@@ -18028,9 +18538,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path58 = join53(roamDir, name);
+    const path57 = join55(roamDir, name);
     try {
-      return { path: path58, mtimeMs: statSync6(path58).mtimeMs };
+      return { path: path57, mtimeMs: statSync6(path57).mtimeMs };
     } catch {
       return void 0;
     }
@@ -18040,11 +18550,11 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join53(appData, "Roam"));
+  const portFile = findPortFile(join55(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync39(portFile, "utf8").trim();
+    port = readFileSync40(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -18088,7 +18598,7 @@ function registerRoam(program2) {
 }
 
 // src/commands/run/index.ts
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 
 // src/commands/run/findRunConfig.ts
 function exitNoRunConfigs() {
@@ -18172,11 +18682,11 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/runPreCommands.ts
-import { execSync as execSync47 } from "child_process";
+import { execSync as execSync48 } from "child_process";
 function runPreCommands(pre, cwd) {
   for (const cmd of pre) {
     try {
-      execSync47(cmd, { stdio: "inherit", cwd });
+      execSync48(cmd, { stdio: "inherit", cwd });
     } catch (error) {
       const code = error && typeof error === "object" && "status" in error ? error.status : 1;
       process.exit(code);
@@ -18187,13 +18697,13 @@ function runPreCommands(pre, cwd) {
 // src/commands/run/spawnRunCommand.ts
 import { execFileSync as execFileSync8, spawn as spawn8 } from "child_process";
 import { existsSync as existsSync47 } from "fs";
-import { dirname as dirname27, join as join54, resolve as resolve11 } from "path";
+import { dirname as dirname27, join as join56, resolve as resolve12 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync8("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
-    const gitRoot = resolve11(dirname27(gitPath), "..");
-    const gitBash = join54(gitRoot, "bin", "bash.exe");
+    const gitRoot = resolve12(dirname27(gitPath), "..");
+    const gitBash = join56(gitRoot, "bin", "bash.exe");
     if (existsSync47(gitBash)) return gitBash;
   } catch {
   }
@@ -18240,7 +18750,7 @@ function listRunConfigs(verbose) {
   }
 }
 function execRunConfig(config, args) {
-  const cwd = config.cwd ? resolve12(getConfigDir(), config.cwd) : void 0;
+  const cwd = config.cwd ? resolve13(getConfigDir(), config.cwd) : void 0;
   if (config.pre) runPreCommands(config.pre, cwd);
   const resolved = resolveParams(config.params, args);
   spawnRunCommand(
@@ -18279,8 +18789,8 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync34 } from "fs";
-import { join as join55 } from "path";
+import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync35 } from "fs";
+import { join as join57 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -18341,7 +18851,7 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join55(".claude", "commands");
+  const dir = join57(".claude", "commands");
   mkdirSync20(dir, { recursive: true });
   const content = `---
 description: Run ${name}
@@ -18349,8 +18859,8 @@ description: Run ${name}
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join55(dir, `${name}.md`);
-  writeFileSync34(filePath, content);
+  const filePath = join57(dir, `${name}.md`);
+  writeFileSync35(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add3() {
@@ -18373,11 +18883,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path58 = process.argv[idx + 1];
+  const path57 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path58, prefix: prefix2 };
+  return { path: path57, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -18406,7 +18916,7 @@ function link2() {
 
 // src/commands/run/remove.ts
 import { existsSync as existsSync48, unlinkSync as unlinkSync16 } from "fs";
-import { join as join56 } from "path";
+import { join as join58 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -18421,7 +18931,7 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join56(".claude", "commands", `${name}.md`);
+  const filePath = join58(".claude", "commands", `${name}.md`);
   if (existsSync48(filePath)) {
     unlinkSync16(filePath);
     console.log(`Deleted command file: ${filePath}`);
@@ -18460,11 +18970,11 @@ function registerRun(program2) {
 }
 
 // src/commands/screenshot/index.ts
-import { execSync as execSync48 } from "child_process";
-import { existsSync as existsSync49, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync35 } from "fs";
+import { execSync as execSync49 } from "child_process";
+import { existsSync as existsSync49, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync36 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join57, resolve as resolve13 } from "path";
-import chalk169 from "chalk";
+import { join as join59, resolve as resolve14 } from "path";
+import chalk170 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -18597,13 +19107,13 @@ function buildOutputPath(outputDir, processName) {
     mkdirSync21(outputDir, { recursive: true });
   }
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return resolve13(outputDir, `${processName}-${timestamp2}.png`);
+  return resolve14(outputDir, `${processName}-${timestamp2}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join57(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
-  writeFileSync35(scriptPath, captureWindowPs1, "utf8");
+  const scriptPath = join59(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
+  writeFileSync36(scriptPath, captureWindowPs1, "utf8");
   try {
-    execSync48(
+    execSync49(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
       { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" }
     );
@@ -18613,15 +19123,15 @@ function runPowerShellScript(processName, outputPath) {
 }
 function screenshot(processName) {
   const config = loadConfig();
-  const outputDir = resolve13(config.screenshot.outputDir);
+  const outputDir = resolve14(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk169.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk170.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk169.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk170.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk169.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk170.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -18677,7 +19187,7 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/reportStolenSocket.ts
-import { readFileSync as readFileSync40 } from "fs";
+import { readFileSync as readFileSync41 } from "fs";
 function reportStolenSocket(socketPid) {
   if (!socketPid) return;
   const filePid = readPidFile();
@@ -18689,7 +19199,7 @@ function reportStolenSocket(socketPid) {
 function readPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync40(daemonPaths.pid, "utf8").trim(),
+      readFileSync41(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -19017,6 +19527,9 @@ function createAssistSession(id2, assistArgs, cwd) {
   };
 }
 
+// src/commands/sessions/daemon/createSession.ts
+import { randomUUID as randomUUID4 } from "crypto";
+
 // src/commands/sessions/daemon/spawnClaude.ts
 function spawnClaude2(opts = {}) {
   return spawnPty(buildArgs3(opts), opts.cwd, opts.sessionId);
@@ -19026,6 +19539,7 @@ function buildArgs3(opts) {
   if (opts.resumeSessionId) {
     return opts.prompt ? [...base, "--resume", opts.resumeSessionId, opts.prompt] : [...base, "--resume", opts.resumeSessionId];
   }
+  if (opts.claudeSessionId) base.push("--session-id", opts.claudeSessionId);
   if (opts.prompt) return [...base, opts.prompt];
   return base;
 }
@@ -19036,33 +19550,34 @@ function spawnRun(opts) {
 }
 
 // src/commands/sessions/daemon/createSession.ts
-function createSession(id2, prompt, cwd) {
+function runningBase(id2) {
   const startedAt = Date.now();
   return {
     id: id2,
-    name: prompt?.slice(0, 40) || `Session ${id2}`,
-    commandType: "claude",
     status: "running",
     startedAt,
     runningMs: 0,
     runningSince: startedAt,
-    pty: spawnClaude2({ prompt, cwd, sessionId: id2 }),
-    scrollback: "",
-    cwd
+    scrollback: ""
+  };
+}
+function createSession(id2, prompt, cwd) {
+  const claudeSessionId = randomUUID4();
+  return {
+    ...runningBase(id2),
+    name: prompt?.slice(0, 40) || `Session ${id2}`,
+    commandType: "claude",
+    pty: spawnClaude2({ prompt, cwd, sessionId: id2, claudeSessionId }),
+    cwd,
+    claudeSessionId
   };
 }
 function createRunSession(id2, runName, runArgs, cwd) {
-  const startedAt = Date.now();
   return {
-    id: id2,
+    ...runningBase(id2),
     name: `run: ${runName}`,
     commandType: "run",
-    status: "running",
-    startedAt,
-    runningMs: 0,
-    runningSince: startedAt,
     pty: spawnRun({ name: runName, args: runArgs, cwd }),
-    scrollback: "",
     runName,
     runArgs,
     cwd
@@ -19126,10 +19641,14 @@ function disarmEscInterrupt(session) {
 
 // src/commands/sessions/daemon/shouldAutoDismiss.ts
 function shouldAutoDismiss(session, exitCode) {
-  const args = session.assistArgs;
-  if (session.status !== "done" || exitCode !== 0 || args === void 0) {
+  if (session.status !== "done" || exitCode !== 0) {
     return false;
   }
+  if (session.reviewStarted) {
+    return session.autoAdvance === true;
+  }
+  const args = session.assistArgs;
+  if (args === void 0) return false;
   if (args[0] === "update") return true;
   return args.includes("--once") && args[0] !== "next";
 }
@@ -19214,9 +19733,25 @@ function runningSession(base, persisted, pty2) {
   };
 }
 
+// src/commands/sessions/daemon/updatedSession.ts
+function updatedSession(id2, persisted) {
+  return {
+    ...restoreBase(id2, persisted),
+    status: "done",
+    startedAt: persisted.startedAt,
+    runningMs: persisted.runningMs ?? 0,
+    runningSince: null,
+    pty: null
+  };
+}
+function isUpdate(persisted) {
+  return persisted.commandType === "assist" && persisted.assistArgs?.[0] === "update";
+}
+
 // src/commands/sessions/daemon/restoreSession.ts
 function restoreSession(id2, persisted) {
   const base = restoreBase(id2, persisted);
+  if (isUpdate(persisted)) return updatedSession(id2, persisted);
   if (isBacklogRun(persisted)) {
     const pty2 = spawnPty(backlogRunArgs(persisted), persisted.cwd, id2);
     return runningSession(base, persisted, pty2);
@@ -19296,18 +19831,35 @@ function resumeSession(id2, sessionId, cwd, name) {
     runningSince: startedAt,
     pty: spawnClaude2({ resumeSessionId: sessionId, cwd, sessionId: id2 }),
     scrollback: "",
-    cwd
+    cwd,
+    /* why: bind the card to the conversation it is resuming so a daemon restart
+     * re-resumes this same transcript, not whichever .jsonl a cwd poller would
+     * have re-discovered (#413). */
+    claudeSessionId: sessionId
   };
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
 import { existsSync as existsSync51, mkdirSync as mkdirSync22, watch } from "fs";
 import { dirname as dirname28 } from "path";
+
+// src/commands/sessions/daemon/applyReviewPause.ts
+function applyReviewPause(session, activity2) {
+  const inReview = activity2.kind === "backlog" && activity2.phase !== void 0 && activity2.phase === activity2.totalPhases;
+  if (inReview && !session.reviewStarted) {
+    session.autoAdvance = false;
+    session.reviewStarted = true;
+  } else if (!inReview && session.reviewStarted) {
+    session.reviewStarted = false;
+  }
+}
+
+// src/commands/sessions/daemon/watchActivity.ts
 var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path58 = activityPath(session.id);
-  const dir = dirname28(path58);
+  const path57 = activityPath(session.id);
+  const dir = dirname28(path57);
   try {
     mkdirSync22(dir, { recursive: true });
   } catch {
@@ -19317,19 +19869,20 @@ function watchActivity(session, notify2) {
   let timer = null;
   const read = () => {
     timer = null;
-    const activity2 = readActivity(path58);
+    const activity2 = readActivity(path57);
     if (!activity2) return;
     session.activity = activity2;
     if (activity2.claudeSessionId)
       session.claudeSessionId = activity2.claudeSessionId;
+    applyReviewPause(session, activity2);
     notify2();
   };
   session.activityWatcher = watch(dir, (_event, filename) => {
-    if (filename && !path58.endsWith(filename)) return;
+    if (filename && !path57.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync51(path58)) read();
+  if (existsSync51(path57)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -19946,9 +20499,144 @@ var WindowsProxy = class {
   }
 };
 
-// src/commands/sessions/daemon/watchClaudeSessionId.ts
-import * as fs31 from "fs";
-import * as path52 from "path";
+// src/commands/sessions/daemon/writeToSession.ts
+function writeToSession(sessions, id2, data, onStatusChange) {
+  const s = sessions.get(id2);
+  if (!s || s.status === "done") return;
+  s.pty?.write(data);
+  watchEscInterrupt(s, data, onStatusChange);
+}
+function resizeSession(sessions, id2, cols, rows) {
+  const s = sessions.get(id2);
+  if (s && s.status !== "done") s.pty?.resize(cols, rows);
+}
+function setAutoRun(sessions, id2, enabled) {
+  const s = sessions.get(id2);
+  if (!s) return false;
+  s.autoRun = enabled;
+  return true;
+}
+function setAutoAdvance(sessions, id2, enabled) {
+  const s = sessions.get(id2);
+  if (!s) return false;
+  s.autoAdvance = enabled;
+  const itemId = s.activity?.itemId;
+  if (itemId != null) {
+    if (enabled) clearPause(itemId);
+    else requestPause(itemId);
+  }
+  return true;
+}
+function dismissSession(sessions, id2) {
+  const s = sessions.get(id2);
+  if (!s) return false;
+  if (s.status !== "done") s.pty?.kill();
+  s.activityWatcher?.close();
+  removeActivity(s.id);
+  if (s.activity?.itemId != null) releaseLock(s.activity.itemId);
+  sessions.delete(id2);
+  return true;
+}
+
+// src/commands/sessions/daemon/SessionManager.ts
+var SessionManager = class {
+  constructor(onIdleChange) {
+    this.onIdleChange = onIdleChange;
+  }
+  sessions = /* @__PURE__ */ new Map();
+  // why: dispatch calls active.set() on card click; broadcasts include active.toJSON()
+  active = new ActiveSelection(() => this.notify());
+  clients = new ClientHub(persistUsagePeak);
+  nextId = 1;
+  shuttingDown = false;
+  // why: dispatch calls windowsProxy.route() to forward windows-origin sessions
+  windowsProxy = new WindowsProxy(this.clients, () => this.notify());
+  addClient(client) {
+    this.clients.add(client);
+    this.notify();
+    greetClient(client, this.sessions, this.windowsProxy);
+  }
+  removeClient(client) {
+    this.clients.delete(client);
+    this.onIdleChange?.(this.isIdle());
+  }
+  isIdle = () => this.sessions.size === 0 && this.clients.size === 0;
+  shutdown() {
+    this.shuttingDown = true;
+    shutdownSessions(this.sessions);
+  }
+  restore() {
+    return restoreAll(this.spawnWith, this.sessions);
+  }
+  add(session) {
+    this.wire(session);
+    watchActivity(session, this.notify);
+    return session.id;
+  }
+  spawnWith = (create) => this.add(create(String(this.nextId++)));
+  spawn(prompt, cwd) {
+    return this.spawnWith((id2) => createSession(id2, prompt, cwd));
+  }
+  spawnRun(runName, runArgs, cwd) {
+    return this.spawnWith((id2) => createRunSession(id2, runName, runArgs, cwd));
+  }
+  spawnAssist(assistArgs, cwd) {
+    return this.spawnWith((id2) => createAssistSession(id2, assistArgs, cwd));
+  }
+  resume(sessionId, cwd, name) {
+    return this.spawnWith((id2) => resumeSession(id2, sessionId, cwd, name));
+  }
+  onStatusChange = makeStatusChangeHandler(
+    (id2) => this.dismissSession(id2),
+    () => this.notify(),
+    (session, itemId) => reuseSessionForRun(session, itemId, this.clients, this.onStatusChange)
+  );
+  wire(session) {
+    this.sessions.set(session.id, session);
+    wirePtyEvents(session, this.clients, this.onStatusChange);
+    this.notify();
+  }
+  writeToSession(id2, data) {
+    writeToSession(this.sessions, id2, data, this.onStatusChange);
+  }
+  resizeSession(id2, cols, rows) {
+    resizeSession(this.sessions, id2, cols, rows);
+  }
+  retrySession(id2) {
+    const s = this.sessions.get(id2);
+    if (s && retrySession(s, this.clients, this.onStatusChange)) this.notify();
+  }
+  dismissSession = (id2) => {
+    if (dismissSession(this.sessions, id2)) this.notify();
+  };
+  setAutoRun(id2, enabled) {
+    if (setAutoRun(this.sessions, id2, enabled)) this.notify();
+  }
+  setAutoAdvance(id2, enabled) {
+    if (setAutoAdvance(this.sessions, id2, enabled)) this.notify();
+  }
+  setStatus(id2, status2) {
+    const session = this.sessions.get(id2);
+    if (session) this.onStatusChange(session, status2);
+  }
+  listSessions = () => {
+    const local = [...this.sessions.values()].map(toSessionInfo);
+    return local.concat(this.windowsProxy.sessions());
+  };
+  notify = () => {
+    if (this.shuttingDown) return;
+    const windows = this.windowsProxy.sessions();
+    broadcastSessions(this.sessions, this.clients, windows, this.active);
+    this.onIdleChange?.(this.isIdle());
+  };
+};
+
+// src/commands/sessions/daemon/startDaemonServer.ts
+import { unlinkSync as unlinkSync19 } from "fs";
+import * as net3 from "net";
+
+// src/commands/sessions/daemon/handleConnection.ts
+import { createInterface as createInterface7 } from "readline";
 
 // src/commands/sessions/shared/discoverSessions.ts
 import * as fs30 from "fs";
@@ -20136,211 +20824,8 @@ async function discoverSessions() {
   return sessions;
 }
 
-// src/commands/sessions/daemon/watchClaudeSessionId.ts
-var POLL_MS = 3e3;
-async function watchClaudeSessionId(options2) {
-  let adoptedMs = 0;
-  while (options2.isActive()) {
-    const latest = await findLatestSessionId(options2);
-    if (latest && latest.createdMs > adoptedMs) {
-      adoptedMs = latest.createdMs;
-      options2.onSessionId(latest.sessionId);
-    }
-    await sleep(options2.pollMs ?? POLL_MS);
-  }
-}
-async function findLatestSessionId(options2) {
-  const paths = await discoverSessionJsonlPaths();
-  let latest = null;
-  for (const { path: filePath, origin } of paths) {
-    const createdMs = await createdSince(filePath, options2.sinceMs);
-    if (createdMs === null) continue;
-    const meta = await parseSessionFile(filePath, origin);
-    if (!meta?.cwd || options2.isClaimed(meta.sessionId)) continue;
-    if (path52.resolve(meta.cwd) !== path52.resolve(options2.cwd)) continue;
-    if (!latest || createdMs > latest.createdMs)
-      latest = { sessionId: meta.sessionId, createdMs };
-  }
-  return latest;
-}
-async function createdSince(filePath, sinceMs) {
-  try {
-    const stat = await fs31.promises.stat(filePath);
-    const createdMs = stat.birthtimeMs || stat.mtimeMs;
-    return createdMs >= sinceMs ? createdMs : null;
-  } catch {
-    return null;
-  }
-}
-function sleep(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
-}
-
-// src/commands/sessions/daemon/watchForClaudeSessionId.ts
-function watchForClaudeSessionId(session, sessions, onDiscovered) {
-  if (session.commandType === "run" || !session.pty) return;
-  if (isBacklogRun2(session)) return;
-  void watchClaudeSessionId({
-    cwd: session.cwd ?? process.cwd(),
-    sinceMs: session.startedAt,
-    isClaimed: (sessionId) => [...sessions.values()].some((s) => s.claudeSessionId === sessionId),
-    isActive: () => {
-      const s = sessions.get(session.id);
-      return !!s && s.status !== "done";
-    },
-    onSessionId: (sessionId) => {
-      if (!sessions.has(session.id)) return;
-      session.claudeSessionId = sessionId;
-      onDiscovered();
-    }
-  });
-}
-function isBacklogRun2(session) {
-  return session.commandType === "assist" && session.assistArgs?.[0] === "backlog" && session.assistArgs?.[1] === "run";
-}
-
-// src/commands/sessions/daemon/writeToSession.ts
-function writeToSession(sessions, id2, data, onStatusChange) {
-  const s = sessions.get(id2);
-  if (!s || s.status === "done") return;
-  s.pty?.write(data);
-  watchEscInterrupt(s, data, onStatusChange);
-}
-function resizeSession(sessions, id2, cols, rows) {
-  const s = sessions.get(id2);
-  if (s && s.status !== "done") s.pty?.resize(cols, rows);
-}
-function setAutoRun(sessions, id2, enabled) {
-  const s = sessions.get(id2);
-  if (!s) return false;
-  s.autoRun = enabled;
-  return true;
-}
-function setAutoAdvance(sessions, id2, enabled) {
-  const s = sessions.get(id2);
-  if (!s) return false;
-  s.autoAdvance = enabled;
-  const itemId = s.activity?.itemId;
-  if (itemId != null) {
-    if (enabled) clearPause(itemId);
-    else requestPause(itemId);
-  }
-  return true;
-}
-function dismissSession(sessions, id2) {
-  const s = sessions.get(id2);
-  if (!s) return false;
-  if (s.status !== "done") s.pty?.kill();
-  s.activityWatcher?.close();
-  removeActivity(s.id);
-  if (s.activity?.itemId != null) releaseLock(s.activity.itemId);
-  sessions.delete(id2);
-  return true;
-}
-
-// src/commands/sessions/daemon/SessionManager.ts
-var SessionManager = class {
-  constructor(onIdleChange) {
-    this.onIdleChange = onIdleChange;
-  }
-  sessions = /* @__PURE__ */ new Map();
-  // why: dispatch calls active.set() on card click; broadcasts include active.toJSON()
-  active = new ActiveSelection(() => this.notify());
-  clients = new ClientHub(persistUsagePeak);
-  nextId = 1;
-  shuttingDown = false;
-  // why: dispatch calls windowsProxy.route() to forward windows-origin sessions
-  windowsProxy = new WindowsProxy(this.clients, () => this.notify());
-  addClient(client) {
-    this.clients.add(client);
-    this.notify();
-    greetClient(client, this.sessions, this.windowsProxy);
-  }
-  removeClient(client) {
-    this.clients.delete(client);
-    this.onIdleChange?.(this.isIdle());
-  }
-  isIdle = () => this.sessions.size === 0 && this.clients.size === 0;
-  shutdown() {
-    this.shuttingDown = true;
-    shutdownSessions(this.sessions);
-  }
-  restore() {
-    return restoreAll(this.spawnWith, this.sessions);
-  }
-  add(session) {
-    this.wire(session);
-    watchForClaudeSessionId(session, this.sessions, this.notify);
-    watchActivity(session, this.notify);
-    return session.id;
-  }
-  spawnWith = (create) => this.add(create(String(this.nextId++)));
-  spawn(prompt, cwd) {
-    return this.spawnWith((id2) => createSession(id2, prompt, cwd));
-  }
-  spawnRun(runName, runArgs, cwd) {
-    return this.spawnWith((id2) => createRunSession(id2, runName, runArgs, cwd));
-  }
-  spawnAssist(assistArgs, cwd) {
-    return this.spawnWith((id2) => createAssistSession(id2, assistArgs, cwd));
-  }
-  resume(sessionId, cwd, name) {
-    return this.spawnWith((id2) => resumeSession(id2, sessionId, cwd, name));
-  }
-  onStatusChange = makeStatusChangeHandler(
-    (id2) => this.dismissSession(id2),
-    () => this.notify(),
-    (session, itemId) => reuseSessionForRun(session, itemId, this.clients, this.onStatusChange)
-  );
-  wire(session) {
-    this.sessions.set(session.id, session);
-    wirePtyEvents(session, this.clients, this.onStatusChange);
-    this.notify();
-  }
-  writeToSession(id2, data) {
-    writeToSession(this.sessions, id2, data, this.onStatusChange);
-  }
-  resizeSession(id2, cols, rows) {
-    resizeSession(this.sessions, id2, cols, rows);
-  }
-  retrySession(id2) {
-    const s = this.sessions.get(id2);
-    if (s && retrySession(s, this.clients, this.onStatusChange)) this.notify();
-  }
-  dismissSession = (id2) => {
-    if (dismissSession(this.sessions, id2)) this.notify();
-  };
-  setAutoRun(id2, enabled) {
-    if (setAutoRun(this.sessions, id2, enabled)) this.notify();
-  }
-  setAutoAdvance(id2, enabled) {
-    if (setAutoAdvance(this.sessions, id2, enabled)) this.notify();
-  }
-  setStatus(id2, status2) {
-    const session = this.sessions.get(id2);
-    if (session) this.onStatusChange(session, status2);
-  }
-  listSessions = () => {
-    const local = [...this.sessions.values()].map(toSessionInfo);
-    return local.concat(this.windowsProxy.sessions());
-  };
-  notify = () => {
-    if (this.shuttingDown) return;
-    const windows = this.windowsProxy.sessions();
-    broadcastSessions(this.sessions, this.clients, windows, this.active);
-    this.onIdleChange?.(this.isIdle());
-  };
-};
-
-// src/commands/sessions/daemon/startDaemonServer.ts
-import { unlinkSync as unlinkSync19 } from "fs";
-import * as net3 from "net";
-
-// src/commands/sessions/daemon/handleConnection.ts
-import { createInterface as createInterface7 } from "readline";
-
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs32 from "fs";
+import * as fs31 from "fs";
 
 // src/commands/sessions/shared/toolTarget.ts
 function toolTarget(input) {
@@ -20388,11 +20873,11 @@ function cleanUserText(value) {
 }
 
 // src/commands/sessions/shared/findSessionJsonlPath.ts
-import * as path53 from "path";
+import * as path52 from "path";
 async function findSessionJsonlPath(sessionId) {
   const paths = await discoverSessionJsonlPaths();
   const direct = paths.find(
-    (p) => path53.basename(p.path, ".jsonl") === sessionId
+    (p) => path52.basename(p.path, ".jsonl") === sessionId
   );
   if (direct) return direct.path;
   for (const p of paths) {
@@ -20407,7 +20892,7 @@ async function parseTranscript(sessionId) {
   const filePath = await findSessionJsonlPath(sessionId);
   if (!filePath) return [];
   try {
-    const raw = await fs32.promises.readFile(filePath, "utf8");
+    const raw = await fs31.promises.readFile(filePath, "utf8");
     return parseTranscriptLines(raw.split("\n"));
   } catch {
     return [];
@@ -20552,10 +21037,10 @@ function handleConnection(socket, manager) {
 }
 
 // src/commands/sessions/daemon/onListening.ts
-import { unlinkSync as unlinkSync18, writeFileSync as writeFileSync36 } from "fs";
+import { unlinkSync as unlinkSync18, writeFileSync as writeFileSync37 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync41 } from "fs";
+import { readFileSync as readFileSync42 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -20566,7 +21051,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync41(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync42(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -20574,7 +21059,7 @@ function ownsPidFile() {
 
 // src/commands/sessions/daemon/onListening.ts
 function onListening(manager, checkAutoExit) {
-  writeFileSync36(daemonPaths.pid, String(process.pid));
+  writeFileSync37(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
     manager.shutdown();
@@ -20707,17 +21192,17 @@ async function setSessionStatus(status2) {
 }
 
 // src/commands/sessions/summarise/index.ts
-import * as fs35 from "fs";
-import chalk170 from "chalk";
+import * as fs34 from "fs";
+import chalk171 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs33 from "fs";
+import * as fs32 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs33.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs32.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs33.existsSync(summaryPathFor(jsonlPath2));
+  return fs32.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
@@ -20727,7 +21212,7 @@ function summaryPathFor(jsonlPath2) {
 import { execFileSync as execFileSync10 } from "child_process";
 
 // src/commands/sessions/summarise/iterateUserMessages.ts
-import * as fs34 from "fs";
+import * as fs33 from "fs";
 
 // src/commands/sessions/summarise/parseUserLine.ts
 function parseUserLine(line) {
@@ -20758,13 +21243,13 @@ function parseUserLine(line) {
 function* iterateUserMessages(filePath, maxBytes = 65536) {
   let content;
   try {
-    const fd = fs34.openSync(filePath, "r");
+    const fd = fs33.openSync(filePath, "r");
     try {
       const buf = Buffer.alloc(maxBytes);
-      const bytesRead = fs34.readSync(fd, buf, 0, buf.length, 0);
+      const bytesRead = fs33.readSync(fd, buf, 0, buf.length, 0);
       content = buf.toString("utf8", 0, bytesRead);
     } finally {
-      fs34.closeSync(fd);
+      fs33.closeSync(fd);
     }
   } catch {
     return;
@@ -20862,29 +21347,29 @@ ${firstMessage}`);
 async function summarise3(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk170.yellow("No sessions found."));
+    console.log(chalk171.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk170.green("All sessions already summarised."));
+    console.log(chalk171.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk170.cyan(
+    chalk171.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk170.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk170.yellow(`, ${failed2} skipped`) : "")
+    chalk171.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk171.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs35.statSync(b).mtimeMs - fs35.statSync(a).mtimeMs;
+      return fs34.statSync(b).mtimeMs - fs34.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -20897,16 +21382,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk170.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk171.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk170.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk171.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk170.yellow("skip")}
+      process.stdout.write(` ${chalk171.yellow("skip")}
 `);
     }
   }
@@ -20924,10 +21409,10 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk172 from "chalk";
+import chalk173 from "chalk";
 
 // src/commands/buildLimitsSegment.ts
-import chalk171 from "chalk";
+import chalk172 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -20958,9 +21443,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk171.green,
-  warn: chalk171.yellow,
-  over: chalk171.red
+  ok: chalk172.green,
+  warn: chalk172.yellow,
+  over: chalk172.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -21000,14 +21485,14 @@ async function relayRateLimits(rateLimits) {
 }
 
 // src/commands/statusLine.ts
-chalk172.level = 3;
+chalk173.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
 function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
-  if (pct > 80) return chalk172.red(label2);
-  if (pct > 40) return chalk172.yellow(label2);
+  if (pct > 80) return chalk173.red(label2);
+  if (pct > 40) return chalk173.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -21023,29 +21508,29 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs38 from "fs";
+import * as fs37 from "fs";
 import * as os2 from "os";
-import * as path56 from "path";
+import * as path55 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs36 from "fs";
-import * as path54 from "path";
-import chalk173 from "chalk";
+import * as fs35 from "fs";
+import * as path53 from "path";
+import chalk174 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path54.join(claudeDir, "CLAUDE.md");
-  const target = path54.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs36.readFileSync(source, "utf8");
-  if (fs36.existsSync(target)) {
-    const targetContent = fs36.readFileSync(target, "utf8");
+  const source = path53.join(claudeDir, "CLAUDE.md");
+  const target = path53.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs35.readFileSync(source, "utf8");
+  if (fs35.existsSync(target)) {
+    const targetContent = fs35.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk173.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk174.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = options2?.yes || await promptConfirm(
-        chalk173.red("Overwrite existing CLAUDE.md?"),
+        chalk174.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -21054,21 +21539,21 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs36.copyFileSync(source, target);
+  fs35.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs37 from "fs";
-import * as path55 from "path";
-import chalk174 from "chalk";
+import * as fs36 from "fs";
+import * as path54 from "path";
+import chalk175 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path55.join(claudeDir, "settings.json");
-  const target = path55.join(targetBase, "settings.json");
-  const sourceContent = fs37.readFileSync(source, "utf8");
+  const source = path54.join(claudeDir, "settings.json");
+  const target = path54.join(targetBase, "settings.json");
+  const sourceContent = fs36.readFileSync(source, "utf8");
   const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
-  if (fs37.existsSync(target)) {
-    const targetContent = fs37.readFileSync(target, "utf8");
+  if (fs36.existsSync(target)) {
+    const targetContent = fs36.readFileSync(target, "utf8");
     const normalizedTarget = JSON.stringify(
       JSON.parse(targetContent),
       null,
@@ -21077,14 +21562,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk174.yellow(
+          chalk175.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk174.red("Overwrite existing settings.json?"),
+          chalk175.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -21094,37 +21579,37 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs37.writeFileSync(target, mergedContent);
+  fs36.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath7(import.meta.url);
-var __dirname6 = path56.dirname(__filename4);
+var __dirname6 = path55.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path56.join(__dirname6, "..", "claude");
-  const targetBase = path56.join(os2.homedir(), ".claude");
+  const claudeDir = path55.join(__dirname6, "..", "claude");
+  const targetBase = path55.join(os2.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   await syncClaudeMd(claudeDir, targetBase, { yes });
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path56.join(claudeDir, "commands");
-  const targetDir = path56.join(targetBase, "commands");
-  fs38.mkdirSync(targetDir, { recursive: true });
-  const files = fs38.readdirSync(sourceDir);
+  const sourceDir = path55.join(claudeDir, "commands");
+  const targetDir = path55.join(targetBase, "commands");
+  fs37.mkdirSync(targetDir, { recursive: true });
+  const files = fs37.readdirSync(sourceDir);
   for (const file of files) {
-    fs38.copyFileSync(path56.join(sourceDir, file), path56.join(targetDir, file));
+    fs37.copyFileSync(path55.join(sourceDir, file), path55.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
 }
 
 // src/commands/update.ts
-import { execSync as execSync49 } from "child_process";
-import * as path57 from "path";
+import { execSync as execSync50 } from "child_process";
+import * as path56 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -21143,12 +21628,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path57.resolve(dir);
-    if (resolved.split(path57.sep).includes("node_modules")) {
+    const resolved = path56.resolve(dir);
+    if (resolved.split(path56.sep).includes("node_modules")) {
       return true;
     }
-    const globalPrefix = execSync49("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path57.resolve(globalPrefix).toLowerCase());
+    const globalPrefix = execSync50("npm prefix -g", { stdio: "pipe" }).toString().trim();
+    return resolved.toLowerCase().startsWith(path56.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }
@@ -21158,18 +21643,18 @@ async function update2() {
   console.log(`Assist is installed at: ${installDir}`);
   if (isGitRepo(installDir)) {
     console.log("Detected git repo installation, pulling latest...");
-    execSync49("git pull", { cwd: installDir, stdio: "inherit" });
+    execSync50("git pull", { cwd: installDir, stdio: "inherit" });
     console.log("Installing dependencies...");
-    execSync49("npm i", { cwd: installDir, stdio: "inherit" });
+    execSync50("npm i", { cwd: installDir, stdio: "inherit" });
     console.log("Building...");
-    execSync49("npm run build", { cwd: installDir, stdio: "inherit" });
+    execSync50("npm run build", { cwd: installDir, stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync49("assist sync", { stdio: "inherit" });
+    execSync50("assist sync", { stdio: "inherit" });
   } else if (isGlobalNpmInstall(installDir)) {
     console.log("Detected global npm installation, updating...");
-    execSync49("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
+    execSync50("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync49("assist sync", { stdio: "inherit" });
+    execSync50("assist sync", { stdio: "inherit" });
   } else {
     console.error(
       "Could not determine installation method. Expected a git repo or global npm install."