@staff0rd/assist 0.305.4 → 0.307.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.305.4",
+  version: "0.307.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -2178,7 +2178,7 @@ function flushIfFailed(exitCode, chunks) {
 
 // src/commands/verify/run/runAllEntries.ts
 function runEntry(entry, onComplete) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const child = spawnCommand(
       entry.fullCommand,
       entry.cwd,
@@ -2190,7 +2190,7 @@ function runEntry(entry, onComplete) {
       const exitCode = code ?? 1;
       flushIfFailed(exitCode, chunks);
       onComplete?.(exitCode);
-      resolve16({ script: entry.name, code: exitCode });
+      resolve17({ script: entry.name, code: exitCode });
     });
   });
 }
@@ -2943,8 +2943,8 @@ function spawnClaude(prompt, options2 = {}) {
     stdio: "inherit",
     env
   });
-  const done2 = new Promise((resolve16, reject) => {
-    child.on("close", (code) => resolve16(code ?? 0));
+  const done2 = new Promise((resolve17, reject) => {
+    child.on("close", (code) => resolve17(code ?? 0));
     child.on("error", reject);
   });
   return { child, done: done2 };
@@ -4752,9 +4752,9 @@ import {
 // src/commands/sessions/daemon/connectToDaemon.ts
 import * as net from "net";
 function connectToDaemon() {
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve17, reject) => {
     const socket = net.connect(daemonPaths.socket);
-    socket.once("connect", () => resolve16(socket));
+    socket.once("connect", () => resolve17(socket));
     socket.once("error", reject);
   });
 }
@@ -4834,7 +4834,7 @@ function spawnDaemon(reason) {
   child.unref();
 }
 function delay(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve17) => setTimeout(resolve17, ms));
 }
 
 // src/commands/sessions/web/handleRequest.ts
@@ -4972,20 +4972,17 @@ async function loadVisibleItems(req) {
   return loaded.filter((item) => !completedStatuses.has(item.status));
 }
 
-// src/commands/backlog/web/parseItemBody.ts
+// src/commands/backlog/web/parseStatusBody.ts
 function readBody(req) {
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve17, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
     });
-    req.on("end", () => resolve16(body));
+    req.on("end", () => resolve17(body));
     req.on("error", reject);
   });
 }
-async function parseItemBody(req) {
-  return JSON.parse(await readBody(req));
-}
 async function parseStatusBody(req) {
   return JSON.parse(await readBody(req));
 }
@@ -5099,22 +5096,6 @@ function validateRewind(item, plan2, phase) {
   return void 0;
 }
 
-// src/commands/backlog/web/updateItem.ts
-import { eq as eq15 } from "drizzle-orm";
-async function updateItem(req, res, id2) {
-  const body = await parseItemBody(req);
-  const result = await findItemOr404(res, id2);
-  if (!result) return;
-  const { orm } = result;
-  await orm.update(items).set({
-    type: body.type ?? result.item.type,
-    name: body.name,
-    description: body.description ?? null,
-    acceptanceCriteria: JSON.stringify(body.acceptanceCriteria ?? [])
-  }).where(eq15(items.id, id2));
-  respondJson(res, 200, await loadItem(orm, id2));
-}
-
 // src/commands/backlog/web/handleItemRoute.ts
 var id = (match, group = 1) => Number.parseInt(match[group], 10);
 var routes = [
@@ -5138,11 +5119,6 @@ var routes = [
     method: "GET",
     run: (_req, res, m) => getItemById(res, id(m))
   },
-  {
-    pattern: /^\/api\/items\/(\d+)$/,
-    method: "PUT",
-    run: (req, res, m) => updateItem(req, res, id(m))
-  },
   {
     pattern: /^\/api\/items\/(\d+)$/,
     method: "PATCH",
@@ -5527,17 +5503,17 @@ async function stopDaemon() {
   }
 }
 function closedBeforeTimeout(socket) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const timer = setTimeout(() => {
       socket.destroy();
-      resolve16(false);
+      resolve17(false);
     }, STOP_TIMEOUT_MS);
     socket.resume();
     socket.on("error", () => {
     });
     socket.once("close", () => {
       clearTimeout(timer);
-      resolve16(true);
+      resolve17(true);
     });
   });
 }
@@ -5588,8 +5564,8 @@ async function restartWeb(req, res, deps2 = {}) {
     respondJson(res, 400, { error: "Invalid target" });
     return;
   }
-  await new Promise((resolve16) => {
-    res.once("finish", resolve16);
+  await new Promise((resolve17) => {
+    res.once("finish", resolve17);
     respondJson(res, 200, { ok: true });
   });
   if (target === "daemon" || target === "both") {
@@ -6486,22 +6462,22 @@ async function add(options2) {
 import chalk58 from "chalk";
 
 // src/commands/backlog/insertPhaseAt.ts
-import { count, eq as eq17 } from "drizzle-orm";
+import { count, eq as eq16 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and3, desc as desc2, eq as eq16, gte } from "drizzle-orm";
+import { and as and3, desc as desc2, eq as eq15, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and3(eq16(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc2(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and3(eq15(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc2(planPhases.idx));
   for (const p of toShift) {
-    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and3(eq16(planTasks.itemId, itemId), eq16(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and3(eq16(planPhases.itemId, itemId), eq16(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and3(eq15(planTasks.itemId, itemId), eq15(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and3(eq15(planPhases.itemId, itemId), eq15(planPhases.idx, p.idx)));
   }
 }
 
 // src/commands/backlog/insertPhaseAt.ts
 async function insertPhaseAt(orm, itemId, phaseIdx, name, tasks, manualChecks, currentPhase) {
   await orm.transaction(async (tx) => {
-    const [row] = await tx.select({ cnt: count() }).from(planPhases).where(eq17(planPhases.itemId, itemId));
+    const [row] = await tx.select({ cnt: count() }).from(planPhases).where(eq16(planPhases.itemId, itemId));
     const phaseCount = row?.cnt ?? 0;
     await shiftPhasesUp(tx, itemId, phaseIdx);
     await tx.insert(planPhases).values({ itemId, idx: phaseIdx, name, manualChecks });
@@ -6510,16 +6486,16 @@ async function insertPhaseAt(orm, itemId, phaseIdx, name, tasks, manualChecks, c
     }
     if (currentPhase !== void 0 && currentPhase - 1 >= phaseIdx) {
       const atReviewSlot = currentPhase - 1 >= phaseCount;
-      await tx.update(items).set({ currentPhase: atReviewSlot ? phaseIdx + 1 : currentPhase + 1 }).where(eq17(items.id, itemId));
+      await tx.update(items).set({ currentPhase: atReviewSlot ? phaseIdx + 1 : currentPhase + 1 }).where(eq16(items.id, itemId));
     }
   });
 }
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk57 from "chalk";
-import { count as count2, eq as eq18 } from "drizzle-orm";
+import { count as count2, eq as eq17 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId, position) {
-  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(eq18(planPhases.itemId, itemId));
+  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(eq17(planPhases.itemId, itemId));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -6680,9 +6656,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq19 } from "drizzle-orm";
+import { eq as eq18 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq19(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq18(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId, targetId } of rows) {
     const bucket = graph.get(itemId);
@@ -6745,7 +6721,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk62 from "chalk";
-import { and as and4, eq as eq20 } from "drizzle-orm";
+import { and as and4, eq as eq19 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = Number.parseInt(fromId, 10);
   const toNum = Number.parseInt(toId, 10);
@@ -6763,7 +6739,7 @@ async function unlink(fromId, toId) {
     console.log(chalk62.yellow(`No link from #${fromId} to #${toId} found.`));
     return;
   }
-  await orm.delete(links).where(and4(eq20(links.itemId, fromNum), eq20(links.targetId, toNum)));
+  await orm.delete(links).where(and4(eq19(links.itemId, fromNum), eq19(links.targetId, toNum)));
   console.log(chalk62.green(`Removed link from #${fromId} to #${toId}.`));
 }
 
@@ -6779,7 +6755,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/move-repo/index.ts
 import chalk64 from "chalk";
-import { eq as eq22 } from "drizzle-orm";
+import { eq as eq21 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk63 from "chalk";
@@ -6794,9 +6770,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count3, eq as eq21 } from "drizzle-orm";
+import { count as count3, eq as eq20 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count3() }).from(items).where(eq21(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count3() }).from(items).where(eq20(items.origin, origin));
   return cnt;
 }
 
@@ -6839,7 +6815,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk64.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq22(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq21(items.origin, oldOrigin));
   console.log(
     chalk64.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -7173,10 +7149,10 @@ async function start(id2) {
 
 // src/commands/backlog/stop/index.ts
 import chalk75 from "chalk";
-import { and as and5, eq as eq23 } from "drizzle-orm";
+import { and as and5, eq as eq22 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
-  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and5(eq23(items.status, "in-progress"), eq23(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and5(eq22(items.status, "in-progress"), eq22(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
     console.log(chalk75.yellow("No in-progress items to stop."));
     return;
@@ -7222,18 +7198,18 @@ function registerStatusCommands(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk79 from "chalk";
-import { and as and8, eq as eq26 } from "drizzle-orm";
+import { and as and8, eq as eq25 } from "drizzle-orm";
 
 // src/commands/backlog/findPhase.ts
 import chalk78 from "chalk";
-import { and as and6, count as count4, eq as eq24 } from "drizzle-orm";
+import { and as and6, count as count4, eq as eq23 } from "drizzle-orm";
 async function findPhase(id2, phase) {
   const found = await findOneItem(id2);
   if (!found) return void 0;
   const { orm, item } = found;
   const itemId = item.id;
   const phaseIdx = Number.parseInt(phase, 10) - 1;
-  const [row] = await orm.select({ cnt: count4() }).from(planPhases).where(and6(eq24(planPhases.itemId, itemId), eq24(planPhases.idx, phaseIdx)));
+  const [row] = await orm.select({ cnt: count4() }).from(planPhases).where(and6(eq23(planPhases.itemId, itemId), eq23(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
       chalk78.red(`Phase ${phaseIdx + 1} not found on item #${itemId}.`)
@@ -7245,14 +7221,14 @@ async function findPhase(id2, phase) {
 }
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and7, asc as asc6, count as count5, eq as eq25 } from "drizzle-orm";
+import { and as and7, asc as asc6, count as count5, eq as eq24 } from "drizzle-orm";
 async function reindexPhases(db, itemId) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq25(planPhases.itemId, itemId)).orderBy(asc6(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq24(planPhases.itemId, itemId)).orderBy(asc6(planPhases.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
-    await db.update(planTasks).set({ phaseIdx: i }).where(and7(eq25(planTasks.itemId, itemId), eq25(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and7(eq25(planPhases.itemId, itemId), eq25(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and7(eq24(planTasks.itemId, itemId), eq24(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and7(eq24(planPhases.itemId, itemId), eq24(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -7260,13 +7236,13 @@ async function adjustCurrentPhase(db, item, removedIdx) {
   if (currentPhase === void 0) return;
   const currentIdx = currentPhase - 1;
   if (removedIdx < currentIdx) {
-    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq25(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq24(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq25(planPhases.itemId, item.id));
+  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq24(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq25(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq24(items.id, item.id));
 }
 
 // src/commands/backlog/removePhase.ts
@@ -7276,9 +7252,9 @@ async function removePhase(id2, phase) {
   const { item, orm, itemId, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and8(eq26(planTasks.itemId, itemId), eq26(planTasks.phaseIdx, phaseIdx))
+      and8(eq25(planTasks.itemId, itemId), eq25(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and8(eq26(planPhases.itemId, itemId), eq26(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and8(eq25(planPhases.itemId, itemId), eq25(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
@@ -7289,7 +7265,7 @@ async function removePhase(id2, phase) {
 
 // src/commands/backlog/update/index.ts
 import chalk81 from "chalk";
-import { eq as eq27 } from "drizzle-orm";
+import { eq as eq26 } from "drizzle-orm";
 
 // src/commands/backlog/update/parseListIndex.ts
 function parseListIndex(raw, length, label2) {
@@ -7423,7 +7399,7 @@ async function update(id2, options2) {
   if (!built) return;
   const { orm } = found;
   const itemId = found.item.id;
-  await orm.update(items).set(built.set).where(eq27(items.id, itemId));
+  await orm.update(items).set(built.set).where(eq26(items.id, itemId));
   console.log(chalk81.green(`Updated ${built.fields} on item #${itemId}.`));
 }
 
@@ -7431,22 +7407,22 @@ async function update(id2, options2) {
 import chalk82 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and9, eq as eq28 } from "drizzle-orm";
+import { and as and9, eq as eq27 } from "drizzle-orm";
 async function applyPhaseUpdate(orm, itemId, phaseIdx, fields) {
   await orm.transaction(async (tx) => {
     if (fields.name) {
       await tx.update(planPhases).set({ name: fields.name }).where(
-        and9(eq28(planPhases.itemId, itemId), eq28(planPhases.idx, phaseIdx))
+        and9(eq27(planPhases.itemId, itemId), eq27(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and9(eq28(planPhases.itemId, itemId), eq28(planPhases.idx, phaseIdx))
+        and9(eq27(planPhases.itemId, itemId), eq27(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and9(eq28(planTasks.itemId, itemId), eq28(planTasks.phaseIdx, phaseIdx))
+        and9(eq27(planTasks.itemId, itemId), eq27(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -8363,12 +8339,12 @@ function hasSubcommands(helpText) {
 // src/commands/permitCliReads/runHelp.ts
 import { exec as exec2 } from "child_process";
 function runHelp(args) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     exec2(
       `${args.join(" ")} --help`,
       { encoding: "utf8", timeout: 3e4 },
       (_err, stdout, stderr) => {
-        resolve16(stdout || stderr || "");
+        resolve17(stdout || stderr || "");
       }
     );
   });
@@ -10755,9 +10731,9 @@ function registerGithub(program2) {
 }
 
 // src/commands/handover/countPendingHandovers.ts
-import { and as and10, eq as eq29, isNull, sql as sql3 } from "drizzle-orm";
+import { and as and10, eq as eq28, isNull, sql as sql3 } from "drizzle-orm";
 async function countPendingHandovers(orm, origin) {
-  const [row] = await orm.select({ count: sql3`count(*)::int` }).from(handovers).where(and10(eq29(handovers.origin, origin), isNull(handovers.recalledAt)));
+  const [row] = await orm.select({ count: sql3`count(*)::int` }).from(handovers).where(and10(eq28(handovers.origin, origin), isNull(handovers.recalledAt)));
   return row?.count ?? 0;
 }
 
@@ -10897,13 +10873,13 @@ async function load(options2 = {}) {
 }
 
 // src/commands/handover/listPendingHandovers.ts
-import { and as and11, desc as desc3, eq as eq30, isNull as isNull2 } from "drizzle-orm";
+import { and as and11, desc as desc3, eq as eq29, isNull as isNull2 } from "drizzle-orm";
 async function listPendingHandovers(orm, origin) {
   return orm.select({
     id: handovers.id,
     summary: handovers.summary,
     createdAt: handovers.createdAt
-  }).from(handovers).where(and11(eq30(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc3(handovers.createdAt), desc3(handovers.id));
+  }).from(handovers).where(and11(eq29(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc3(handovers.createdAt), desc3(handovers.id));
 }
 
 // src/commands/handover/printPendingHandovers.ts
@@ -10916,17 +10892,17 @@ async function printPendingHandovers() {
 }
 
 // src/commands/handover/recallHandover.ts
-import { and as and12, desc as desc4, eq as eq31, isNull as isNull3 } from "drizzle-orm";
+import { and as and12, desc as desc4, eq as eq30, isNull as isNull3 } from "drizzle-orm";
 async function recallHandover(orm, origin, id2) {
   const [row] = await orm.select().from(handovers).where(
     and12(
-      eq31(handovers.origin, origin),
+      eq30(handovers.origin, origin),
       isNull3(handovers.recalledAt),
-      ...id2 === void 0 ? [] : [eq31(handovers.id, id2)]
+      ...id2 === void 0 ? [] : [eq30(handovers.id, id2)]
     )
   ).orderBy(desc4(handovers.createdAt), desc4(handovers.id)).limit(1);
   if (!row) return void 0;
-  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq31(handovers.id, row.id));
+  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq30(handovers.id, row.id));
   return row.content;
 }
 
@@ -11356,8 +11332,666 @@ function registerMermaid(program2) {
   );
 }
 
-// src/commands/news/add/index.ts
+// src/commands/netcap/netcap.ts
+import { mkdir } from "fs/promises";
+import { createServer as createServer2 } from "http";
+import { dirname as dirname20 } from "path";
+import chalk124 from "chalk";
+
+// src/commands/netcap/corsHeaders.ts
+var corsHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type",
+  "Access-Control-Max-Age": "86400"
+};
+
+// src/commands/netcap/handleNetcapPost.ts
+import { appendFile } from "fs/promises";
+
+// src/commands/netcap/parseNetcapEntry.ts
+function parseNetcapEntry(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/netcap/handleNetcapPost.ts
+function handleNetcapPost(req, res, options2) {
+  let body = "";
+  req.on("data", (chunk) => {
+    body += chunk;
+  });
+  req.on("end", () => {
+    const entry = parseNetcapEntry(body);
+    if (!entry) {
+      res.writeHead(400, corsHeaders);
+      res.end();
+      return;
+    }
+    void appendFile(options2.outPath, `${JSON.stringify(entry)}
+`).then(() => {
+      options2.onCapture?.(entry);
+      res.writeHead(200, {
+        ...corsHeaders,
+        "Content-Type": "application/json"
+      });
+      res.end(JSON.stringify({ ok: true }));
+    }).catch((error) => {
+      res.writeHead(500, corsHeaders);
+      res.end(String(error));
+    });
+  });
+}
+
+// src/commands/netcap/createNetcapHandler.ts
+function createNetcapHandler(options2) {
+  return (req, res) => {
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, corsHeaders);
+      res.end();
+      return;
+    }
+    if (req.method === "GET") {
+      options2.onPing?.(req);
+      res.writeHead(200, { ...corsHeaders, "Content-Type": "text/plain" });
+      res.end("netcap receiver");
+      return;
+    }
+    if (req.method !== "POST") {
+      res.writeHead(405, corsHeaders);
+      res.end();
+      return;
+    }
+    handleNetcapPost(req, res, options2);
+  };
+}
+
+// src/commands/netcap/prepareExtensionForLoad.ts
+import { cp, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { networkInterfaces } from "os";
+import { join as join35 } from "path";
 import chalk123 from "chalk";
+
+// src/commands/netcap/netcapExtensionDir.ts
+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 join34(moduleDir, "commands", "netcap", "netcap-extension");
+}
+
+// src/commands/netcap/prepareExtensionForLoad.ts
+var WSL_WINDOWS_DIR = "/mnt/c/tools/netcap-extension";
+var WSL_WINDOWS_PATH = String.raw`C:\tools\netcap-extension`;
+function lanIPv4() {
+  for (const addrs of Object.values(networkInterfaces())) {
+    for (const addr of addrs ?? []) {
+      if (addr.family === "IPv4" && !addr.internal) return addr.address;
+    }
+  }
+  return void 0;
+}
+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, filter = "") {
+  const source = netcapExtensionDir();
+  if (detectPlatform() !== "wsl") {
+    await configureBackground(source, "127.0.0.1", port, filter);
+    return source;
+  }
+  const host = lanIPv4();
+  if (!host) {
+    console.log(
+      chalk123.yellow("could not determine the WSL IP for the extension")
+    );
+    await configureBackground(source, "127.0.0.1", port, filter);
+    return source;
+  }
+  try {
+    await cp(source, WSL_WINDOWS_DIR, { recursive: true });
+    await configureBackground(WSL_WINDOWS_DIR, host, port, filter);
+    return WSL_WINDOWS_PATH;
+  } catch {
+    console.log(
+      chalk123.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
+    );
+    return source;
+  }
+}
+
+// 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 = resolveNetcapOutPath(options2.out);
+  const filter = options2.filter ?? "";
+  await mkdir(dirname20(outPath), { recursive: true });
+  const extensionPath = await prepareExtensionForLoad(port, filter);
+  let count6 = 0;
+  const handler = createNetcapHandler({
+    outPath,
+    onPing: () => console.log(chalk124.dim("ping from extension")),
+    onCapture: (entry) => {
+      count6 += 1;
+      console.log(
+        chalk124.green(`captured #${count6}`),
+        chalk124.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
+      );
+    }
+  });
+  const server = createServer2(handler);
+  server.listen(port, () => {
+    console.log(
+      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, ...path58] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    let v = rows[id2];
+    for (const key of path58) {
+      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, resolve17, sink, seen) {
+  if (v == null) return;
+  if (typeof v === "string") {
+    if (isRscRef(v)) {
+      if (!seen.has(v)) {
+        seen.add(v);
+        collectRscText(resolve17(v), resolve17, 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, resolve17, sink, seen);
+    return;
+  }
+  if (typeof v === "object") {
+    for (const val of Object.values(v)) {
+      collectRscText(val, resolve17, 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, resolve17) {
+  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, resolve17, 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, resolve17, raw) {
+  if (v == null || typeof v !== "object") return;
+  if (Array.isArray(v)) {
+    for (const x of v) walkPostRow(x, resolve17, 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, resolve17, sink, /* @__PURE__ */ new Set());
+  }
+  for (const val of Object.values(o)) walkPostRow(val, resolve17, 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 resolve17 = makeRscResolver(rows);
+  const mentionMap = buildMentionMap(rows, resolve17);
+  const posts = [];
+  for (const id2 of findCommentaryRows(rows)) {
+    const raw = {
+      text: [],
+      hashtags: [],
+      profileUrls: [],
+      links: [],
+      related: []
+    };
+    walkPostRow(rows[id2], resolve17, 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) {
+  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").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 chalk126 from "chalk";
 import enquirer8 from "enquirer";
 async function add2(url) {
   if (!url) {
@@ -11379,10 +12013,10 @@ async function add2(url) {
   const { orm } = await getReady();
   const added = await addFeed(orm, url);
   if (!added) {
-    console.log(chalk123.yellow("Feed already exists"));
+    console.log(chalk126.yellow("Feed already exists"));
     return;
   }
-  console.log(chalk123.green(`Added feed: ${url}`));
+  console.log(chalk126.green(`Added feed: ${url}`));
 }
 
 // src/commands/registerNews.ts
@@ -11392,7 +12026,7 @@ function registerNews(program2) {
 }
 
 // src/commands/prompts/printPromptsTable.ts
-import chalk124 from "chalk";
+import chalk127 from "chalk";
 function truncate(str, max) {
   if (str.length <= max) return str;
   return `${str.slice(0, max - 1)}\u2026`;
@@ -11410,14 +12044,14 @@ function printPromptsTable(rows) {
     "Command".padEnd(commandWidth),
     "Repos"
   ].join("  ");
-  console.log(chalk124.dim(header));
-  console.log(chalk124.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(
-      `${chalk124.yellow(count6)}  ${tool}  ${command}  ${chalk124.dim(row.repos)}`
+      `${chalk127.yellow(count6)}  ${tool}  ${command}  ${chalk127.dim(row.repos)}`
     );
   }
 }
@@ -11765,23 +12399,23 @@ import { execSync as execSync33 } 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 { unlinkSync as unlinkSync10, writeFileSync as writeFileSync27 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join35 } 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 join34 } 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 join34(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) {
@@ -11801,8 +12435,8 @@ function replyToComment(org, repo, prNumber, commentId, message) {
 }
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join35(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
-  writeFileSync26(queryFile, mutation);
+  const queryFile = join40(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
+  writeFileSync27(queryFile, mutation);
   try {
     execSync32(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
@@ -11883,19 +12517,19 @@ 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 join37 } 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 { unlinkSync as unlinkSync11, writeFileSync as writeFileSync28 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join36 } 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 = join36(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(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
@@ -11963,20 +12597,20 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 }
 
 // src/commands/prs/listComments/printComments.ts
-import chalk125 from "chalk";
+import chalk128 from "chalk";
 function formatForHuman(comment3) {
   if (comment3.type === "review") {
-    const stateColor = comment3.state === "APPROVED" ? chalk125.green : comment3.state === "CHANGES_REQUESTED" ? chalk125.red : chalk125.yellow;
+    const stateColor = comment3.state === "APPROVED" ? chalk128.green : comment3.state === "CHANGES_REQUESTED" ? chalk128.red : chalk128.yellow;
     return [
-      `${chalk125.cyan("Review")} by ${chalk125.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 [
-    `${chalk125.cyan("Line comment")} by ${chalk125.bold(comment3.user)} on ${chalk125.dim(`${comment3.path}${location}`)}`,
-    chalk125.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");
@@ -12008,7 +12642,7 @@ function printComments2(result) {
 
 // src/commands/prs/listComments/index.ts
 function writeCommentsCache(prNumber, comments3) {
-  const assistDir = join37(process.cwd(), ".assist");
+  const assistDir = join42(process.cwd(), ".assist");
   if (!existsSync34(assistDir)) {
     mkdirSync13(assistDir, { recursive: true });
   }
@@ -12017,8 +12651,8 @@ function writeCommentsCache(prNumber, comments3) {
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  const cachePath = join37(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)) {
@@ -12050,7 +12684,7 @@ async function listComments() {
     ];
     updateCache(prNumber, allComments);
     const hasLineComments = allComments.some((c) => c.type === "line");
-    const cachePath = hasLineComments ? join37(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);
@@ -12066,13 +12700,13 @@ import { execSync as execSync36 } from "child_process";
 import enquirer9 from "enquirer";
 
 // src/commands/prs/prs/displayPaginated/printPr.ts
-import chalk126 from "chalk";
+import chalk129 from "chalk";
 var STATUS_MAP = {
-  MERGED: (pr) => pr.mergedAt ? { label: chalk126.magenta("merged"), date: pr.mergedAt } : null,
-  CLOSED: (pr) => pr.closedAt ? { label: chalk126.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: chalk126.green("opened"), date: pr.createdAt };
+  return { label: chalk129.green("opened"), date: pr.createdAt };
 }
 function getStatus2(pr) {
   return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -12081,11 +12715,11 @@ function formatDate(dateStr) {
   return new Date(dateStr).toISOString().split("T")[0];
 }
 function formatPrHeader(pr, status2) {
-  return `${chalk126.cyan(`#${pr.number}`)} ${pr.title} ${chalk126.dim(`(${pr.author.login},`)} ${status2.label} ${chalk126.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(
-    chalk126.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
+    chalk129.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
   console.log();
 }
@@ -12364,10 +12998,10 @@ function registerPrs(program2) {
 }
 
 // src/commands/ravendb/ravendbAuth.ts
-import chalk132 from "chalk";
+import chalk135 from "chalk";
 
 // src/shared/createConnectionAuth.ts
-import chalk127 from "chalk";
+import chalk130 from "chalk";
 function listConnections(connections, format2) {
   if (connections.length === 0) {
     console.log("No connections configured.");
@@ -12380,7 +13014,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(chalk127.red(`Connection "${name}" not found.`));
+    console.error(chalk130.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   save(filtered);
@@ -12426,15 +13060,15 @@ function saveConnections(connections) {
 }
 
 // src/commands/ravendb/promptConnection.ts
-import chalk130 from "chalk";
+import chalk133 from "chalk";
 
 // src/commands/ravendb/selectOpSecret.ts
-import chalk129 from "chalk";
+import chalk132 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
 import { execSync as execSync39 } from "child_process";
-import chalk128 from "chalk";
+import chalk131 from "chalk";
 function opExec(args) {
   return execSync39(`op ${args}`, {
     encoding: "utf8",
@@ -12447,7 +13081,7 @@ function searchItems(search2) {
     items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
-      chalk128.red(
+      chalk131.red(
         "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
       )
     );
@@ -12461,7 +13095,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(chalk128.red("Failed to get item details from 1Password."));
+    console.error(chalk131.red("Failed to get item details from 1Password."));
     process.exit(1);
   }
 }
@@ -12480,7 +13114,7 @@ async function selectOpSecret(searchTerm) {
   }).run();
   const items2 = searchItems(search2);
   if (items2.length === 0) {
-    console.error(chalk129.red(`No items found matching "${search2}".`));
+    console.error(chalk132.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId = await selectOne(
@@ -12489,7 +13123,7 @@ async function selectOpSecret(searchTerm) {
   );
   const fields = getItemFields(itemId);
   if (fields.length === 0) {
-    console.error(chalk129.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(
@@ -12503,7 +13137,7 @@ async function selectOpSecret(searchTerm) {
 async function promptConnection(existingNames) {
   const name = await promptInput("name", "Connection name:");
   if (existingNames.includes(name)) {
-    console.error(chalk130.red(`Connection "${name}" already exists.`));
+    console.error(chalk133.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput(
@@ -12512,22 +13146,22 @@ async function promptConnection(existingNames) {
   );
   const database = await promptInput("database", "Database name:");
   if (!name || !url || !database) {
-    console.error(chalk130.red("All fields are required."));
+    console.error(chalk133.red("All fields are required."));
     process.exit(1);
   }
   const apiKeyRef = await selectOpSecret();
-  console.log(chalk130.dim(`Using: ${apiKeyRef}`));
+  console.log(chalk133.dim(`Using: ${apiKeyRef}`));
   return { name, url, database, apiKeyRef };
 }
 
 // src/commands/ravendb/ravendbSetConnection.ts
-import chalk131 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(chalk131.red(`Connection "${name}" not found.`));
+    console.error(chalk134.red(`Connection "${name}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -12543,16 +13177,16 @@ function ravendbSetConnection(name) {
 var ravendbAuth = createConnectionAuth({
   load: loadConnections,
   save: saveConnections,
-  format: (c) => `${chalk132.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 chalk136 from "chalk";
+import chalk139 from "chalk";
 
 // src/commands/ravendb/ravenFetch.ts
-import chalk134 from "chalk";
+import chalk137 from "chalk";
 
 // src/commands/ravendb/getAccessToken.ts
 var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -12589,10 +13223,10 @@ ${errorText}`
 
 // src/commands/ravendb/resolveOpSecret.ts
 import { execSync as execSync40 } from "child_process";
-import chalk133 from "chalk";
+import chalk136 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
-    console.error(chalk133.red(`Invalid secret reference: must start with op://`));
+    console.error(chalk136.red(`Invalid secret reference: must start with op://`));
     process.exit(1);
   }
   try {
@@ -12602,7 +13236,7 @@ function resolveOpSecret(reference) {
     }).trim();
   } catch {
     console.error(
-      chalk133.red(
+      chalk136.red(
         "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
       )
     );
@@ -12629,7 +13263,7 @@ async function ravenFetch(connection, path58) {
   if (!response.ok) {
     const body = await response.text();
     console.error(
-      chalk134.red(`RavenDB error: ${response.status} ${response.statusText}`)
+      chalk137.red(`RavenDB error: ${response.status} ${response.statusText}`)
     );
     console.error(body.substring(0, 500));
     process.exit(1);
@@ -12638,7 +13272,7 @@ async function ravenFetch(connection, path58) {
 }
 
 // src/commands/ravendb/resolveConnection.ts
-import chalk135 from "chalk";
+import chalk138 from "chalk";
 function loadRavendb() {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb;
@@ -12652,7 +13286,7 @@ function resolveConnection(name) {
   const connectionName = name ?? defaultConnection;
   if (!connectionName) {
     console.error(
-      chalk135.red(
+      chalk138.red(
         "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
       )
     );
@@ -12660,7 +13294,7 @@ function resolveConnection(name) {
   }
   const connection = connections.find((c) => c.name === connectionName);
   if (!connection) {
-    console.error(chalk135.red(`Connection "${connectionName}" not found.`));
+    console.error(chalk138.red(`Connection "${connectionName}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -12691,15 +13325,15 @@ async function ravendbCollections(connectionName) {
     return;
   }
   for (const c of collections) {
-    console.log(`${chalk136.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+    console.log(`${chalk139.bold(c.Name)}  ${c.CountOfDocuments} docs`);
   }
 }
 
 // src/commands/ravendb/ravendbQuery.ts
-import chalk138 from "chalk";
+import chalk141 from "chalk";
 
 // src/commands/ravendb/fetchAllPages.ts
-import chalk137 from "chalk";
+import chalk140 from "chalk";
 
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
@@ -12737,7 +13371,7 @@ async function fetchAllPages(connection, opts) {
     allResults.push(...results);
     start3 += results.length;
     process.stderr.write(
-      `\r${chalk137.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;
@@ -12752,7 +13386,7 @@ async function fetchAllPages(connection, opts) {
 async function ravendbQuery(connectionName, collection, options2) {
   const resolved = resolveArgs(connectionName, collection);
   if (!resolved.collection && !options2.query) {
-    console.error(chalk138.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;
@@ -12790,7 +13424,7 @@ import { spawn as spawn5 } from "child_process";
 import * as path28 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk139 from "chalk";
+import chalk142 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -12799,43 +13433,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk139.red(`
+  console.error(chalk142.red(`
 Refactor check failed:
 `));
-  console.error(chalk139.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk142.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk139.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk142.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk139.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(chalk139.gray(`    assist refactor ignore <file>
+  console.error(chalk142.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk139.cyan(`
+    console.error(chalk142.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk139.cyan(
+      chalk142.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk139.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(
-      chalk139.cyan(
+      chalk142.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -12933,7 +13567,7 @@ function getViolations(pattern2, options2 = {}, maxLines = DEFAULT_MAX_LINES) {
 
 // src/commands/refactor/check/index.ts
 function runScript(script, cwd) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const child = spawn5("npm", ["run", script], {
       stdio: "pipe",
       shell: true,
@@ -12947,7 +13581,7 @@ function runScript(script, cwd) {
       output += data.toString();
     });
     child.on("close", (code) => {
-      resolve16({ script, code: code ?? 1, output });
+      resolve17({ script, code: code ?? 1, output });
     });
   });
 }
@@ -12991,7 +13625,7 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/extract/index.ts
 import path35 from "path";
-import chalk142 from "chalk";
+import chalk145 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
@@ -13566,23 +14200,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 
 // src/commands/refactor/extract/displayPlan.ts
 import path32 from "path";
-import chalk140 from "chalk";
+import chalk143 from "chalk";
 function section(title) {
   return `
-  ${chalk140.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(`    ${chalk140.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(chalk140.bold(`Extract: ${functionName} \u2192 ${relDest}
+  console.log(chalk143.bold(`Extract: ${functionName} \u2192 ${relDest}
 `));
-  console.log(`  ${chalk140.cyan("Functions to move:")}`);
+  console.log(`  ${chalk143.cyan("Functions to move:")}`);
   for (const name of plan2.extractedNames) {
     console.log(`    ${name}`);
   }
@@ -13616,7 +14250,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import path34 from "path";
-import chalk141 from "chalk";
+import chalk144 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
@@ -13676,7 +14310,7 @@ function loadProjectFile(file) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk141.red(`File not found in project: ${file}`));
+    console.log(chalk144.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   return { project, sourceFile };
@@ -13699,19 +14333,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(chalk142.green("\nExtraction complete"));
+    console.log(chalk145.green("\nExtraction complete"));
   } else {
-    console.log(chalk142.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 chalk143 from "chalk";
+import chalk146 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
   if (!fs22.existsSync(file)) {
-    console.error(chalk143.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");
@@ -13727,7 +14361,7 @@ function ignore(file) {
     fs22.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk143.green(
+    chalk146.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -13736,12 +14370,12 @@ function ignore(file) {
 // src/commands/refactor/rename/index.ts
 import fs25 from "fs";
 import path40 from "path";
-import chalk146 from "chalk";
+import chalk149 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs24 from "fs";
 import path37 from "path";
-import chalk144 from "chalk";
+import chalk147 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
 import path36 from "path";
@@ -13846,13 +14480,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs24.writeFileSync(file, content, "utf8");
-    console.log(chalk144.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(
-    chalk144.white(
+    chalk147.white(
       `  Moved ${path37.relative(cwd, sourcePath)} \u2192 ${path37.relative(cwd, destPath)}`
     )
   );
@@ -13939,16 +14573,16 @@ function computeRenameRewrites(sourcePath, destPath) {
 
 // src/commands/refactor/rename/printRenamePreview.ts
 import path39 from "path";
-import chalk145 from "chalk";
+import chalk148 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
-      chalk145.dim(
+      chalk148.dim(
         `  ${path39.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
-  console.log(chalk145.dim("Dry run. Use --apply to execute."));
+  console.log(chalk148.dim("Dry run. Use --apply to execute."));
 }
 
 // src/commands/refactor/rename/index.ts
@@ -13959,20 +14593,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(chalk146.red(`File not found: ${source}`));
+    console.log(chalk149.red(`File not found: ${source}`));
     process.exit(1);
   }
   if (destPath !== sourcePath && fs25.existsSync(destPath)) {
-    console.log(chalk146.red(`Destination already exists: ${destination}`));
+    console.log(chalk149.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
-  console.log(chalk146.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  console.log(chalk146.dim("Loading project..."));
-  console.log(chalk146.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(
-    chalk146.dim(
+    chalk149.dim(
       `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
     )
   );
@@ -13981,11 +14615,11 @@ async function rename(source, destination, options2 = {}) {
     return;
   }
   applyRename(rewrites, sourcePath, destPath, cwd);
-  console.log(chalk146.green("Done"));
+  console.log(chalk149.green("Done"));
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import chalk147 from "chalk";
+import chalk150 from "chalk";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
 import { SyntaxKind as SyntaxKind14 } from "ts-morph";
@@ -14031,33 +14665,33 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const { project, sourceFile } = loadProjectFile(file);
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk147.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(
-    chalk147.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk150.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines] of grouped) {
     console.log(
-      `  ${chalk147.dim(refFile)}: lines ${chalk147.cyan(lines.join(", "))}`
+      `  ${chalk150.dim(refFile)}: lines ${chalk150.cyan(lines.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk147.green(`
+    console.log(chalk150.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk147.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 chalk150 from "chalk";
+import chalk153 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
 import path42 from "path";
@@ -14136,50 +14770,50 @@ function clusterFiles(graph) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path44 from "path";
-import chalk148 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(chalk148.bold("\nFile moves:"));
+  console.log(chalk151.bold("\nFile moves:"));
   for (const move of plan2.moves) {
     console.log(
-      `  ${chalk148.red(relPath(move.from))} \u2192 ${chalk148.green(relPath(move.to))}`
+      `  ${chalk151.red(relPath(move.from))} \u2192 ${chalk151.green(relPath(move.to))}`
     );
-    console.log(chalk148.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(chalk148.bold(`
+  console.log(chalk151.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk148.cyan(relPath(file))}:`);
+    console.log(`  ${chalk151.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk148.red(`"${oldSpecifier}"`)} \u2192 ${chalk148.green(`"${newSpecifier}"`)}`
+        `    ${chalk151.red(`"${oldSpecifier}"`)} \u2192 ${chalk151.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk148.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk148.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(chalk148.bold("\nNew directories:"));
+    console.log(chalk151.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk148.green(`  ${dir}/`));
+      console.log(chalk151.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk148.dim(
+    chalk151.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -14189,18 +14823,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 chalk149 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(
-      chalk149.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(chalk149.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);
@@ -14209,7 +14843,7 @@ function executePlan(plan2) {
     }
     fs26.renameSync(move.from, move.to);
     console.log(
-      chalk149.white(
+      chalk152.white(
         `  Moved ${path45.relative(process.cwd(), move.from)} \u2192 ${path45.relative(process.cwd(), move.to)}`
       )
     );
@@ -14224,7 +14858,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs26.rmdirSync(dir);
       console.log(
-        chalk149.dim(
+        chalk152.dim(
           `  Removed empty directory ${path45.relative(process.cwd(), dir)}`
         )
       );
@@ -14357,22 +14991,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk150.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(chalk150.green("No restructuring needed"));
+    console.log(chalk153.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk150.bold("\nApplying changes..."));
+    console.log(chalk153.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk150.green("\nRestructuring complete"));
+    console.log(chalk153.green("\nRestructuring complete"));
   } else {
-    console.log(chalk150.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk153.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -14527,11 +15161,11 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 }
 
 // src/commands/review/buildReviewPaths.ts
-import { homedir as homedir12 } from "os";
-import { basename as basename7, join as join38 } from "path";
+import { homedir as homedir13 } from "os";
+import { basename as basename7, join as join43 } from "path";
 function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join38(
-    homedir12(),
+  const reviewDir = join43(
+    homedir13(),
     ".assist",
     "reviews",
     basename7(repoRoot),
@@ -14539,10 +15173,10 @@ function buildReviewPaths(repoRoot, key) {
   );
   return {
     reviewDir,
-    requestPath: join38(reviewDir, "request.md"),
-    claudePath: join38(reviewDir, "claude.md"),
-    codexPath: join38(reviewDir, "codex.md"),
-    synthesisPath: join38(reviewDir, "synthesis.md")
+    requestPath: join43(reviewDir, "request.md"),
+    claudePath: join43(reviewDir, "claude.md"),
+    codexPath: join43(reviewDir, "codex.md"),
+    synthesisPath: join43(reviewDir, "synthesis.md")
   };
 }
 
@@ -14685,7 +15319,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"];
@@ -14941,18 +15575,18 @@ function partitionFindingsByDiff(findings, index3) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk151 from "chalk";
+import chalk154 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk151.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(
-      `  ${chalk151.yellow("\xB7")} ${finding.title} ${chalk151.dim(
+      `  ${chalk154.yellow("\xB7")} ${finding.title} ${chalk154.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -14971,18 +15605,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk152 from "chalk";
+import chalk155 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk152.yellow(
+    chalk155.yellow(
       `Skipped ${unlocated.length} finding(s) without a parseable file:line:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk152.dim("missing");
+    const where = finding.location || chalk155.dim("missing");
     console.warn(
-      `  ${chalk152.yellow("\xB7")} ${finding.title} ${chalk152.dim(`(${where})`)}`
+      `  ${chalk155.yellow("\xB7")} ${finding.title} ${chalk155.dim(`(${where})`)}`
     );
   }
 }
@@ -14995,7 +15629,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.");
@@ -15077,7 +15711,7 @@ 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);
@@ -15086,7 +15720,7 @@ function clearReviewFiles(paths) {
 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
@@ -15431,7 +16065,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;
@@ -15689,12 +16323,12 @@ function onCloseResult(ctx, code) {
   return { ...closed, stderr: ctx.stderr.value, stdout: ctx.stdout.value };
 }
 function waitForChildExit(ctx) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     let settled = false;
     const settle = (result) => {
       if (settled) return;
       settled = true;
-      resolve16(result);
+      resolve17(result);
     };
     ctx.child.on("error", (err) => settle(onErrorResult(ctx, err)));
     ctx.child.on("close", (code) => settle(onCloseResult(ctx, code)));
@@ -15767,7 +16401,7 @@ async function runClaudeReviewer(spec) {
     }
   });
   if (result.exitCode === 0 && finalText)
-    writeFileSync30(spec.outputPath, finalText);
+    writeFileSync31(spec.outputPath, finalText);
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
 
@@ -15879,7 +16513,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.
@@ -15935,7 +16569,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("");
@@ -16153,7 +16787,7 @@ function registerReview(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk154 from "chalk";
+import chalk157 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -16182,10 +16816,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk153 from "chalk";
+import chalk156 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk153.red(`Connection "${name}" already exists.`));
+    console.error(chalk156.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -16203,16 +16837,16 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk154.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 chalk158 from "chalk";
+import chalk161 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk155 from "chalk";
+import chalk158 from "chalk";
 async function fetchSeq(conn, path58, params) {
   const url = `${conn.url}${path58}?${params}`;
   const response = await fetch(url, {
@@ -16223,7 +16857,7 @@ async function fetchSeq(conn, path58, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk155.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk158.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -16282,23 +16916,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk156 from "chalk";
+import chalk159 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk156.bgRed.white;
+      return chalk159.bgRed.white;
     case "Error":
-      return chalk156.red;
+      return chalk159.red;
     case "Warning":
-      return chalk156.yellow;
+      return chalk159.yellow;
     case "Information":
-      return chalk156.cyan;
+      return chalk159.cyan;
     case "Debug":
-      return chalk156.gray;
+      return chalk159.gray;
     case "Verbose":
-      return chalk156.dim;
+      return chalk159.dim;
     default:
-      return chalk156.white;
+      return chalk159.white;
   }
 }
 function levelAbbrev(level) {
@@ -16339,12 +16973,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk156.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(chalk156.red(`  ${line}`));
+      lines.push(chalk159.red(`  ${line}`));
     }
   }
   return lines.join("\n");
@@ -16377,11 +17011,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk157 from "chalk";
+import chalk160 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk157.red(
+      chalk160.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -16390,7 +17024,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(chalk157.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk160.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -16419,7 +17053,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count6) })
   );
   if (events.length === 0) {
-    console.log(chalk158.yellow("No events found."));
+    console.log(chalk161.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -16430,11 +17064,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk158.dim(`
+  console.log(chalk161.dim(`
 ${events.length} events`));
   if (events.length >= count6) {
     console.log(
-      chalk158.yellow(
+      chalk161.yellow(
         `Results limited to ${count6}. Use --count to retrieve more.`
       )
     );
@@ -16442,10 +17076,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk159 from "chalk";
+import chalk162 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk159.red(`Connection "${name}" not found.`));
+    console.error(chalk162.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -16493,7 +17127,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk161 from "chalk";
+import chalk164 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -16522,7 +17156,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk160 from "chalk";
+import chalk163 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -16530,7 +17164,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk160.red(`Invalid port "${portStr}".`));
+    console.error(chalk163.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -16543,13 +17177,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk161.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 chalk162 from "chalk";
+import chalk165 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -16558,7 +17192,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk162.yellow("(no rows)"));
+    console.log(chalk165.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -16566,13 +17200,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(chalk162.dim(header));
-  console.log(chalk162.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(chalk162.dim(`
+  console.log(chalk165.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -16632,7 +17266,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk163 from "chalk";
+import chalk166 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -16666,7 +17300,7 @@ function isMutation(sql6) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk163.red(
+      chalk166.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -16676,18 +17310,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk163.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 chalk164 from "chalk";
+import chalk167 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk164.red(
+      chalk167.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -16702,7 +17336,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk164.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk167.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -16763,7 +17397,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 join39, 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) {
@@ -16781,7 +17415,7 @@ function collectFiles(dir, extension) {
   if (!existsSync38(dir)) return [];
   const results = [];
   for (const entry of readdirSync7(dir)) {
-    const fullPath = join39(dir, entry);
+    const fullPath = join44(dir, entry);
     if (statSync5(fullPath).isDirectory()) {
       results.push(...collectFiles(fullPath, extension));
     } else if (entry.endsWith(extension)) {
@@ -16813,9 +17447,9 @@ function createReadlineInterface() {
   });
 }
 function askQuestion(rl, question) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     rl.question(question, (answer) => {
-      resolve16(answer.trim());
+      resolve17(answer.trim());
     });
   });
 }
@@ -16878,11 +17512,11 @@ async function configure() {
 import { existsSync as existsSync40 } from "fs";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/index.ts
-import { dirname as dirname20, join as join41 } 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 join40 } 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);
@@ -16897,7 +17531,7 @@ async function resolveDate(rl, choice) {
 }
 function renameWithPrefix(vttDir, vttFile, prefix2) {
   const newFilename = `${prefix2}.${vttFile}`;
-  renameSync2(join40(vttDir, vttFile), join40(vttDir, newFilename));
+  renameSync2(join45(vttDir, vttFile), join45(vttDir, newFilename));
   console.log(`Renamed to: ${newFilename}`);
   return newFilename;
 }
@@ -16928,15 +17562,15 @@ async function fixInvalidDatePrefixes(vttFiles) {
   for (let i = 0; i < vttFiles.length; i++) {
     const vttFile = vttFiles[i];
     if (!isValidDatePrefix(vttFile.filename)) {
-      const vttFileDir = dirname20(vttFile.absolutePath);
+      const vttFileDir = dirname22(vttFile.absolutePath);
       const newFilename = await promptForDateFix(vttFile.filename, vttFileDir);
       if (newFilename) {
-        const newRelativePath = join41(
-          dirname20(vttFile.relativePath),
+        const newRelativePath = join46(
+          dirname22(vttFile.relativePath),
           newFilename
         );
         vttFiles[i] = {
-          absolutePath: join41(vttFileDir, newFilename),
+          absolutePath: join46(vttFileDir, newFilename),
           relativePath: newRelativePath,
           filename: newFilename
         };
@@ -16949,8 +17583,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 dirname21, join as join42 } 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) {
@@ -17160,17 +17794,17 @@ function toMdFilename(vttFilename) {
   return `${basename9(vttFilename, ".vtt").replace(/\s*Transcription\s*/g, " ").trim()}.md`;
 }
 function resolveOutputDir(relativeDir, transcriptsDir) {
-  return relativeDir === "." ? transcriptsDir : join42(transcriptsDir, relativeDir);
+  return relativeDir === "." ? transcriptsDir : join47(transcriptsDir, relativeDir);
 }
 function buildOutputPaths(vttFile, transcriptsDir) {
   const mdFile = toMdFilename(vttFile.filename);
-  const relativeDir = dirname21(vttFile.relativePath);
+  const relativeDir = dirname23(vttFile.relativePath);
   const outputDir = resolveOutputDir(relativeDir, transcriptsDir);
-  const outputPath = join42(outputDir, mdFile);
+  const outputPath = join47(outputDir, mdFile);
   return { outputDir, outputPath, mdFile, relativeDir };
 }
 function logSkipped(relativeDir, mdFile) {
-  console.log(`Skipping (already exists): ${join42(relativeDir, mdFile)}`);
+  console.log(`Skipping (already exists): ${join47(relativeDir, mdFile)}`);
   return "skipped";
 }
 function ensureDirectory(dir, label2) {
@@ -17197,10 +17831,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) {
@@ -17269,27 +17903,27 @@ async function format() {
 
 // src/commands/transcript/summarise/index.ts
 import { existsSync as existsSync42 } from "fs";
-import { basename as basename10, dirname as dirname23, join as join44, 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 dirname22, join as join43 } from "path";
+import { dirname as dirname24, join as join48 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk165 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(
-      chalk165.red(
+      chalk168.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -17298,7 +17932,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk165.red(
+      chalk168.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -17308,7 +17942,7 @@ function validateStagedContent(filename, content) {
 }
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
-var STAGING_DIR = join43(process.cwd(), ".assist", "transcript");
+var STAGING_DIR = join48(process.cwd(), ".assist", "transcript");
 function processStagedFile() {
   if (!existsSync41(STAGING_DIR)) {
     return false;
@@ -17319,7 +17953,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);
@@ -17332,8 +17966,8 @@ function processStagedFile() {
     );
     process.exit(1);
   }
-  const destPath = join43(summaryDir, matchingTranscript.relativePath);
-  const destDir = dirname22(destPath);
+  const destPath = join48(summaryDir, matchingTranscript.relativePath);
+  const destDir = dirname24(destPath);
   if (!existsSync41(destDir)) {
     mkdirSync16(destDir, { recursive: true });
   }
@@ -17347,8 +17981,8 @@ function processStagedFile() {
 
 // src/commands/transcript/summarise/index.ts
 function buildRelativeKey(relativePath, baseName) {
-  const relDir = dirname23(relativePath);
-  return relDir === "." ? baseName : join44(relDir, baseName);
+  const relDir = dirname25(relativePath);
+  return relDir === "." ? baseName : join49(relDir, baseName);
 }
 function buildSummaryIndex(summaryDir) {
   const summaryFiles = findMdFilesRecursive(summaryDir);
@@ -17382,8 +18016,8 @@ function summarise2() {
   }
   const next3 = missing[0];
   const outputFilename = `${getTranscriptBaseName(next3.filename)}.md`;
-  const outputPath = join44(STAGING_DIR, outputFilename);
-  const summaryFileDir = join44(summaryDir, dirname23(next3.relativePath));
+  const outputPath = join49(STAGING_DIR, outputFilename);
+  const summaryFileDir = join49(summaryDir, dirname25(next3.relativePath));
   const relativeTranscriptPath = encodeURI(
     relative3(summaryFileDir, next3.absolutePath).replace(/\\/g, "/")
   );
@@ -17433,50 +18067,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { join as join46 } from "path";
+import { join as join51 } from "path";
 
 // src/commands/voice/shared.ts
-import { homedir as homedir13 } from "os";
-import { dirname as dirname24, join as join45 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
-var __dirname5 = dirname24(fileURLToPath5(import.meta.url));
-var VOICE_DIR = join45(homedir13(), ".assist", "voice");
+import { homedir as homedir14 } from "os";
+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 = join50(homedir14(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join45(VOICE_DIR, "voice.pid"),
-  log: join45(VOICE_DIR, "voice.log"),
-  venv: join45(VOICE_DIR, ".venv"),
-  lock: join45(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 join45(__dirname5, "commands", "voice", "python");
+  return join50(__dirname5, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join45(voicePaths.venv, "Scripts", "python.exe") : join45(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 join45(getLockDir(), "voice.lock");
+  return join50(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join46(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;
@@ -17499,12 +18133,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 join48 } 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 join47 } from "path";
+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);
@@ -17517,7 +18151,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`
@@ -17541,8 +18175,8 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync17(join47(lockFile, ".."), { recursive: true });
-  writeFileSync32(
+  mkdirSync17(join52(lockFile, ".."), { recursive: true });
+  writeFileSync33(
     lockFile,
     JSON.stringify({
       pid,
@@ -17557,7 +18191,7 @@ function setup() {
   mkdirSync18(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join48(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 }
@@ -17570,8 +18204,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 join49 } 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) {
@@ -17599,7 +18233,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})`);
 }
@@ -17609,7 +18243,7 @@ function start2(options2) {
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join49(getPythonDir(), "voice_daemon.py");
+  const script = join54(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -17619,7 +18253,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);
@@ -17630,7 +18264,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() {
@@ -17638,7 +18272,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);
@@ -17657,13 +18291,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})`);
@@ -17695,10 +18329,10 @@ function registerVoice(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk166 from "chalk";
+import chalk169 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
-import { createServer as createServer2 } from "http";
+import { createServer as createServer3 } from "http";
 function respondHtml(res, status2, title) {
   res.writeHead(status2, { "Content-Type": "text/html" });
   res.end(
@@ -17716,12 +18350,12 @@ function extractCode(url, expectedState) {
   return code;
 }
 function waitForCallback(port, expectedState) {
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve17, reject) => {
     const timeout = setTimeout(() => {
       server.close();
       reject(new Error("Authorization timed out after 120 seconds"));
     }, 12e4);
-    const server = createServer2((req, res) => {
+    const server = createServer3((req, res) => {
       const url = new URL(req.url ?? "/", `http://localhost:${port}`);
       if (url.pathname !== "/callback") {
         res.writeHead(404);
@@ -17733,7 +18367,7 @@ function waitForCallback(port, expectedState) {
         const code = extractCode(url, expectedState);
         respondHtml(res, 200, "Authorization successful!");
         server.close();
-        resolve16(code);
+        resolve17(code);
       } catch (error) {
         respondHtml(res, 400, error.message);
         server.close();
@@ -17826,13 +18460,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk166.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(chalk166.white("http://localhost:14523/callback\n"));
-  console.log(chalk166.blue("Opening browser for authorization..."));
-  console.log(chalk166.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(chalk166.dim("Exchanging code for tokens..."));
+  console.log(chalk169.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -17848,14 +18482,14 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk166.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 join50 } 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 {
@@ -17864,7 +18498,7 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path58 = join50(roamDir, name);
+    const path58 = join55(roamDir, name);
     try {
       return { path: path58, mtimeMs: statSync6(path58).mtimeMs };
     } catch {
@@ -17876,11 +18510,11 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join50(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;
   }
@@ -17924,7 +18558,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() {
@@ -18023,13 +18657,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 dirname25, join as join51, 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(dirname25(gitPath), "..");
-    const gitBash = join51(gitRoot, "bin", "bash.exe");
+    const gitRoot = resolve12(dirname27(gitPath), "..");
+    const gitBash = join56(gitRoot, "bin", "bash.exe");
     if (existsSync47(gitBash)) return gitBash;
   } catch {
   }
@@ -18076,7 +18710,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(
@@ -18115,8 +18749,8 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync34 } from "fs";
-import { join as join52 } 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) {
@@ -18177,7 +18811,7 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join52(".claude", "commands");
+  const dir = join57(".claude", "commands");
   mkdirSync20(dir, { recursive: true });
   const content = `---
 description: Run ${name}
@@ -18185,8 +18819,8 @@ description: Run ${name}
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join52(dir, `${name}.md`);
-  writeFileSync34(filePath, content);
+  const filePath = join57(dir, `${name}.md`);
+  writeFileSync35(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add3() {
@@ -18242,7 +18876,7 @@ function link2() {
 
 // src/commands/run/remove.ts
 import { existsSync as existsSync48, unlinkSync as unlinkSync16 } from "fs";
-import { join as join53 } 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;
@@ -18257,7 +18891,7 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join53(".claude", "commands", `${name}.md`);
+  const filePath = join58(".claude", "commands", `${name}.md`);
   if (existsSync48(filePath)) {
     unlinkSync16(filePath);
     console.log(`Deleted command file: ${filePath}`);
@@ -18297,10 +18931,10 @@ 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 { existsSync as existsSync49, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync36 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join54, resolve as resolve13 } from "path";
-import chalk167 from "chalk";
+import { join as join59, resolve as resolve14 } from "path";
+import chalk170 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -18433,11 +19067,11 @@ 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 = join54(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(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
@@ -18449,15 +19083,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(chalk167.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk170.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk167.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk170.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk167.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk170.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -18482,10 +19116,10 @@ var STATUS_TIMEOUT_MS = 5e3;
 function queryDaemon(socket) {
   socket.write(`${JSON.stringify({ type: "ping" })}
 `);
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const result = { sessions: [] };
     const pending = /* @__PURE__ */ new Set(["sessions", "pong"]);
-    const timer = setTimeout(() => resolve16(result), STATUS_TIMEOUT_MS);
+    const timer = setTimeout(() => resolve17(result), STATUS_TIMEOUT_MS);
     const lines = createInterface4({ input: socket });
     lines.on("error", () => {
     });
@@ -18493,7 +19127,7 @@ function queryDaemon(socket) {
       applyLine(result, pending, line);
       if (pending.size === 0) {
         clearTimeout(timer);
-        resolve16(result);
+        resolve17(result);
       }
     });
   });
@@ -18513,7 +19147,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();
@@ -18525,7 +19159,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;
@@ -18644,6 +19278,7 @@ var persistedSessionSchema = z6.object({
   commandType: z6.enum(["claude", "run", "assist"]),
   cwd: z6.string(),
   startedAt: z6.number(),
+  runningMs: z6.number().optional(),
   claudeSessionId: z6.string().optional(),
   runName: z6.string().optional(),
   runArgs: z6.array(z6.string()).optional(),
@@ -18672,6 +19307,7 @@ function toPersistedSession(session) {
     commandType: session.commandType,
     cwd: session.cwd ?? process.cwd(),
     startedAt: session.startedAt,
+    runningMs: accumulatedRunningMs(session),
     claudeSessionId: session.claudeSessionId,
     runName: session.runName,
     runArgs: session.runArgs,
@@ -18679,6 +19315,9 @@ function toPersistedSession(session) {
     activity: session.activity
   };
 }
+function accumulatedRunningMs(session) {
+  return session.runningSince != null ? session.runningMs + Date.now() - session.runningSince : session.runningMs;
+}
 
 // src/commands/sessions/daemon/toSessionInfo.ts
 function toSessionInfo({
@@ -18687,6 +19326,8 @@ function toSessionInfo({
   commandType,
   status: status2,
   startedAt,
+  runningMs,
+  runningSince,
   runName,
   runArgs,
   assistArgs,
@@ -18703,6 +19344,8 @@ function toSessionInfo({
     commandType,
     status: status2,
     startedAt,
+    runningMs,
+    runningSince,
     runName,
     runArgs,
     assistArgs,
@@ -18828,12 +19471,15 @@ function shellEscape(s) {
 
 // src/commands/sessions/daemon/createAssistSession.ts
 function createAssistSession(id2, assistArgs, cwd) {
+  const startedAt = Date.now();
   return {
     id: id2,
     name: `assist ${assistArgs.join(" ")}`,
     commandType: "assist",
     status: "running",
-    startedAt: Date.now(),
+    startedAt,
+    runningMs: 0,
+    runningSince: startedAt,
     pty: spawnPty(["assist", ...assistArgs], cwd, id2),
     scrollback: "",
     assistArgs,
@@ -18861,24 +19507,30 @@ function spawnRun(opts) {
 
 // src/commands/sessions/daemon/createSession.ts
 function createSession(id2, prompt, cwd) {
+  const startedAt = Date.now();
   return {
     id: id2,
     name: prompt?.slice(0, 40) || `Session ${id2}`,
     commandType: "claude",
     status: "running",
-    startedAt: Date.now(),
+    startedAt,
+    runningMs: 0,
+    runningSince: startedAt,
     pty: spawnClaude2({ prompt, cwd, sessionId: id2 }),
     scrollback: "",
     cwd
   };
 }
 function createRunSession(id2, runName, runArgs, cwd) {
+  const startedAt = Date.now();
   return {
     id: id2,
     name: `run: ${runName}`,
     commandType: "run",
     status: "running",
-    startedAt: Date.now(),
+    startedAt,
+    runningMs: 0,
+    runningSince: startedAt,
     pty: spawnRun({ name: runName, args: runArgs, cwd }),
     scrollback: "",
     runName,
@@ -18902,6 +19554,16 @@ function greetClient(client, sessions, windowsProxy) {
   void windowsProxy.discover();
 }
 
+// src/commands/sessions/daemon/setStatus.ts
+function setStatus2(session, newStatus) {
+  const now = Date.now();
+  if (session.status === "running" && session.runningSince != null) {
+    session.runningMs += now - session.runningSince;
+  }
+  session.runningSince = newStatus === "running" ? now : null;
+  session.status = newStatus;
+}
+
 // src/commands/sessions/daemon/watchEscInterrupt.ts
 var ESC2 = "\x1B";
 var SETTLE_MS = 1e3;
@@ -18957,7 +19619,7 @@ function applyStatusChange(session, status2, exitCode, dismiss, notify2, reuseFo
   disarmEscInterrupt(session);
   if (session.status === status2) return;
   daemonLog(`session ${session.id} status: ${session.status} -> ${status2}`);
-  session.status = status2;
+  setStatus2(session, status2);
   if (shouldAutoRun(session, exitCode) && session.activity?.itemId != null) {
     reuseForRun(session, session.activity.itemId);
     notify2();
@@ -18990,6 +19652,8 @@ function errorSession(id2, persisted, error) {
     ...restoreBase(id2, persisted),
     status: "error",
     startedAt: persisted.startedAt,
+    runningMs: persisted.runningMs ?? 0,
+    runningSince: null,
     pty: null,
     runName: persisted.runName,
     runArgs: persisted.runArgs,
@@ -19006,10 +19670,13 @@ function backlogRunArgs(persisted) {
 
 // src/commands/sessions/daemon/runningSession.ts
 function runningSession(base, persisted, pty2) {
+  const startedAt = Date.now();
   return {
     ...base,
     status: "running",
-    startedAt: Date.now(),
+    startedAt,
+    runningMs: persisted.runningMs ?? 0,
+    runningSince: startedAt,
     pty: pty2,
     claudeSessionId: persisted.claudeSessionId,
     restored: true,
@@ -19044,6 +19711,8 @@ function restoreSession(id2, persisted) {
     ...base,
     status: "done",
     startedAt: persisted.startedAt,
+    runningMs: persisted.runningMs ?? 0,
+    runningSince: null,
     pty: null,
     runName: persisted.runName,
     runArgs: persisted.runArgs,
@@ -19086,12 +19755,15 @@ function restoreAll(spawn12, sessions) {
 
 // src/commands/sessions/daemon/resumeSession.ts
 function resumeSession(id2, sessionId, cwd, name) {
+  const startedAt = Date.now();
   return {
     id: id2,
     name: name ? `${name.slice(0, 36)} (R)` : `Resume ${sessionId.slice(0, 8)}`,
     commandType: "claude",
     status: "running",
-    startedAt: Date.now(),
+    startedAt,
+    runningMs: 0,
+    runningSince: startedAt,
     pty: spawnClaude2({ resumeSessionId: sessionId, cwd, sessionId: id2 }),
     scrollback: "",
     cwd
@@ -19100,12 +19772,12 @@ function resumeSession(id2, sessionId, cwd, name) {
 
 // src/commands/sessions/daemon/watchActivity.ts
 import { existsSync as existsSync51, mkdirSync as mkdirSync22, watch } from "fs";
-import { dirname as dirname26 } from "path";
+import { dirname as dirname28 } from "path";
 var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
   if (session.commandType !== "assist" || !session.cwd) return;
   const path58 = activityPath(session.id);
-  const dir = dirname26(path58);
+  const dir = dirname28(path58);
   try {
     mkdirSync22(dir, { recursive: true });
   } catch {
@@ -19172,8 +19844,10 @@ function retrySession(session, clients, onStatusChange) {
   if (!respawn) return false;
   if (session.status !== "done") session.pty?.kill();
   session.scrollback = "";
-  session.status = "running";
   session.startedAt = Date.now();
+  session.runningMs = 0;
+  session.runningSince = null;
+  setStatus2(session, "running");
   session.restored = void 0;
   session.pty = respawn();
   broadcast(clients, { type: "clear", sessionId: session.id });
@@ -19196,8 +19870,10 @@ function reuseSessionForRun(session, itemId, clients, onStatusChange) {
   session.assistArgs = assistArgs;
   session.name = `assist ${assistArgs.join(" ")}`;
   session.commandType = "assist";
-  session.status = "running";
   session.startedAt = Date.now();
+  session.runningMs = 0;
+  session.runningSince = null;
+  setStatus2(session, "running");
   session.restored = void 0;
   session.pty = spawnPty(["assist", ...assistArgs], session.cwd, session.id);
   wirePtyEvents(session, clients, onStatusChange);
@@ -19225,10 +19901,10 @@ function windowsDaemonHost() {
 
 // src/commands/sessions/daemon/connectToWindowsDaemon.ts
 function connectToWindowsDaemon() {
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve17, reject) => {
     const socket = net2.connect(windowsDaemonPort(), windowsDaemonHost());
     socket.setKeepAlive(true, 1e4);
-    socket.once("connect", () => resolve16(socket));
+    socket.once("connect", () => resolve17(socket));
     socket.once("error", reject);
   });
 }
@@ -19305,7 +19981,7 @@ async function waitForWindowsDaemon() {
   );
 }
 function delay2(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve17) => setTimeout(resolve17, ms));
 }
 
 // src/commands/sessions/daemon/defaultConnect.ts
@@ -19472,7 +20148,7 @@ async function healWindowsDaemon() {
   daemonLog("windows daemon: auto-heal: stale daemon stopped");
 }
 function runOnWindowsHost(command, timeoutMs) {
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve17, reject) => {
     const child = spawn11("pwsh.exe", ["-Command", command], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -19492,7 +20168,7 @@ function runOnWindowsHost(command, timeoutMs) {
     });
     child.on("exit", (code) => {
       clearTimeout(timer);
-      if (code === 0) resolve16();
+      if (code === 0) resolve17();
       else
         reject(
           new Error(
@@ -19967,7 +20643,7 @@ async function createdSince(filePath, sinceMs) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve17) => setTimeout(resolve17, ms));
 }
 
 // src/commands/sessions/daemon/watchForClaudeSessionId.ts
@@ -20346,10 +21022,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(() => {
@@ -20360,7 +21036,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;
   }
@@ -20368,7 +21044,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();
@@ -20502,7 +21178,7 @@ async function setSessionStatus(status2) {
 
 // src/commands/sessions/summarise/index.ts
 import * as fs35 from "fs";
-import chalk168 from "chalk";
+import chalk171 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs33 from "fs";
@@ -20656,22 +21332,22 @@ ${firstMessage}`);
 async function summarise3(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk168.yellow("No sessions found."));
+    console.log(chalk171.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk168.green("All sessions already summarised."));
+    console.log(chalk171.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk168.cyan(
+    chalk171.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk168.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk168.yellow(`, ${failed2} skipped`) : "")
+    chalk171.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk171.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -20691,16 +21367,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk168.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(`${chalk168.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk171.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk168.yellow("skip")}
+      process.stdout.write(` ${chalk171.yellow("skip")}
 `);
     }
   }
@@ -20718,10 +21394,10 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk170 from "chalk";
+import chalk173 from "chalk";
 
 // src/commands/buildLimitsSegment.ts
-import chalk169 from "chalk";
+import chalk172 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -20752,9 +21428,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk169.green,
-  warn: chalk169.yellow,
-  over: chalk169.red
+  ok: chalk172.green,
+  warn: chalk172.yellow,
+  over: chalk172.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -20794,14 +21470,14 @@ async function relayRateLimits(rateLimits) {
 }
 
 // src/commands/statusLine.ts
-chalk170.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 chalk170.red(label2);
-  if (pct > 40) return chalk170.yellow(label2);
+  if (pct > 80) return chalk173.red(label2);
+  if (pct > 40) return chalk173.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -20820,12 +21496,12 @@ async function statusLine() {
 import * as fs38 from "fs";
 import * as os2 from "os";
 import * as path56 from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
+import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
 import * as fs36 from "fs";
 import * as path54 from "path";
-import chalk171 from "chalk";
+import chalk174 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path54.join(claudeDir, "CLAUDE.md");
   const target = path54.join(targetBase, "CLAUDE.md");
@@ -20834,12 +21510,12 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
     const targetContent = fs36.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk171.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(
-        chalk171.red("Overwrite existing CLAUDE.md?"),
+        chalk174.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -20855,7 +21531,7 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 // src/commands/sync/syncSettings.ts
 import * as fs37 from "fs";
 import * as path55 from "path";
-import chalk172 from "chalk";
+import chalk175 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path55.join(claudeDir, "settings.json");
   const target = path55.join(targetBase, "settings.json");
@@ -20871,14 +21547,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk172.yellow(
+          chalk175.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk172.red("Overwrite existing settings.json?"),
+          chalk175.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -20893,7 +21569,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
 }
 
 // src/commands/sync.ts
-var __filename4 = fileURLToPath6(import.meta.url);
+var __filename4 = fileURLToPath7(import.meta.url);
 var __dirname6 = path56.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
@@ -21011,6 +21687,7 @@ registerDeploy(program);
 registerComplexity(program);
 registerDotnet(program);
 registerNews(program);
+registerNetcap(program);
 registerRavendb(program);
 registerSeq(program);
 registerSql(program);