@staff0rd/assist 0.439.2 → 0.440.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.439.2",
+  version: "0.440.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -10680,6 +10680,29 @@ async function insertSubtask(orm, itemId2, title, description) {
   });
 }
 
+// src/commands/backlog/createItemWithDefaults.ts
+async function createItemWithDefaults(fields) {
+  const orm = await getDb();
+  const id = await insertItem(
+    orm,
+    {
+      type: fields.type,
+      name: fields.name,
+      description: fields.description || void 0,
+      acceptanceCriteria: fields.acceptanceCriteria,
+      status: "todo",
+      starred: false
+    },
+    getOrigin()
+  );
+  if (fields.type === "bug")
+    await insertPhaseAt(orm, id, 0, "Fix", ["Fix the bug"], null, void 0);
+  for (const subtask of loadConfig().subtasks ?? []) {
+    await insertSubtask(orm, id, subtask.title, subtask.description);
+  }
+  return id;
+}
+
 // src/commands/backlog/ensureRemoteOrigin.ts
 import chalk73 from "chalk";
 function ensureRemoteOrigin() {
@@ -10770,25 +10793,12 @@ async function add(options2) {
   const name = options2.name ?? await promptName();
   const description = options2.desc?.replaceAll(String.raw`\n`, "\n") ?? await promptDescription();
   const acceptanceCriteria2 = options2.ac ?? await promptAcceptanceCriteria();
-  const orm = await getDb();
-  const id = await insertItem(
-    orm,
-    {
-      type,
-      name,
-      description: description || void 0,
-      acceptanceCriteria: acceptanceCriteria2,
-      status: "todo",
-      starred: false
-    },
-    getOrigin()
-  );
-  if (type === "bug") {
-    await insertPhaseAt(orm, id, 0, "Fix", ["Fix the bug"], null, void 0);
-  }
-  for (const subtask of loadConfig().subtasks ?? []) {
-    await insertSubtask(orm, id, subtask.title, subtask.description);
-  }
+  const id = await createItemWithDefaults({
+    type,
+    name,
+    description,
+    acceptanceCriteria: acceptanceCriteria2
+  });
   console.log(chalk74.green(`Added item ${formatItemId(id)}: ${name}`));
 }
 
@@ -10887,6 +10897,187 @@ async function list2(options2) {
   }
 }
 
+// src/commands/backlog/propose/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import chalk79 from "chalk";
+
+// src/commands/sessions/shared/reportPreviewRejection.ts
+function reportPreviewRejection(subject, decision) {
+  console.error(
+    `${subject} rejected${decision.reason ? `: ${decision.reason}` : "."}`
+  );
+  const comments3 = decision.comments ?? [];
+  if (comments3.length > 0) {
+    console.error(
+      `
+The reviewer left ${comments3.length} comment${comments3.length === 1 ? "" : "s"} on the preview. Address each one, then re-run this command:
+`
+    );
+    for (const [i, c] of comments3.entries()) {
+      const quoted = c.quote.split("\n").map((line) => `  > ${line}`).join("\n");
+      console.error(`${i + 1}. On:
+${quoted}
+   Comment: ${c.note}
+`);
+    }
+  }
+  process.exit(1);
+}
+
+// src/commands/sessions/shared/parsePreviewDecision.ts
+function parsePreviewDecision(line, requestId) {
+  try {
+    const msg = JSON.parse(line);
+    if (msg.type === "error" && (msg.message ?? "").includes("pr-preview"))
+      return { kind: "error", message: msg.message ?? "pr-preview failed" };
+    if (msg.type !== "pr-decision" || msg.requestId !== requestId) return null;
+    if (msg.decision !== "approve" && msg.decision !== "reject") return null;
+    return {
+      kind: "decision",
+      decision: {
+        decision: msg.decision,
+        reason: msg.reason,
+        comments: Array.isArray(msg.comments) ? msg.comments : void 0,
+        screenshots: Array.isArray(msg.screenshots) ? msg.screenshots : void 0
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/sessions/shared/requestPreviewDecision.ts
+function requestPreviewDecision(request) {
+  return new Promise((resolve20, reject) => {
+    connectToDaemon().then((socket) => {
+      let settled = false;
+      const finish = (error, decision) => {
+        if (settled) return;
+        settled = true;
+        socket.destroy();
+        if (error) reject(error);
+        else resolve20(decision);
+      };
+      readSocketLines(socket, (line) => {
+        const incoming = parsePreviewDecision(line, request.requestId);
+        if (!incoming) return;
+        if (incoming.kind === "error") finish(new Error(incoming.message));
+        else finish(void 0, incoming.decision);
+      });
+      socket.on("error", (error) => finish(error));
+      socket.on(
+        "close",
+        () => finish(new Error("daemon closed before a decision was made"))
+      );
+      socket.write(`${JSON.stringify({ type: "pr-preview", ...request })}
+`);
+    }, reject);
+  });
+}
+
+// src/commands/sessions/shared/awaitPreviewApproval.ts
+async function awaitPreviewApproval(subject, request) {
+  console.log("Awaiting your approval in the assist web UI preview pane\u2026");
+  let decision;
+  try {
+    decision = await requestPreviewDecision(request);
+  } catch (error) {
+    console.error(
+      `Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+  if (decision.decision === "reject") reportPreviewRejection(subject, decision);
+  return decision;
+}
+
+// src/commands/backlog/propose/readProposedItem.ts
+import { readFileSync as readFileSync23 } from "fs";
+import chalk78 from "chalk";
+
+// src/commands/backlog/propose/proposedItemSchema.ts
+import { z as z5 } from "zod";
+var proposedItemSchema = z5.strictObject({
+  name: z5.string().trim().min(1, "name is required"),
+  type: z5.enum(["story", "bug"]),
+  description: z5.string().optional(),
+  acceptanceCriteria: z5.array(z5.string().trim().min(1)).default([])
+});
+
+// src/commands/backlog/propose/readProposedItem.ts
+function fail3(message2) {
+  console.error(chalk78.red(message2));
+  process.exit(1);
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function readSource(source) {
+  try {
+    if (source === "-") return (await readStdinBuffer()).toString("utf8");
+    return readFileSync23(source, "utf8");
+  } catch (error) {
+    return fail3(
+      `Cannot read the payload from ${source === "-" ? "stdin" : source}: ${describe(error)}`
+    );
+  }
+}
+async function readProposedItem(source) {
+  const raw = await readSource(source);
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (error) {
+    return fail3(`The payload is not valid JSON: ${describe(error)}`);
+  }
+  const parsed = proposedItemSchema.safeParse(json);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+    return fail3(`The payload is not a valid backlog item:
+${issues}`);
+  }
+  return parsed.data;
+}
+
+// src/commands/backlog/propose/renderProposedItem.ts
+function renderProposedItem(item) {
+  const sections = [`**Type:** ${item.type}`];
+  if (item.description) sections.push("## Description", item.description);
+  if (item.acceptanceCriteria.length > 0)
+    sections.push(
+      "## Acceptance Criteria",
+      item.acceptanceCriteria.map((ac, i) => `${i + 1}. ${ac}`).join("\n")
+    );
+  return sections.join("\n\n");
+}
+
+// src/commands/backlog/propose/index.ts
+async function reviewProposal(item) {
+  const body = renderProposedItem(item);
+  const sessionId = process.env.ASSIST_SESSION_ID;
+  if (process.env.ASSIST_SESSION === "1" && sessionId) {
+    await awaitPreviewApproval("Backlog item preview", {
+      sessionId,
+      requestId: randomUUID2(),
+      title: item.name,
+      body,
+      prNumber: null,
+      kind: "backlog-item",
+      itemType: item.type
+    });
+    return;
+  }
+  console.log(chalk79.bold(item.name));
+  console.log(renderMarkdownTerminal(body));
+}
+async function propose(options2) {
+  if (!ensureRemoteOrigin()) return;
+  const item = await readProposedItem(options2.json);
+  await reviewProposal(item);
+  const id = await createItemWithDefaults(item);
+  console.log(chalk79.green(`Added item ${formatItemId(id)}: ${item.name}`));
+}
+
 // src/commands/backlog/registerItemCommands.ts
 function registerItemCommands(cmd) {
   cmd.command("list").alias("ls").description("List all backlog items").option(
@@ -10897,6 +11088,12 @@ function registerItemCommands(cmd) {
     "--desc <description>",
     String.raw`Item description (Markdown supported; use \n for line breaks)`
   ).option("--ac <criterion...>", "Acceptance criteria (repeatable)").action(add);
+  cmd.command("propose").description(
+    "Preview a complete backlog item for approval, then create it on approval"
+  ).requiredOption(
+    "--json <file|->",
+    "Path to a JSON payload describing the item, or - to read it from stdin"
+  ).action(propose);
   cmd.command("add-phase <id> <name>").description("Add a phase to an existing backlog item").option("--task <task...>", "Task description (repeatable)").option(
     "--manual-check <check...>",
     "Manual check description (repeatable)"
@@ -10907,7 +11104,7 @@ function registerItemCommands(cmd) {
 }
 
 // src/commands/backlog/link.ts
-import chalk79 from "chalk";
+import chalk81 from "chalk";
 
 // src/commands/backlog/hasCycle.ts
 function hasCycle(adjacency, fromId, toId) {
@@ -10939,14 +11136,14 @@ async function loadDependencyGraph(orm) {
 }
 
 // src/commands/backlog/validateLinkTarget.ts
-import chalk78 from "chalk";
+import chalk80 from "chalk";
 function validateLinkTarget(fromItem, fromNum, toNum, linkType) {
   const duplicate = (fromItem.links ?? []).some(
     (l) => l.targetId === toNum && l.type === linkType
   );
   if (duplicate) {
     console.log(
-      chalk78.yellow(
+      chalk80.yellow(
         `Link already exists: ${formatItemId(fromNum)} ${linkType} ${formatItemId(toNum)}`
       )
     );
@@ -10956,20 +11153,20 @@ function validateLinkTarget(fromItem, fromNum, toNum, linkType) {
 }
 
 // src/commands/backlog/link.ts
-function fail3(message2) {
-  console.log(chalk79.red(message2));
+function fail4(message2) {
+  console.log(chalk81.red(message2));
   return void 0;
 }
 function parseLinkType(type) {
   const linkType = type ?? "relates-to";
   if (linkType === "relates-to" || linkType === "depends-on") return linkType;
-  return fail3(`Invalid link type: ${linkType}`);
+  return fail4(`Invalid link type: ${linkType}`);
 }
 async function createsCycle(orm, linkType, fromNum, toNum) {
   if (linkType !== "depends-on") return false;
   const graph = await loadDependencyGraph(orm);
   if (!hasCycle(graph, fromNum, toNum)) return false;
-  fail3(
+  fail4(
     `Cannot add dependency: ${formatItemId(fromNum)} \u2192 ${formatItemId(toNum)} would create a cycle.`
   );
   return true;
@@ -10979,22 +11176,22 @@ async function link(fromId, toId, opts) {
   if (!linkType) return;
   const fromNum = parseItemId(fromId);
   const toNum = parseItemId(toId);
-  if (fromNum === toNum) return void fail3("Cannot link an item to itself.");
+  if (fromNum === toNum) return void fail4("Cannot link an item to itself.");
   const from = formatItemId(fromNum);
   const to = formatItemId(toNum);
   const { orm } = await getReady();
   const fromItem = await loadItem(orm, fromNum);
-  if (!fromItem) return void fail3(`Item ${from} not found.`);
+  if (!fromItem) return void fail4(`Item ${from} not found.`);
   const toItem = await loadItem(orm, toNum);
-  if (!toItem) return void fail3(`Item ${to} not found.`);
+  if (!toItem) return void fail4(`Item ${to} not found.`);
   if (!validateLinkTarget(fromItem, fromNum, toNum, linkType)) return;
   if (await createsCycle(orm, linkType, fromNum, toNum)) return;
   await orm.insert(links).values({ itemId: fromNum, type: linkType, targetId: toNum });
-  console.log(chalk79.green(`Linked ${from} ${linkType} ${to} (${toItem.name})`));
+  console.log(chalk81.green(`Linked ${from} ${linkType} ${to} (${toItem.name})`));
 }
 
 // src/commands/backlog/unlink.ts
-import chalk80 from "chalk";
+import chalk82 from "chalk";
 import { and as and9, eq as eq24 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = parseItemId(fromId);
@@ -11002,18 +11199,18 @@ async function unlink(fromId, toId) {
   const { orm } = await getReady();
   const fromItem = await loadItem(orm, fromNum);
   if (!fromItem) {
-    console.log(chalk80.red(`Item ${formatItemId(fromNum)} not found.`));
+    console.log(chalk82.red(`Item ${formatItemId(fromNum)} not found.`));
     return;
   }
   if (!fromItem.links || fromItem.links.length === 0) {
     console.log(
-      chalk80.yellow(`No links found on item ${formatItemId(fromNum)}.`)
+      chalk82.yellow(`No links found on item ${formatItemId(fromNum)}.`)
     );
     return;
   }
   if (!fromItem.links.some((l) => l.targetId === toNum)) {
     console.log(
-      chalk80.yellow(
+      chalk82.yellow(
         `No link from ${formatItemId(fromNum)} to ${formatItemId(toNum)} found.`
       )
     );
@@ -11021,7 +11218,7 @@ async function unlink(fromId, toId) {
   }
   await orm.delete(links).where(and9(eq24(links.itemId, fromNum), eq24(links.targetId, toNum)));
   console.log(
-    chalk80.green(
+    chalk82.green(
       `Removed link from ${formatItemId(fromNum)} to ${formatItemId(toNum)}.`
     )
   );
@@ -11038,17 +11235,17 @@ function registerLinkCommands(cmd) {
 }
 
 // src/commands/backlog/move-repo/index.ts
-import chalk82 from "chalk";
+import chalk84 from "chalk";
 import { eq as eq26 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
-import chalk81 from "chalk";
+import chalk83 from "chalk";
 function pluralItems(n) {
   return `${n} item${n === 1 ? "" : "s"}`;
 }
 async function confirmMove(cnt, oldOrigin, newOrigin) {
   console.log(
-    `${pluralItems(cnt)}: ${chalk81.cyan(oldOrigin)} \u2192 ${chalk81.cyan(newOrigin)}`
+    `${pluralItems(cnt)}: ${chalk83.cyan(oldOrigin)} \u2192 ${chalk83.cyan(newOrigin)}`
   );
   return promptConfirm(`Retag ${pluralItems(cnt)}?`);
 }
@@ -11079,29 +11276,29 @@ Pass the full origin.`
 }
 
 // src/commands/backlog/move-repo/index.ts
-function fail4(message2) {
-  console.log(chalk82.red(message2));
+function fail5(message2) {
+  console.log(chalk84.red(message2));
   process.exitCode = 1;
 }
 async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
   const newOrigin = newOriginRaw ? normalizeOrigin(newOriginRaw) : getOrigin();
   const { orm } = await getReady();
   const resolved = await resolveOldOrigin(orm, normalizeOrigin(oldOriginRaw));
-  if ("error" in resolved) return fail4(resolved.error);
+  if ("error" in resolved) return fail5(resolved.error);
   const oldOrigin = resolved.origin;
   if (oldOrigin === newOrigin) {
-    return fail4(
+    return fail5(
       `Old and new origins both resolve to "${oldOrigin}"; nothing to move.`
     );
   }
   const cnt = await countByOrigin(orm, oldOrigin);
   if (!options2.yes && !await confirmMove(cnt, oldOrigin, newOrigin)) {
-    console.log(chalk82.yellow("Move cancelled; no changes made."));
+    console.log(chalk84.yellow("Move cancelled; no changes made."));
     return;
   }
   await orm.update(items).set({ origin: newOrigin }).where(eq26(items.origin, oldOrigin));
   console.log(
-    chalk82.green(
+    chalk84.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
     )
   );
@@ -11130,11 +11327,11 @@ function registerPlanCommands(cmd) {
 }
 
 // src/commands/backlog/refine.ts
-import chalk85 from "chalk";
+import chalk87 from "chalk";
 import enquirer7 from "enquirer";
 
 // src/commands/backlog/launchMode.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/shared/spawnCodex.ts
 function spawnCodex(prompt, options2 = {}) {
@@ -11164,7 +11361,7 @@ function spawnHarness(harness, prompt, options2 = {}) {
 }
 
 // src/commands/backlog/handleLaunchSignal.ts
-import chalk84 from "chalk";
+import chalk86 from "chalk";
 
 // src/commands/backlog/surfaceCreatedItem.ts
 async function surfaceCreatedItem(slashCommand, id) {
@@ -11187,32 +11384,32 @@ async function surfaceCreatedItem(slashCommand, id) {
 }
 
 // src/commands/backlog/tryRunById.ts
-import chalk83 from "chalk";
+import chalk85 from "chalk";
 async function tryRunById(id, options2) {
   const numericId = parseItemId(id);
   const label2 = formatItemId(numericId);
   const { orm } = await getReady();
   const item = await loadItem(orm, numericId);
   if (!item) {
-    console.log(chalk83.red(`Item ${label2} not found.`));
+    console.log(chalk85.red(`Item ${label2} not found.`));
     return false;
   }
   if (item.status === "done") {
-    console.log(chalk83.red(`Item ${label2} is already done.`));
+    console.log(chalk85.red(`Item ${label2} is already done.`));
     return false;
   }
   if (item.status === "wontdo") {
-    console.log(chalk83.red(`Item ${label2} is marked won't do.`));
+    console.log(chalk85.red(`Item ${label2} is marked won't do.`));
     return false;
   }
   const hasDeps = (item.links ?? []).some((l) => l.type === "depends-on");
   if (hasDeps && isBlocked(item, await loadItemSummaries(orm, getOrigin()))) {
     console.log(
-      chalk83.red(`Item ${label2} is blocked by unresolved dependencies.`)
+      chalk85.red(`Item ${label2} is blocked by unresolved dependencies.`)
     );
     return false;
   }
-  console.log(chalk83.bold(`
+  console.log(chalk85.bold(`
 Running backlog item ${label2}...
 `));
   await run2(id, options2);
@@ -11231,13 +11428,13 @@ async function handleLaunchSignal(slashCommand, once) {
       if (typeof signal.id === "string" && signal.id) {
         if (await tryRunById(signal.id, { allowEdits: true })) return;
       }
-      console.log(chalk84.bold("\nChaining into assist next...\n"));
+      console.log(chalk86.bold("\nChaining into assist next...\n"));
       await next({ allowEdits: true, once });
     }
   } catch (error) {
     const message2 = error instanceof Error ? error.message : String(error);
     console.error(
-      chalk84.yellow(
+      chalk86.yellow(
         `
 Could not complete post-run step (${message2}).
 This is usually a transient database/network blip \u2014 the work is saved and the session is safe to resume.`
@@ -11255,7 +11452,7 @@ async function launchMode(slashCommand, options2) {
   const resumeSessionId = options2?.resumeSessionId;
   if (!resumeSessionId) pullIfConfigured();
   process.env.ASSIST_SESSION_ID ??= String(process.pid);
-  const claudeSessionId = resumeSessionId ?? randomUUID2();
+  const claudeSessionId = resumeSessionId ?? randomUUID3();
   emitActivity({
     kind: "command",
     name: slashCommand,
@@ -11284,13 +11481,13 @@ async function pickItemForRefine() {
     (i) => i.status === "todo" || i.status === "in-progress"
   );
   if (active.length === 0) {
-    console.log(chalk85.yellow("No active backlog items to refine."));
+    console.log(chalk87.yellow("No active backlog items to refine."));
     return void 0;
   }
   if (active.length === 1) {
     const item = active[0];
     console.log(
-      chalk85.bold(`Auto-selecting item ${formatItemId(item.id)}: ${item.name}`)
+      chalk87.bold(`Auto-selecting item ${formatItemId(item.id)}: ${item.name}`)
     );
     return formatItemId(item.id);
   }
@@ -11338,7 +11535,7 @@ function registerRefineCommand(cmd) {
 }
 
 // src/commands/backlog/rewindPhase.ts
-import chalk86 from "chalk";
+import chalk88 from "chalk";
 async function rewindPhase(id, phase, opts) {
   const phaseNumber = Number.parseInt(phase, 10);
   const found = await findOneItem(id);
@@ -11346,12 +11543,12 @@ async function rewindPhase(id, phase, opts) {
   const { orm, item } = found;
   const result = await rewindItemToPhase(orm, item, phaseNumber, opts.reason);
   if (!result.ok) {
-    console.log(chalk86.red(result.error));
+    console.log(chalk88.red(result.error));
     process.exitCode = 1;
     return;
   }
   console.log(
-    chalk86.green(
+    chalk88.green(
       `Rewound item ${formatItemId(item.id)} to phase ${phaseNumber} (${result.phaseName}).`
     )
   );
@@ -11379,22 +11576,22 @@ function registerRunCommand(cmd) {
 }
 
 // src/commands/backlog/search/index.ts
-import chalk87 from "chalk";
+import chalk89 from "chalk";
 async function search(query) {
   const items2 = await searchBacklog(query);
   if (items2.length === 0) {
-    console.log(chalk87.dim(`No items matching "${query}".`));
+    console.log(chalk89.dim(`No items matching "${query}".`));
     return;
   }
   console.log(
-    chalk87.dim(
+    chalk89.dim(
       `${items2.length} item${items2.length === 1 ? "" : "s"} matching "${query}":
 `
     )
   );
   for (const item of items2) {
     console.log(
-      `${statusIcon(item.status)} ${typeLabel(item.type)} ${chalk87.dim(formatItemId(item.id))} ${item.name}`
+      `${statusIcon(item.status)} ${typeLabel(item.type)} ${chalk89.dim(formatItemId(item.id))} ${item.name}`
     );
   }
 }
@@ -11405,18 +11602,18 @@ function registerSearchCommand(cmd) {
 }
 
 // src/commands/backlog/delete/index.ts
-import chalk88 from "chalk";
+import chalk90 from "chalk";
 async function del(id) {
   const name = await removeItem(id);
   if (name) {
     console.log(
-      chalk88.green(`Deleted item ${formatItemId(parseItemId(id))}: ${name}`)
+      chalk90.green(`Deleted item ${formatItemId(parseItemId(id))}: ${name}`)
     );
   }
 }
 
 // src/commands/backlog/done/index.ts
-import chalk89 from "chalk";
+import chalk91 from "chalk";
 async function done(id, summary) {
   const found = await findOneItem(id);
   if (!found) return;
@@ -11430,12 +11627,12 @@ async function done(id, summary) {
     const pending = item.plan.slice(completedCount);
     if (pending.length > 0) {
       console.log(
-        chalk89.red(
+        chalk91.red(
           `Cannot complete item ${formatItemId(item.id)}: ${pending.length} pending phase(s):`
         )
       );
       for (const phase of pending) {
-        console.log(chalk89.yellow(`  - ${phase.name}`));
+        console.log(chalk91.yellow(`  - ${phase.name}`));
       }
       process.exitCode = 1;
       return;
@@ -11447,12 +11644,12 @@ async function done(id, summary) {
     await appendComment(orm, item.id, summary, { phase, type: "summary" });
   }
   console.log(
-    chalk89.green(`Completed item ${formatItemId(item.id)}: ${item.name}`)
+    chalk91.green(`Completed item ${formatItemId(item.id)}: ${item.name}`)
   );
 }
 
 // src/commands/backlog/set-status/index.ts
-import chalk90 from "chalk";
+import chalk92 from "chalk";
 var allowedStatuses = [
   "todo",
   "in-progress",
@@ -11462,7 +11659,7 @@ var allowedStatuses = [
 async function setStatusCommand(id, status3) {
   if (!allowedStatuses.includes(status3)) {
     console.log(
-      chalk90.red(
+      chalk92.red(
         `Invalid status "${status3}". Must be one of: ${allowedStatuses.join(", ")}.`
       )
     );
@@ -11472,7 +11669,7 @@ async function setStatusCommand(id, status3) {
   const name = await setStatus(id, status3);
   if (name) {
     console.log(
-      chalk90.green(
+      chalk92.green(
         `Set item ${formatItemId(parseItemId(id))} to ${status3}: ${name}`
       )
     );
@@ -11480,16 +11677,16 @@ async function setStatusCommand(id, status3) {
 }
 
 // src/commands/backlog/star/index.ts
-import chalk92 from "chalk";
+import chalk94 from "chalk";
 
 // src/commands/backlog/setStarred.ts
-import chalk91 from "chalk";
+import chalk93 from "chalk";
 async function setStarred(id, starred) {
   const { orm } = await getReady();
   const numId = parseItemId(id);
   const name = await updateStarred(orm, numId, starred);
   if (name === void 0)
-    console.log(chalk91.red(`Item ${formatItemId(numId)} not found.`));
+    console.log(chalk93.red(`Item ${formatItemId(numId)} not found.`));
   return name;
 }
 
@@ -11498,52 +11695,52 @@ async function star(id) {
   const name = await setStarred(id, true);
   if (name) {
     console.log(
-      chalk92.green(`Starred item ${formatItemId(parseItemId(id))}: ${name}`)
+      chalk94.green(`Starred item ${formatItemId(parseItemId(id))}: ${name}`)
     );
   }
 }
 
 // src/commands/backlog/start/index.ts
-import chalk93 from "chalk";
+import chalk95 from "chalk";
 async function start(id) {
   const name = await setStatus(id, "in-progress");
   if (name) {
     console.log(
-      chalk93.green(`Started item ${formatItemId(parseItemId(id))}: ${name}`)
+      chalk95.green(`Started item ${formatItemId(parseItemId(id))}: ${name}`)
     );
   }
 }
 
 // src/commands/backlog/stop/index.ts
-import chalk94 from "chalk";
+import chalk96 from "chalk";
 import { and as and10, eq as eq27 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
   const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and10(eq27(items.status, "in-progress"), eq27(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
-    console.log(chalk94.yellow("No in-progress items to stop."));
+    console.log(chalk96.yellow("No in-progress items to stop."));
     return;
   }
   for (const item of stopped) {
     console.log(
-      chalk94.yellow(`Stopped item ${formatItemId(item.id)}: ${item.name}`)
+      chalk96.yellow(`Stopped item ${formatItemId(item.id)}: ${item.name}`)
     );
   }
 }
 
 // src/commands/backlog/unstar/index.ts
-import chalk95 from "chalk";
+import chalk97 from "chalk";
 async function unstar(id) {
   const name = await setStarred(id, false);
   if (name) {
     console.log(
-      chalk95.green(`Unstarred item ${formatItemId(parseItemId(id))}: ${name}`)
+      chalk97.green(`Unstarred item ${formatItemId(parseItemId(id))}: ${name}`)
     );
   }
 }
 
 // src/commands/backlog/wontdo/index.ts
-import chalk96 from "chalk";
+import chalk98 from "chalk";
 async function wontdo(id, reason2) {
   const found = await findOneItem(id);
   if (!found) return;
@@ -11554,7 +11751,7 @@ async function wontdo(id, reason2) {
     await appendComment(orm, item.id, reason2, { phase, type: "summary" });
   }
   console.log(
-    chalk96.red(`Won't do item ${formatItemId(item.id)}: ${item.name}`)
+    chalk98.red(`Won't do item ${formatItemId(item.id)}: ${item.name}`)
   );
 }
 
@@ -11573,17 +11770,17 @@ function registerStatusCommands(cmd) {
 }
 
 // src/commands/backlog/addSubtask.ts
-import chalk97 from "chalk";
+import chalk99 from "chalk";
 async function addSubtask(id, options2) {
   const title = options2.title?.trim();
   if (!title) {
-    console.log(chalk97.red("A sub-task title is required (--title)."));
+    console.log(chalk99.red("A sub-task title is required (--title)."));
     process.exitCode = 1;
     return;
   }
   if (title.length > 50) {
     console.log(
-      chalk97.red(
+      chalk99.red(
         "A sub-task title must be 50 characters or fewer. Use --desc for longer detail."
       )
     );
@@ -11599,21 +11796,21 @@ async function addSubtask(id, options2) {
   const description = options2.desc?.replaceAll(String.raw`\n`, "\n");
   await insertSubtask(orm, item.id, title, description);
   console.log(
-    chalk97.green(`Added sub-task to item ${formatItemId(item.id)}: ${title}`)
+    chalk99.green(`Added sub-task to item ${formatItemId(item.id)}: ${title}`)
   );
 }
 
 // src/commands/backlog/editSubtask.ts
-import chalk99 from "chalk";
+import chalk101 from "chalk";
 
 // src/commands/backlog/resolveSubtaskIndex.ts
-import chalk98 from "chalk";
+import chalk100 from "chalk";
 function resolveSubtaskIndex(index3, item) {
   const position = Number.parseInt(index3, 10);
   const subtasks = item.subtasks ?? [];
   if (Number.isNaN(position) || position < 1 || position > subtasks.length) {
     console.log(
-      chalk98.red(
+      chalk100.red(
         `Item ${formatItemId(item.id)} has no sub-task ${index3}${subtasks.length > 0 ? ` (1-${subtasks.length})` : ""}.`
       )
     );
@@ -11680,21 +11877,21 @@ async function editSubtask(id, index3, options2) {
   if (!found) return;
   const fields = buildUpdate(options2);
   if (typeof fields === "string") {
-    console.log(chalk99.red(fields));
+    console.log(chalk101.red(fields));
     process.exitCode = 1;
     return;
   }
   const { orm, item, idx } = found;
   const title = await updateSubtask(orm, item.id, idx, fields);
   console.log(
-    chalk99.green(
+    chalk101.green(
       `Updated sub-task ${idx + 1} of item ${formatItemId(item.id)}: ${title}`
     )
   );
 }
 
 // src/commands/backlog/removeSubtask.ts
-import chalk100 from "chalk";
+import chalk102 from "chalk";
 
 // src/commands/backlog/deleteSubtask.ts
 import { and as and12, asc as asc6, eq as eq29 } from "drizzle-orm";
@@ -11719,18 +11916,18 @@ async function removeSubtask(id, index3) {
   const { orm, item, idx } = found;
   const title = await deleteSubtask(orm, item.id, idx);
   console.log(
-    chalk100.green(
+    chalk102.green(
       `Removed sub-task ${idx + 1} of item ${formatItemId(item.id)}: ${title}`
     )
   );
 }
 
 // src/commands/backlog/subtaskStatus.ts
-import chalk101 from "chalk";
+import chalk103 from "chalk";
 async function subtaskStatus(id, index3, status3) {
   if (!validSubtaskStatuses.includes(status3)) {
     console.log(
-      chalk101.red(
+      chalk103.red(
         `Invalid status "${status3}". Use one of: ${validSubtaskStatuses.join(", ")}.`
       )
     );
@@ -11747,7 +11944,7 @@ async function subtaskStatus(id, index3, status3) {
     status3
   );
   console.log(
-    chalk101.green(
+    chalk103.green(
       `Set sub-task ${idx + 1} of item ${formatItemId(item.id)} to ${status3}: ${title}`
     )
   );
@@ -11774,7 +11971,7 @@ function registerSubtaskCommands(cmd) {
 }
 
 // src/commands/backlog/movePhase.ts
-import chalk102 from "chalk";
+import chalk104 from "chalk";
 import { count as count5, eq as eq32 } from "drizzle-orm";
 
 // src/commands/backlog/reorderPhaseRows.ts
@@ -11840,7 +12037,7 @@ function toIndex(value, phaseCount) {
   const pos = Number.parseInt(value, 10);
   if (Number.isNaN(pos) || pos < 1 || pos > phaseCount) {
     console.log(
-      chalk102.red(
+      chalk104.red(
         `Position "${value}" is out of range. Must be between 1 and ${phaseCount}.`
       )
     );
@@ -11863,11 +12060,11 @@ async function movePhase(id, from, to) {
   if (fromIdx !== toIdx) {
     await reorderPhaseRows(orm, itemId2, fromIdx, toIdx);
   }
-  console.log(chalk102.green(`Moved phase ${from} to position ${to}.`));
+  console.log(chalk104.green(`Moved phase ${from} to position ${to}.`));
 }
 
 // src/commands/backlog/updatePhase.ts
-import chalk104 from "chalk";
+import chalk106 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
 import { and as and15, eq as eq33 } from "drizzle-orm";
@@ -11902,7 +12099,7 @@ async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
 }
 
 // src/commands/backlog/findPhase.ts
-import chalk103 from "chalk";
+import chalk105 from "chalk";
 import { and as and16, count as count6, eq as eq34 } from "drizzle-orm";
 async function findPhase(id, phase) {
   const found = await findOneItem(id);
@@ -11913,7 +12110,7 @@ async function findPhase(id, phase) {
   const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(and16(eq34(planPhases.itemId, itemId2), eq34(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
-      chalk103.red(
+      chalk105.red(
         `Phase ${phaseIdx + 1} not found on item ${formatItemId(itemId2)}.`
       )
     );
@@ -12047,7 +12244,7 @@ async function updatePhase(id, phase, options2) {
   const { item, orm, itemId: itemId2, phaseIdx } = found;
   const resolved = resolvePhaseFields(options2, item.plan?.[phaseIdx]);
   if (!resolved.ok) {
-    console.log(chalk104.red(resolved.error));
+    console.log(chalk106.red(resolved.error));
     process.exitCode = 1;
     return;
   }
@@ -12059,7 +12256,7 @@ async function updatePhase(id, phase, options2) {
     manualCheck && "manual checks"
   ].filter(Boolean).join(", ");
   console.log(
-    chalk104.green(
+    chalk106.green(
       `Updated ${fields} on phase ${phaseIdx + 1} of item ${formatItemId(itemId2)}.`
     )
   );
@@ -12082,7 +12279,7 @@ function registerUpdatePhaseCommand(cmd) {
 }
 
 // src/commands/backlog/removePhase.ts
-import chalk105 from "chalk";
+import chalk107 from "chalk";
 import { and as and17, eq as eq35 } from "drizzle-orm";
 async function removePhase(id, phase) {
   const found = await findPhase(id, phase);
@@ -12097,27 +12294,27 @@ async function removePhase(id, phase) {
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
   console.log(
-    chalk105.green(
+    chalk107.green(
       `Removed phase ${phaseIdx + 1} from item ${formatItemId(itemId2)}.`
     )
   );
 }
 
 // src/commands/backlog/update/update.ts
-import chalk109 from "chalk";
+import chalk111 from "chalk";
 import { eq as eq36 } from "drizzle-orm";
 
 // src/commands/backlog/update/buildUpdateValues.ts
-import chalk106 from "chalk";
+import chalk108 from "chalk";
 function buildUpdateValues(options2) {
   const { name, desc: desc6, type, ac, origin } = options2;
   if (!name && !desc6 && !type && !ac && !origin) {
-    console.log(chalk106.red("Nothing to update. Provide at least one flag."));
+    console.log(chalk108.red("Nothing to update. Provide at least one flag."));
     process.exitCode = 1;
     return void 0;
   }
   if (type && type !== "story" && type !== "bug") {
-    console.log(chalk106.red('Invalid type. Must be "story" or "bug".'));
+    console.log(chalk108.red('Invalid type. Must be "story" or "bug".'));
     process.exitCode = 1;
     return void 0;
   }
@@ -12147,7 +12344,7 @@ function buildUpdateValues(options2) {
 }
 
 // src/commands/backlog/update/resolveAcUpdate.ts
-import chalk107 from "chalk";
+import chalk109 from "chalk";
 
 // src/commands/backlog/update/applyAcMutations.ts
 function hasAcMutations(options2) {
@@ -12172,14 +12369,14 @@ function resolveAcUpdate(options2, currentCriteria) {
   if (!hasAcMutations(options2)) return { ok: true, ac: options2.ac };
   if (options2.ac) {
     console.log(
-      chalk107.red("Cannot combine --ac with --add-ac/--edit-ac/--remove-ac.")
+      chalk109.red("Cannot combine --ac with --add-ac/--edit-ac/--remove-ac.")
     );
     process.exitCode = 1;
     return { ok: false };
   }
   const mutation = applyAcMutations(currentCriteria, options2);
   if (!mutation.ok) {
-    console.log(chalk107.red(mutation.error));
+    console.log(chalk109.red(mutation.error));
     process.exitCode = 1;
     return { ok: false };
   }
@@ -12187,14 +12384,14 @@ function resolveAcUpdate(options2, currentCriteria) {
 }
 
 // src/commands/backlog/update/resolveOriginUpdate.ts
-import chalk108 from "chalk";
+import chalk110 from "chalk";
 function resolveOriginUpdate(optionOrigin, item) {
   if (optionOrigin === void 0 || optionOrigin === false)
     return { kind: "none" };
   const origin = typeof optionOrigin === "string" ? normalizeOrigin(optionOrigin) : getOrigin();
   if (origin === item.origin) {
     console.log(
-      chalk108.yellow(
+      chalk110.yellow(
         `Item ${formatItemId(item.id)} is already on origin "${origin}"; nothing to change.`
       )
     );
@@ -12218,7 +12415,7 @@ async function update(id, options2) {
   const itemId2 = found.item.id;
   await orm.update(items).set(built.set).where(eq36(items.id, itemId2));
   console.log(
-    chalk109.green(`Updated ${built.fields} on item ${formatItemId(itemId2)}.`)
+    chalk111.green(`Updated ${built.fields} on item ${formatItemId(itemId2)}.`)
   );
 }
 
@@ -12632,7 +12829,7 @@ function extractGraphqlQuery(args) {
 }
 
 // src/shared/loadCliReads.ts
-import { existsSync as existsSync29, readFileSync as readFileSync23, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync24, writeFileSync as writeFileSync22 } from "fs";
 import { dirname as dirname21, resolve as resolve10 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename3 = fileURLToPath5(import.meta.url);
@@ -12642,7 +12839,7 @@ function packageRoot() {
 }
 function readLines(path71) {
   if (!existsSync29(path71)) return [];
-  return readFileSync23(path71, "utf8").split("\n").filter((line) => line.trim() !== "");
+  return readFileSync24(path71, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -12688,7 +12885,7 @@ function findCliWrite(command) {
 }
 
 // src/shared/readSettingsPerms.ts
-import { existsSync as existsSync30, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync25 } from "fs";
 import { homedir as homedir14 } from "os";
 import { join as join30 } from "path";
 function readSettingsPerms(key) {
@@ -12706,7 +12903,7 @@ function readSettingsPerms(key) {
 function readPermissionArray(filePath, key) {
   if (!existsSync30(filePath)) return [];
   try {
-    const data = JSON.parse(readFileSync24(filePath, "utf8"));
+    const data = JSON.parse(readFileSync25(filePath, "utf8"));
     const arr = data?.permissions?.[key];
     return Array.isArray(arr) ? arr.filter((e) => typeof e === "string") : [];
   } catch {
@@ -13016,7 +13213,7 @@ ${reasons.join("\n")}`);
 }
 
 // src/commands/permitCliReads/index.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync13, readFileSync as readFileSync25, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync13, readFileSync as readFileSync26, writeFileSync as writeFileSync23 } from "fs";
 import { homedir as homedir16 } from "os";
 import { join as join32 } from "path";
 
@@ -13028,11 +13225,11 @@ function assertCliExists(cli) {
 }
 
 // src/commands/permitCliReads/colorize.ts
-import chalk110 from "chalk";
+import chalk112 from "chalk";
 function colorize(plainOutput) {
   return plainOutput.split("\n").map((line) => {
-    if (line.startsWith(" R  ")) return chalk110.green(line);
-    if (line.startsWith(" W  ")) return chalk110.red(line);
+    if (line.startsWith(" R  ")) return chalk112.green(line);
+    if (line.startsWith(" W  ")) return chalk112.red(line);
     return line;
   }).join("\n");
 }
@@ -13291,7 +13488,7 @@ function logPath(cli) {
 function readCache(cli) {
   const path71 = logPath(cli);
   if (!existsSync31(path71)) return void 0;
-  return readFileSync25(path71, "utf8");
+  return readFileSync26(path71, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join32(homedir16(), ".assist");
@@ -13330,7 +13527,7 @@ async function permitCliReads(cli, options2 = { noCache: false }) {
 }
 
 // src/commands/deny/denyAdd.ts
-import chalk111 from "chalk";
+import chalk113 from "chalk";
 
 // src/commands/deny/loadDenyConfig.ts
 function loadDenyConfig(global) {
@@ -13350,16 +13547,16 @@ function loadDenyConfig(global) {
 function denyAdd(pattern2, message2, options2) {
   const { deny, saveDeny } = loadDenyConfig(options2.global);
   if (deny.some((r) => r.pattern === pattern2)) {
-    console.log(chalk111.yellow(`Deny rule already exists for: ${pattern2}`));
+    console.log(chalk113.yellow(`Deny rule already exists for: ${pattern2}`));
     return;
   }
   deny.push({ pattern: pattern2, message: message2 });
   saveDeny(deny);
-  console.log(chalk111.green(`Added deny rule: ${pattern2} \u2192 ${message2}`));
+  console.log(chalk113.green(`Added deny rule: ${pattern2} \u2192 ${message2}`));
 }
 
 // src/commands/deny/denyList.ts
-import chalk112 from "chalk";
+import chalk114 from "chalk";
 function denyList() {
   const globalRaw = loadGlobalConfigRaw();
   const projectRaw = loadProjectConfig();
@@ -13370,7 +13567,7 @@ function denyList() {
     projectDeny.length > 0 ? projectDeny : void 0
   );
   if (!merged || merged.length === 0) {
-    console.log(chalk112.dim("No deny rules configured."));
+    console.log(chalk114.dim("No deny rules configured."));
     return;
   }
   const projectPatterns = new Set(projectDeny.map((r) => r.pattern));
@@ -13378,23 +13575,23 @@ function denyList() {
   for (const rule of merged) {
     const inProject = projectPatterns.has(rule.pattern);
     const inGlobal = globalPatterns.has(rule.pattern);
-    const label2 = inProject && inGlobal ? chalk112.dim(" (project, overrides global)") : inGlobal ? chalk112.dim(" (global)") : "";
-    console.log(`${chalk112.red(rule.pattern)} \u2192 ${rule.message}${label2}`);
+    const label2 = inProject && inGlobal ? chalk114.dim(" (project, overrides global)") : inGlobal ? chalk114.dim(" (global)") : "";
+    console.log(`${chalk114.red(rule.pattern)} \u2192 ${rule.message}${label2}`);
   }
 }
 
 // src/commands/deny/denyRemove.ts
-import chalk113 from "chalk";
+import chalk115 from "chalk";
 function denyRemove(pattern2, options2) {
   const { deny, saveDeny } = loadDenyConfig(options2.global);
   const index3 = deny.findIndex((r) => r.pattern === pattern2);
   if (index3 === -1) {
-    console.log(chalk113.yellow(`No deny rule found for: ${pattern2}`));
+    console.log(chalk115.yellow(`No deny rule found for: ${pattern2}`));
     return;
   }
   deny.splice(index3, 1);
   saveDeny(deny.length > 0 ? deny : void 0);
-  console.log(chalk113.green(`Removed deny rule: ${pattern2}`));
+  console.log(chalk115.green(`Removed deny rule: ${pattern2}`));
 }
 
 // src/commands/registerDeny.ts
@@ -13437,8 +13634,8 @@ function registerCliHook(program2) {
 }
 
 // src/commands/codeComment/codeCommentConfirm.ts
-import { existsSync as existsSync33, readFileSync as readFileSync27, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
-import chalk114 from "chalk";
+import { existsSync as existsSync33, readFileSync as readFileSync28, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
+import chalk116 from "chalk";
 
 // src/commands/codeComment/getRestrictedDir.ts
 import { homedir as homedir17 } from "os";
@@ -13473,12 +13670,12 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 }
 
 // src/commands/codeComment/readPinState.ts
-import { existsSync as existsSync32, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync27 } from "fs";
 function readPinState(pin) {
   const path71 = getPinStatePath(pin);
   if (!existsSync32(path71)) return void 0;
   try {
-    const state = JSON.parse(readFileSync26(path71, "utf8"));
+    const state = JSON.parse(readFileSync27(path71, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -13491,21 +13688,21 @@ function codeCommentConfirm(pin) {
   sweepRestrictedDir();
   const state = readPinState(pin);
   if (!state) {
-    console.error(chalk114.red(`No pending comment for pin: ${pin}`));
+    console.error(chalk116.red(`No pending comment for pin: ${pin}`));
     process.exitCode = 1;
     return;
   }
   if (!existsSync33(state.file)) {
-    console.error(chalk114.red(`Target file no longer exists: ${state.file}`));
+    console.error(chalk116.red(`Target file no longer exists: ${state.file}`));
     process.exitCode = 1;
     return;
   }
-  const original = readFileSync27(state.file, "utf8");
+  const original = readFileSync28(state.file, "utf8");
   const lines = original.split("\n");
   const index3 = state.line - 1;
   if (index3 > lines.length) {
     console.error(
-      chalk114.red(
+      chalk116.red(
         `Line ${state.line} is beyond the end of ${state.file} (${lines.length} lines).`
       )
     );
@@ -13519,14 +13716,14 @@ function codeCommentConfirm(pin) {
   writeFileSync24(state.file, lines.join("\n"));
   unlinkSync8(getPinStatePath(pin));
   console.log(
-    chalk114.green(
+    chalk116.green(
       `Inserted "${marker} ${state.text}" at ${state.file}:${state.line}`
     )
   );
 }
 
 // src/commands/codeComment/codeCommentSet.ts
-import chalk115 from "chalk";
+import chalk117 from "chalk";
 
 // src/commands/codeComment/validateCommentText.ts
 var MAX_COMMENT_LENGTH = 50;
@@ -13577,7 +13774,7 @@ function generatePin() {
 function codeCommentSet(file, line, text17) {
   const lineNumber = Number.parseInt(line, 10);
   if (!Number.isInteger(lineNumber) || lineNumber < 1) {
-    console.error(chalk115.red(`Invalid line number: ${line}`));
+    console.error(chalk117.red(`Invalid line number: ${line}`));
     process.exitCode = 1;
     return;
   }
@@ -13585,20 +13782,20 @@ function codeCommentSet(file, line, text17) {
   const marker = hash ? "#" : "//";
   const validation = validateCommentText(text17, hash);
   if (!validation.ok) {
-    console.error(chalk115.red(`Refused: ${validation.reason}`));
-    console.error(chalk115.red("No pin issued."));
+    console.error(chalk117.red(`Refused: ${validation.reason}`));
+    console.error(chalk117.red("No pin issued."));
     process.exitCode = 1;
     return;
   }
   console.error(
-    chalk115.yellow.bold(
+    chalk117.yellow.bold(
       "THIS IS YOUR LAST CHANCE TO RECONSIDER BEFORE INVOLVING A HUMAN.\nRequesting this pin pages a real person to approve a comment. DO NOT WASTE THEIR TIME.\nYou had BETTER BE RIGHT that this comment is genuinely necessary.\n\nComments are a last resort, not a habit. Almost every comment you reach for is a sign\nthe code should be clearer instead. Before a human is pulled in, ask whether a better\nname, a smaller function, or a test would make the comment redundant. ONLY if you are\ncertain this one line earns its keep should you proceed to the confirm step below."
     )
   );
   const delivered = issuePin(file, lineNumber, validation.text);
   if (!delivered) {
     console.error(
-      chalk115.red(
+      chalk117.red(
         "Could not deliver the confirmation pin via notification.\nThe comment cannot be confirmed until the notification channel works."
       )
     );
@@ -13608,7 +13805,7 @@ function codeCommentSet(file, line, text17) {
   console.log(
     `A confirmation pin was sent to your desktop notifications.
 To insert "${marker} ${validation.text}" at ${file}:${lineNumber}, run:
-${chalk115.cyan("  assist code-comment confirm <PIN>")}
+${chalk117.cyan("  assist code-comment confirm <PIN>")}
 using the pin from that notification.`
   );
 }
@@ -13687,15 +13884,15 @@ function registerCodexHook(program2) {
 }
 
 // src/commands/complexity/analyze.ts
-import chalk124 from "chalk";
+import chalk126 from "chalk";
 
 // src/commands/complexity/cyclomatic.ts
-import chalk117 from "chalk";
+import chalk119 from "chalk";
 
 // src/commands/complexity/shared/index.ts
 import fs20 from "fs";
 import path27 from "path";
-import chalk116 from "chalk";
+import chalk118 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
@@ -13946,7 +14143,7 @@ function createSourceFromFile(filePath) {
 function withSourceFiles(pattern2, callback, extraIgnore = []) {
   const files = findSourceFiles2(pattern2, ".", extraIgnore);
   if (files.length === 0) {
-    console.log(chalk116.yellow("No files found matching pattern"));
+    console.log(chalk118.yellow("No files found matching pattern"));
     return void 0;
   }
   return callback(files);
@@ -13979,11 +14176,11 @@ async function cyclomatic(pattern2 = "**/*.ts", options2 = {}) {
     results.sort((a, b) => b.complexity - a.complexity);
     for (const { file, name, complexity } of results) {
       const exceedsThreshold = options2.threshold !== void 0 && complexity > options2.threshold;
-      const color = exceedsThreshold ? chalk117.red : chalk117.white;
-      console.log(`${color(`${file}:${name}`)} \u2192 ${chalk117.cyan(complexity)}`);
+      const color = exceedsThreshold ? chalk119.red : chalk119.white;
+      console.log(`${color(`${file}:${name}`)} \u2192 ${chalk119.cyan(complexity)}`);
     }
     console.log(
-      chalk117.dim(
+      chalk119.dim(
         `
 Analyzed ${results.length} functions across ${files.length} files`
       )
@@ -13995,7 +14192,7 @@ Analyzed ${results.length} functions across ${files.length} files`
 }
 
 // src/commands/complexity/halstead.ts
-import chalk118 from "chalk";
+import chalk120 from "chalk";
 async function halstead(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
@@ -14010,13 +14207,13 @@ async function halstead(pattern2 = "**/*.ts", options2 = {}) {
     results.sort((a, b) => b.metrics.effort - a.metrics.effort);
     for (const { file, name, metrics } of results) {
       const exceedsThreshold = options2.threshold !== void 0 && metrics.volume > options2.threshold;
-      const color = exceedsThreshold ? chalk118.red : chalk118.white;
+      const color = exceedsThreshold ? chalk120.red : chalk120.white;
       console.log(
-        `${color(`${file}:${name}`)} \u2192 volume: ${chalk118.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk118.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk118.magenta(metrics.effort.toFixed(1))}`
+        `${color(`${file}:${name}`)} \u2192 volume: ${chalk120.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk120.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk120.magenta(metrics.effort.toFixed(1))}`
       );
     }
     console.log(
-      chalk118.dim(
+      chalk120.dim(
         `
 Analyzed ${results.length} functions across ${files.length} files`
       )
@@ -14085,15 +14282,15 @@ function collectFileMetrics(files) {
 }
 
 // src/commands/complexity/maintainability/displayMaintainabilityResults.ts
-import chalk122 from "chalk";
+import chalk124 from "chalk";
 
 // src/commands/complexity/maintainability/formatResultLine.ts
-import chalk119 from "chalk";
+import chalk121 from "chalk";
 function formatResultLine(entry, failing) {
   const { file, avgMaintainability, minMaintainability, override } = entry;
-  const name = failing ? chalk119.red(file) : chalk119.white(file);
-  const suffix = override !== void 0 ? chalk119.magenta(` (override: ${override})`) : "";
-  return `${name} \u2192 avg: ${chalk119.cyan(avgMaintainability.toFixed(1))}, min: ${chalk119.yellow(minMaintainability.toFixed(1))}${suffix}`;
+  const name = failing ? chalk121.red(file) : chalk121.white(file);
+  const suffix = override !== void 0 ? chalk121.magenta(` (override: ${override})`) : "";
+  return `${name} \u2192 avg: ${chalk121.cyan(avgMaintainability.toFixed(1))}, min: ${chalk121.yellow(minMaintainability.toFixed(1))}${suffix}`;
 }
 
 // src/commands/complexity/maintainability/getMaintainabilityGitState.ts
@@ -14144,38 +14341,38 @@ function getMaintainabilityGitState() {
 
 // src/commands/complexity/maintainability/printMaintainabilityFailure.ts
 import path29 from "path";
-import chalk120 from "chalk";
+import chalk122 from "chalk";
 var extractTemplate = "assist refactor extract <file> <functionName> <destination> --apply";
 function remediationLine(entry) {
-  return `  ${chalk120.bold(entry.file)}
+  return `  ${chalk122.bold(entry.file)}
     Pick a responsibility and extract it:
-    ${chalk120.cyan(extractTemplate)}`;
+    ${chalk122.cyan(extractTemplate)}`;
 }
 function cheatLine(entry, gitState) {
   const shrank = gitState.shrunkFiles.has(path29.resolve(entry.file));
   if (!shrank || gitState.newFileCreated) return "";
   return `
-    ${chalk120.red("\u2717 You shrank existing lines in this file without creating a new file. That cannot clear the gate \u2014 extract a responsibility to a new file.")}`;
+    ${chalk122.red("\u2717 You shrank existing lines in this file without creating a new file. That cannot clear the gate \u2014 extract a responsibility to a new file.")}`;
 }
 function printMaintainabilityFailure(failing, gitState) {
   const blocks = failing.map((entry) => `${remediationLine(entry)}${cheatLine(entry, gitState)}`).join("\n");
   console.error(
-    chalk120.red(
+    chalk122.red(
       `
 Fail: ${failing.length} file(s) below threshold \u2192 extract a responsibility to a new file.
 
 ${blocks}
 
-${chalk120.bold("Diagnose and fix one file at a time.")} Only a new file (Write) or 'assist refactor extract' clears this gate \u2014 editing the existing lines does not.`
+${chalk122.bold("Diagnose and fix one file at a time.")} Only a new file (Write) or 'assist refactor extract' clears this gate \u2014 editing the existing lines does not.`
     )
   );
 }
 
 // src/commands/complexity/maintainability/printMaintainabilityFormula.ts
-import chalk121 from "chalk";
+import chalk123 from "chalk";
 var MI_FORMULA = "171 - 5.2*ln(HalsteadVolume) - 0.23*CyclomaticComplexity - 16.2*ln(SLOC), clamped 0-100";
 function printMaintainabilityFormula() {
-  console.log(chalk121.dim(MI_FORMULA));
+  console.log(chalk123.dim(MI_FORMULA));
 }
 
 // src/commands/complexity/maintainability/displayMaintainabilityResults.ts
@@ -14184,7 +14381,7 @@ function displayMaintainabilityResults(results, threshold, gitState = getMaintai
   if (!gating) {
     printMaintainabilityFormula();
     for (const entry of results) console.log(formatResultLine(entry, false));
-    console.log(chalk122.dim(`
+    console.log(chalk124.dim(`
 Analyzed ${results.length} files`));
     return;
   }
@@ -14193,14 +14390,14 @@ Analyzed ${results.length} files`));
     return limit !== void 0 && r.minMaintainability < limit;
   });
   if (failing.length === 0) {
-    console.log(chalk122.green("All files pass maintainability threshold"));
+    console.log(chalk124.green("All files pass maintainability threshold"));
   }
   const passingOverrides = results.filter(
     (r) => r.override !== void 0 && !failing.includes(r)
   );
   for (const entry of passingOverrides)
     console.log(formatResultLine(entry, false));
-  console.log(chalk122.dim(`
+  console.log(chalk124.dim(`
 Analyzed ${results.length} files`));
   if (failing.length > 0) {
     printMaintainabilityFailure(failing, gitState);
@@ -14223,7 +14420,7 @@ async function maintainability(pattern2 = "**/*.ts", options2 = {}) {
 
 // src/commands/complexity/sloc.ts
 import fs22 from "fs";
-import chalk123 from "chalk";
+import chalk125 from "chalk";
 async function sloc(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
@@ -14239,12 +14436,12 @@ async function sloc(pattern2 = "**/*.ts", options2 = {}) {
     results.sort((a, b) => b.lines - a.lines);
     for (const { file, lines } of results) {
       const exceedsThreshold = options2.threshold !== void 0 && lines > options2.threshold;
-      const color = exceedsThreshold ? chalk123.red : chalk123.white;
-      console.log(`${color(file)} \u2192 ${chalk123.cyan(lines)} lines`);
+      const color = exceedsThreshold ? chalk125.red : chalk125.white;
+      console.log(`${color(file)} \u2192 ${chalk125.cyan(lines)} lines`);
     }
     const total = results.reduce((sum, r) => sum + r.lines, 0);
     console.log(
-      chalk123.dim(`
+      chalk125.dim(`
 Total: ${total} lines across ${files.length} files`)
     );
     if (hasViolation) {
@@ -14258,25 +14455,25 @@ async function analyze(pattern2) {
   const searchPattern = pattern2.includes("*") || pattern2.includes("/") ? pattern2 : `**/${pattern2}`;
   const files = findSourceFiles2(searchPattern);
   if (files.length === 0) {
-    console.log(chalk124.yellow("No files found matching pattern"));
+    console.log(chalk126.yellow("No files found matching pattern"));
     return;
   }
   if (files.length === 1) {
     const file = files[0];
-    console.log(chalk124.bold.underline("SLOC"));
+    console.log(chalk126.bold.underline("SLOC"));
     await sloc(file);
     console.log();
-    console.log(chalk124.bold.underline("Cyclomatic Complexity"));
+    console.log(chalk126.bold.underline("Cyclomatic Complexity"));
     await cyclomatic(file);
     console.log();
-    console.log(chalk124.bold.underline("Halstead Metrics"));
+    console.log(chalk126.bold.underline("Halstead Metrics"));
     await halstead(file);
     console.log();
-    console.log(chalk124.bold.underline("Maintainability Index"));
+    console.log(chalk126.bold.underline("Maintainability Index"));
     await maintainability(file);
     console.log();
     console.log(
-      chalk124.dim(
+      chalk126.dim(
         "To improve the maintainability index, extract functions and logic out of this file into separate, smaller modules. Collapsing whitespace or removing comments is not the goal."
       )
     );
@@ -14327,7 +14524,7 @@ function configList() {
 }
 
 // src/commands/config/configGet.ts
-import chalk125 from "chalk";
+import chalk127 from "chalk";
 
 // src/commands/config/getNestedValue.ts
 function isTraversable(value) {
@@ -14359,15 +14556,15 @@ function requireNestedValue(config, key) {
   return value;
 }
 function exitKeyNotSet(key) {
-  console.error(chalk125.red(`Key "${key}" is not set`));
+  console.error(chalk127.red(`Key "${key}" is not set`));
   process.exit(1);
 }
 
 // src/commands/config/configSet.ts
-import chalk128 from "chalk";
+import chalk130 from "chalk";
 
 // src/commands/config/applyConfigSet.ts
-import chalk127 from "chalk";
+import chalk129 from "chalk";
 
 // src/commands/config/setNestedValue.ts
 function isPlainObject(val) {
@@ -14418,7 +14615,7 @@ function setNestedValue(obj, path71, value) {
 }
 
 // src/commands/config/validateConfig.ts
-import chalk126 from "chalk";
+import chalk128 from "chalk";
 function validateConfig(updated, key) {
   const result = assistConfigSchema.safeParse(updated);
   if (!result.success) return exitValidationFailed(result.error.issues, key);
@@ -14431,7 +14628,7 @@ function exitValidationFailed(issues, key) {
 function printValidationErrors(issues, key) {
   for (const issue of issues) {
     console.error(
-      chalk126.red(`${formatIssuePath(issue, key)}: ${issue.message}`)
+      chalk128.red(`${formatIssuePath(issue, key)}: ${issue.message}`)
     );
   }
 }
@@ -14456,7 +14653,7 @@ function applyConfigSet(key, coerced, global) {
 function assertNotGlobalOnly(key, global) {
   if (!global && GLOBAL_ONLY_KEYS.some((k) => key.startsWith(k))) {
     console.error(
-      chalk127.red(
+      chalk129.red(
         `"${key}" is a global-only key. Use --global to set it in ~/.assist.yml`
       )
     );
@@ -14517,19 +14714,19 @@ function resolveRepoTarget(key, value, repo) {
 function configSet(key, value, options2 = {}) {
   if (options2.repo !== void 0 && !options2.global) {
     console.error(
-      chalk128.red("--repo writes to the global config; add -g (e.g. -g --repo)")
+      chalk130.red("--repo writes to the global config; add -g (e.g. -g --repo)")
     );
     process.exit(1);
   }
   const resolved = resolveRepoTarget(key, value, options2.repo);
   if (resolved.value === void 0) {
-    console.error(chalk128.red(`Missing required argument for '${resolved.key}'`));
+    console.error(chalk130.red(`Missing required argument for '${resolved.key}'`));
     process.exit(1);
   }
   const coerced = coerceValue(resolved.value);
   const target = resolved.useRepo ? `repo: ${applyRepoConfigSet(resolved.key, coerced, resolved.repoName)}` : applyConfigSet(resolved.key, coerced, options2.global ?? false);
   console.log(
-    chalk128.green(`Set ${resolved.key} = ${JSON.stringify(coerced)} (${target})`)
+    chalk130.green(`Set ${resolved.key} = ${JSON.stringify(coerced)} (${target})`)
   );
 }
 function coerceValue(value) {
@@ -14550,40 +14747,40 @@ function registerConfig(program2) {
 }
 
 // src/commands/db/reportMigrationStatus.ts
-import chalk129 from "chalk";
+import chalk131 from "chalk";
 function reportApplied(applied) {
   if (applied.length === 0) {
-    console.error(chalk129.green("Database is up to date; nothing to apply."));
+    console.error(chalk131.green("Database is up to date; nothing to apply."));
     return;
   }
   for (const migration of applied) {
     console.error(
-      chalk129.green(`Applied migration ${migration.id} (${migration.name}).`)
+      chalk131.green(`Applied migration ${migration.id} (${migration.name}).`)
     );
   }
 }
 function reportMigrationStatus(status3) {
   if (status3.state === "in-sync") {
     console.error(
-      chalk129.green(`In sync at migration ${status3.version} (latest).`)
+      chalk131.green(`In sync at migration ${status3.version} (latest).`)
     );
     return;
   }
   if (status3.state === "behind") {
     console.error(
-      chalk129.yellow(
+      chalk131.yellow(
         `Behind: applied ${status3.applied}, build expects ${status3.expected}.`
       )
     );
     console.error(
-      chalk129.yellow(
+      chalk131.yellow(
         `Pending: ${status3.pending.join(", ")}. Run \`assist db migrate\`.`
       )
     );
     return;
   }
   console.error(
-    chalk129.red(
+    chalk131.red(
       `Ahead: applied ${status3.applied}, build knows ${status3.expected}. Update assist.`
     )
   );
@@ -14618,7 +14815,7 @@ function registerDb(program2) {
 
 // src/commands/dbMigration/dbMigrationConfirm.ts
 import { unlinkSync as unlinkSync9, writeFileSync as writeFileSync26 } from "fs";
-import chalk130 from "chalk";
+import chalk132 from "chalk";
 
 // src/commands/dbMigration/getMigrationPinPath.ts
 import { join as join35 } from "path";
@@ -14630,12 +14827,12 @@ function getMigrationApprovalPath(migrationId) {
 }
 
 // src/commands/dbMigration/readMigrationPinState.ts
-import { existsSync as existsSync34, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync29 } from "fs";
 function readMigrationPinState(pin) {
   const path71 = getMigrationPinPath(pin);
   if (!existsSync34(path71)) return void 0;
   try {
-    const state = JSON.parse(readFileSync28(path71, "utf8"));
+    const state = JSON.parse(readFileSync29(path71, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -14649,7 +14846,7 @@ function dbMigrationConfirm(pin) {
   sweepRestrictedDir();
   const state = readMigrationPinState(pin);
   if (!state) {
-    console.error(chalk130.red(`No pending migration unlock for pin: ${pin}`));
+    console.error(chalk132.red(`No pending migration unlock for pin: ${pin}`));
     process.exitCode = 1;
     return;
   }
@@ -14659,7 +14856,7 @@ function dbMigrationConfirm(pin) {
   );
   unlinkSync9(getMigrationPinPath(pin));
   console.log(
-    chalk130.green(
+    chalk132.green(
       `Approved creation of migration ${state.migrationId}. The next write of that migration module will be allowed once.`
     )
   );
@@ -14668,7 +14865,7 @@ function dbMigrationConfirm(pin) {
 // src/commands/dbMigration/dbMigrationUnlock.ts
 import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync27 } from "fs";
 import { randomInt as randomInt2 } from "crypto";
-import chalk131 from "chalk";
+import chalk133 from "chalk";
 
 // src/commands/dbMigration/nextMigrationId.ts
 function nextMigrationId() {
@@ -14683,7 +14880,7 @@ function dbMigrationUnlock() {
   sweepRestrictedDir();
   writeFileSync27(getMigrationPinPath(pin), JSON.stringify({ pin, migrationId }));
   console.error(
-    chalk131.yellow.bold(
+    chalk133.yellow.bold(
       "THIS IS YOUR LAST CHANCE TO RECONSIDER BEFORE INVOLVING A HUMAN.\nRequesting this pin pages a real person to approve a new database migration.\nA schema change is hard to reverse once shipped. You had BETTER have confirmed\nthe change with the user and be certain this migration is genuinely necessary."
     )
   );
@@ -14693,7 +14890,7 @@ function dbMigrationUnlock() {
   });
   if (!delivered) {
     console.error(
-      chalk131.red(
+      chalk133.red(
         "Could not deliver the confirmation pin via notification.\nThe migration cannot be approved until the notification channel works."
       )
     );
@@ -14703,7 +14900,7 @@ function dbMigrationUnlock() {
   console.log(
     `A confirmation pin was sent to your desktop notifications.
 To approve creating migration ${migrationId}, run:
-${chalk131.cyan("  assist db-migration confirm <PIN>")}
+${chalk133.cyan("  assist db-migration confirm <PIN>")}
 using the pin from that notification.`
   );
 }
@@ -14722,8 +14919,8 @@ function registerDbMigration(parent) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync35, readFileSync as readFileSync29, writeFileSync as writeFileSync28 } from "fs";
-import chalk132 from "chalk";
+import { existsSync as existsSync35, readFileSync as readFileSync30, writeFileSync as writeFileSync28 } from "fs";
+import chalk134 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
         window.location.href = \`\${window.location.pathname}/\${window.location.search}\${window.location.hash}\`;
@@ -14732,23 +14929,23 @@ var TRAILING_SLASH_SCRIPT = `    <script>
 function redirect() {
   const indexPath = "index.html";
   if (!existsSync35(indexPath)) {
-    console.log(chalk132.yellow("No index.html found"));
+    console.log(chalk134.yellow("No index.html found"));
     return;
   }
-  const content = readFileSync29(indexPath, "utf8");
+  const content = readFileSync30(indexPath, "utf8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
-    console.log(chalk132.dim("Trailing slash script already present"));
+    console.log(chalk134.dim("Trailing slash script already present"));
     return;
   }
   const headCloseIndex = content.indexOf("</head>");
   if (headCloseIndex === -1) {
-    console.log(chalk132.red("Could not find </head> tag in index.html"));
+    console.log(chalk134.red("Could not find </head> tag in index.html"));
     return;
   }
   const newContent = `${content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT}
   ${content.slice(headCloseIndex)}`;
   writeFileSync28(indexPath, newContent);
-  console.log(chalk132.green("Added trailing slash redirect to index.html"));
+  console.log(chalk134.green("Added trailing slash redirect to index.html"));
 }
 
 // src/commands/registerDeploy.ts
@@ -14775,10 +14972,10 @@ function loadBlogSkipDays(repoName) {
 
 // src/commands/devlog/shared.ts
 import { execSync as execSync33 } from "child_process";
-import chalk133 from "chalk";
+import chalk135 from "chalk";
 
 // src/shared/getRepoName.ts
-import { existsSync as existsSync36, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync31 } from "fs";
 import { basename as basename8, join as join37 } from "path";
 function getRepoName() {
   const config = loadConfig();
@@ -14788,7 +14985,7 @@ function getRepoName() {
   const packageJsonPath = join37(process.cwd(), "package.json");
   if (existsSync36(packageJsonPath)) {
     try {
-      const content = readFileSync30(packageJsonPath, "utf8");
+      const content = readFileSync31(packageJsonPath, "utf8");
       const pkg = JSON.parse(content);
       if (pkg.name) {
         return pkg.name;
@@ -14800,7 +14997,7 @@ function getRepoName() {
 }
 
 // src/commands/devlog/loadDevlogEntries.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync31 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync32 } from "fs";
 import { join as join38 } from "path";
 var DEVLOG_DIR = join38(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
@@ -14830,7 +15027,7 @@ function readDevlogFiles(callback) {
   try {
     const files = readdirSync4(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync31(join38(DEVLOG_DIR, file), "utf8");
+      const content = readFileSync32(join38(DEVLOG_DIR, file), "utf8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -14884,13 +15081,13 @@ function shouldIgnoreCommit(files, ignorePaths) {
 }
 function printCommitsWithFiles(commits2, ignore3, verbose) {
   for (const commit2 of commits2) {
-    console.log(`  ${chalk133.yellow(commit2.hash)} ${commit2.message}`);
+    console.log(`  ${chalk135.yellow(commit2.hash)} ${commit2.message}`);
     if (verbose) {
       const visibleFiles = commit2.files.filter(
         (file) => !ignore3.some((p) => file.startsWith(p))
       );
       for (const file of visibleFiles) {
-        console.log(`    ${chalk133.dim(file)}`);
+        console.log(`    ${chalk135.dim(file)}`);
       }
     }
   }
@@ -14915,15 +15112,15 @@ function parseGitLogCommits(output, ignore3, afterDate) {
 }
 
 // src/commands/devlog/list/printDateHeader.ts
-import chalk134 from "chalk";
+import chalk136 from "chalk";
 function printDateHeader(date, isSkipped, entries) {
   if (isSkipped) {
-    console.log(`${chalk134.bold.blue(date)} ${chalk134.dim("skipped")}`);
+    console.log(`${chalk136.bold.blue(date)} ${chalk136.dim("skipped")}`);
   } else if (entries && entries.length > 0) {
-    const entryInfo = entries.map((e) => `${chalk134.green(e.version)} ${e.title}`).join(" | ");
-    console.log(`${chalk134.bold.blue(date)} ${entryInfo}`);
+    const entryInfo = entries.map((e) => `${chalk136.green(e.version)} ${e.title}`).join(" | ");
+    console.log(`${chalk136.bold.blue(date)} ${entryInfo}`);
   } else {
-    console.log(`${chalk134.bold.blue(date)} ${chalk134.red("\u26A0 devlog missing")}`);
+    console.log(`${chalk136.bold.blue(date)} ${chalk136.red("\u26A0 devlog missing")}`);
   }
 }
 
@@ -15027,24 +15224,24 @@ function bumpVersion(version2, type) {
 
 // src/commands/devlog/next/displayNextEntry/index.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import chalk136 from "chalk";
+import chalk138 from "chalk";
 
 // src/commands/devlog/next/displayNextEntry/displayVersion.ts
-import chalk135 from "chalk";
+import chalk137 from "chalk";
 function displayVersion(conventional, firstHash, patchVersion, minorVersion) {
   if (conventional && firstHash) {
     const version2 = getVersionAtCommit(firstHash);
     if (version2) {
-      console.log(`${chalk135.bold("version:")} ${stripToMinor(version2)}`);
+      console.log(`${chalk137.bold("version:")} ${stripToMinor(version2)}`);
     } else {
-      console.log(`${chalk135.bold("version:")} ${chalk135.red("unknown")}`);
+      console.log(`${chalk137.bold("version:")} ${chalk137.red("unknown")}`);
     }
   } else if (patchVersion && minorVersion) {
     console.log(
-      `${chalk135.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
+      `${chalk137.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
     );
   } else {
-    console.log(`${chalk135.bold("version:")} v0.1 (initial)`);
+    console.log(`${chalk137.bold("version:")} v0.1 (initial)`);
   }
 }
 
@@ -15092,16 +15289,16 @@ function noCommitsMessage(hasLastInfo) {
   return hasLastInfo ? "No commits after last versioned entry" : "No commits found";
 }
 function logName(repoName) {
-  console.log(`${chalk136.bold("name:")} ${repoName}`);
+  console.log(`${chalk138.bold("name:")} ${repoName}`);
 }
 function displayNextEntry(ctx, targetDate, commits2) {
   logName(ctx.repoName);
   printVersionInfo(ctx.config, ctx.lastInfo, commits2[0]?.hash);
-  console.log(chalk136.bold.blue(targetDate));
+  console.log(chalk138.bold.blue(targetDate));
   printCommitsWithFiles(commits2, ctx.ignore, ctx.verbose);
 }
 function logNoCommits(lastInfo) {
-  console.log(chalk136.dim(noCommitsMessage(!!lastInfo)));
+  console.log(chalk138.dim(noCommitsMessage(!!lastInfo)));
 }
 
 // src/commands/devlog/next/index.ts
@@ -15142,11 +15339,11 @@ function next2(options2) {
 import { execSync as execSync35 } from "child_process";
 
 // src/commands/devlog/repos/printReposTable.ts
-import chalk137 from "chalk";
+import chalk139 from "chalk";
 function colorStatus(status3) {
-  if (status3 === "missing") return chalk137.red(status3);
-  if (status3 === "outdated") return chalk137.yellow(status3);
-  return chalk137.green(status3);
+  if (status3 === "missing") return chalk139.red(status3);
+  if (status3 === "outdated") return chalk139.yellow(status3);
+  return chalk139.green(status3);
 }
 function formatRow(row, nameWidth) {
   const devlog = (row.lastDevlog ?? "-").padEnd(11);
@@ -15160,8 +15357,8 @@ function printReposTable(rows) {
     "Last Devlog".padEnd(11),
     "Status"
   ].join("  ");
-  console.log(chalk137.dim(header));
-  console.log(chalk137.dim("-".repeat(header.length)));
+  console.log(chalk139.dim(header));
+  console.log(chalk139.dim("-".repeat(header.length)));
   for (const row of rows) {
     console.log(formatRow(row, nameWidth));
   }
@@ -15219,14 +15416,14 @@ function repos(options2) {
 // src/commands/devlog/skip.ts
 import { writeFileSync as writeFileSync29 } from "fs";
 import { join as join39 } from "path";
-import chalk138 from "chalk";
+import chalk140 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
   return join39(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
-    console.log(chalk138.red("Invalid date format. Use YYYY-MM-DD"));
+    console.log(chalk140.red("Invalid date format. Use YYYY-MM-DD"));
     process.exit(1);
   }
   const repoName = getRepoName();
@@ -15237,7 +15434,7 @@ function skip(date) {
   const skipDays = skip2[repoName] ?? [];
   if (skipDays.includes(date)) {
     console.log(
-      chalk138.yellow(`${date} is already in skip list for ${repoName}`)
+      chalk140.yellow(`${date} is already in skip list for ${repoName}`)
     );
     return;
   }
@@ -15247,20 +15444,20 @@ function skip(date) {
   devlog.skip = skip2;
   config.devlog = devlog;
   writeFileSync29(configPath, stringifyYaml3(config, { lineWidth: 0 }));
-  console.log(chalk138.green(`Added ${date} to skip list for ${repoName}`));
+  console.log(chalk140.green(`Added ${date} to skip list for ${repoName}`));
 }
 
 // src/commands/devlog/version.ts
-import chalk139 from "chalk";
+import chalk141 from "chalk";
 function version() {
   const config = loadConfig();
   const name = getRepoName();
   const lastInfo = getLastVersionInfo(name, config);
   const lastVersion = lastInfo?.version ?? null;
   const nextVersion = lastVersion ? bumpVersion(lastVersion, "patch") : null;
-  console.log(`${chalk139.bold("name:")} ${name}`);
-  console.log(`${chalk139.bold("last:")} ${lastVersion ?? chalk139.dim("none")}`);
-  console.log(`${chalk139.bold("next:")} ${nextVersion ?? chalk139.dim("none")}`);
+  console.log(`${chalk141.bold("name:")} ${name}`);
+  console.log(`${chalk141.bold("last:")} ${lastVersion ?? chalk141.dim("none")}`);
+  console.log(`${chalk141.bold("next:")} ${nextVersion ?? chalk141.dim("none")}`);
 }
 
 // src/commands/devlog/devlogConfigHelp.ts
@@ -15304,7 +15501,7 @@ function registerDevlog(program2) {
 // src/commands/dotnet/checkBuildLocks.ts
 import { closeSync as closeSync3, openSync as openSync3, readdirSync as readdirSync5 } from "fs";
 import { join as join40 } from "path";
-import chalk140 from "chalk";
+import chalk142 from "chalk";
 
 // src/shared/findRepoRoot.ts
 import { existsSync as existsSync37 } from "fs";
@@ -15367,22 +15564,22 @@ function checkBuildLocks(startDir) {
   const locked = findFirstLockedDll(startDir ?? getSearchRoot());
   if (locked) {
     console.error(
-      chalk140.red("Build output locked (is VS debugging?): ") + locked
+      chalk142.red("Build output locked (is VS debugging?): ") + locked
     );
     process.exit(1);
   }
 }
 async function checkBuildLocksCommand() {
   checkBuildLocks();
-  console.log(chalk140.green("No build locks detected"));
+  console.log(chalk142.green("No build locks detected"));
 }
 
 // src/commands/dotnet/buildTree.ts
-import { readFileSync as readFileSync32 } from "fs";
+import { readFileSync as readFileSync33 } from "fs";
 import path31 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
-  const content = readFileSync32(csprojPath, "utf8");
+  const content = readFileSync33(csprojPath, "utf8");
   const refs = [];
   for (const match of content.matchAll(PROJECT_REF_RE)) {
     refs.push(match[1].replace(/\\/g, "/"));
@@ -15399,7 +15596,7 @@ function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
   for (const ref of getProjectRefs(abs)) {
     const childAbs = path31.resolve(dir, ref);
     try {
-      readFileSync32(childAbs);
+      readFileSync33(childAbs);
       node.children.push(buildTree(childAbs, repoRoot, visited));
     } catch {
       node.children.push({
@@ -15424,7 +15621,7 @@ function collectAllDeps(node) {
 }
 
 // src/commands/dotnet/findContainingSolutions.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync33, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync34, statSync as statSync5 } from "fs";
 import path32 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
@@ -15459,7 +15656,7 @@ function findContainingSolutions(csprojPath, repoRoot) {
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
   for (const sln of slnFiles) {
     try {
-      const content = readFileSync33(sln, "utf8");
+      const content = readFileSync34(sln, "utf8");
       if (pattern2.test(content)) {
         matches.push(path32.relative(repoRoot, sln));
       }
@@ -15473,30 +15670,30 @@ function escapeRegex(s) {
 }
 
 // src/commands/dotnet/printTree.ts
-import chalk141 from "chalk";
+import chalk143 from "chalk";
 function printNodes(nodes, prefix2) {
   for (let i = 0; i < nodes.length; i++) {
     const isLast = i === nodes.length - 1;
     const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
     const childPrefix = isLast ? "    " : "\u2502   ";
     const isMissing = nodes[i].relativePath.startsWith("[MISSING]");
-    const label2 = isMissing ? chalk141.red(nodes[i].relativePath) : nodes[i].relativePath;
+    const label2 = isMissing ? chalk143.red(nodes[i].relativePath) : nodes[i].relativePath;
     console.log(`${prefix2}${connector}${label2}`);
     printNodes(nodes[i].children, prefix2 + childPrefix);
   }
 }
 function printTree(tree, totalCount, solutions) {
-  console.log(chalk141.bold("\nProject Dependency Tree"));
-  console.log(chalk141.cyan(tree.relativePath));
+  console.log(chalk143.bold("\nProject Dependency Tree"));
+  console.log(chalk143.cyan(tree.relativePath));
   printNodes(tree.children, "");
-  console.log(chalk141.dim(`
+  console.log(chalk143.dim(`
 ${totalCount} projects total (including root)`));
-  console.log(chalk141.bold("\nSolution Membership"));
+  console.log(chalk143.bold("\nSolution Membership"));
   if (solutions.length === 0) {
-    console.log(chalk141.yellow("  Not found in any .sln"));
+    console.log(chalk143.yellow("  Not found in any .sln"));
   } else {
     for (const sln of solutions) {
-      console.log(`  ${chalk141.green(sln)}`);
+      console.log(`  ${chalk143.green(sln)}`);
     }
   }
   console.log();
@@ -15525,16 +15722,16 @@ function printJson(tree, totalCount, solutions) {
 // src/commands/dotnet/resolveCsproj.ts
 import { existsSync as existsSync38 } from "fs";
 import path33 from "path";
-import chalk142 from "chalk";
+import chalk144 from "chalk";
 function resolveCsproj(csprojPath) {
   const resolved = path33.resolve(csprojPath);
   if (!existsSync38(resolved)) {
-    console.error(chalk142.red(`File not found: ${resolved}`));
+    console.error(chalk144.red(`File not found: ${resolved}`));
     process.exit(1);
   }
   const repoRoot = findRepoRoot(path33.dirname(resolved));
   if (!repoRoot) {
-    console.error(chalk142.red("Could not find git repository root"));
+    console.error(chalk144.red("Could not find git repository root"));
     process.exit(1);
   }
   return { resolved, repoRoot };
@@ -15584,12 +15781,12 @@ function getChangedCsFiles(scope) {
 }
 
 // src/commands/dotnet/inSln.ts
-import chalk143 from "chalk";
+import chalk145 from "chalk";
 async function inSln(csprojPath) {
   const { resolved, repoRoot } = resolveCsproj(csprojPath);
   const solutions = findContainingSolutions(resolved, repoRoot);
   if (solutions.length === 0) {
-    console.log(chalk143.yellow("Not found in any .sln file"));
+    console.log(chalk145.yellow("Not found in any .sln file"));
     process.exit(1);
   }
   for (const sln of solutions) {
@@ -15598,7 +15795,7 @@ async function inSln(csprojPath) {
 }
 
 // src/commands/dotnet/inspect.ts
-import chalk149 from "chalk";
+import chalk151 from "chalk";
 
 // src/shared/formatElapsed.ts
 function formatElapsed(ms) {
@@ -15610,12 +15807,12 @@ function formatElapsed(ms) {
 }
 
 // src/commands/dotnet/displayIssues.ts
-import chalk144 from "chalk";
+import chalk146 from "chalk";
 var SEVERITY_COLOR = {
-  ERROR: chalk144.red,
-  WARNING: chalk144.yellow,
-  SUGGESTION: chalk144.cyan,
-  HINT: chalk144.dim
+  ERROR: chalk146.red,
+  WARNING: chalk146.yellow,
+  SUGGESTION: chalk146.cyan,
+  HINT: chalk146.dim
 };
 function groupByFile(issues) {
   const byFile = /* @__PURE__ */ new Map();
@@ -15631,15 +15828,15 @@ function groupByFile(issues) {
 }
 function displayIssues(issues) {
   for (const [file, fileIssues] of groupByFile(issues)) {
-    console.log(chalk144.bold(file));
+    console.log(chalk146.bold(file));
     for (const issue of fileIssues.sort((a, b) => a.line - b.line)) {
-      const color = SEVERITY_COLOR[issue.severity] ?? chalk144.white;
+      const color = SEVERITY_COLOR[issue.severity] ?? chalk146.white;
       console.log(
-        `  ${chalk144.dim(`${issue.line}:`)} ${color(issue.severity)} [${issue.typeId}] ${issue.message}`
+        `  ${chalk146.dim(`${issue.line}:`)} ${color(issue.severity)} [${issue.typeId}] ${issue.message}`
       );
     }
   }
-  console.log(chalk144.dim(`
+  console.log(chalk146.dim(`
 ${issues.length} issue(s) found`));
 }
 
@@ -15698,12 +15895,12 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 // src/commands/dotnet/resolveSolution.ts
 import { existsSync as existsSync39 } from "fs";
 import path34 from "path";
-import chalk146 from "chalk";
+import chalk148 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
 import { readdirSync as readdirSync7 } from "fs";
 import { dirname as dirname22, join as join41 } from "path";
-import chalk145 from "chalk";
+import chalk147 from "chalk";
 function findSlnInDir(dir) {
   try {
     return readdirSync7(dir).filter((f) => f.endsWith(".sln")).map((f) => join41(dir, f));
@@ -15719,17 +15916,17 @@ function findSolution() {
     const slnFiles = findSlnInDir(current);
     if (slnFiles.length === 1) return slnFiles[0];
     if (slnFiles.length > 1) {
-      console.error(chalk145.red(`Multiple .sln files found in ${current}:`));
+      console.error(chalk147.red(`Multiple .sln files found in ${current}:`));
       for (const f of slnFiles) console.error(`  ${f}`);
       console.error(
-        chalk145.yellow("Specify which one: assist dotnet inspect <sln>")
+        chalk147.yellow("Specify which one: assist dotnet inspect <sln>")
       );
       process.exit(1);
     }
     if (current === ceiling) break;
     current = dirname22(current);
   }
-  console.error(chalk145.red("No .sln file found between cwd and repo root"));
+  console.error(chalk147.red("No .sln file found between cwd and repo root"));
   process.exit(1);
 }
 
@@ -15738,7 +15935,7 @@ function resolveSolution(sln) {
   if (sln) {
     const resolved = path34.resolve(sln);
     if (!existsSync39(resolved)) {
-      console.error(chalk146.red(`Solution file not found: ${resolved}`));
+      console.error(chalk148.red(`Solution file not found: ${resolved}`));
       process.exit(1);
     }
     return resolved;
@@ -15777,17 +15974,17 @@ function parseInspectReport(json) {
 
 // src/commands/dotnet/runInspectCode.ts
 import { execSync as execSync37 } from "child_process";
-import { existsSync as existsSync40, readFileSync as readFileSync34, unlinkSync as unlinkSync10 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync35, unlinkSync as unlinkSync10 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import path35 from "path";
-import chalk147 from "chalk";
+import chalk149 from "chalk";
 function assertJbInstalled() {
   try {
     execSync37("jb inspectcode --version", { stdio: "pipe" });
   } catch {
-    console.error(chalk147.red("jb is not installed. Install with:"));
+    console.error(chalk149.red("jb is not installed. Install with:"));
     console.error(
-      chalk147.yellow("  dotnet tool install -g JetBrains.ReSharper.GlobalTools")
+      chalk149.yellow("  dotnet tool install -g JetBrains.ReSharper.GlobalTools")
     );
     process.exit(1);
   }
@@ -15805,21 +16002,21 @@ function runInspectCode(slnPath, include, swea) {
     if (error && typeof error === "object" && "stderr" in error) {
       process.stderr.write(error.stderr);
     }
-    console.error(chalk147.red("jb inspectcode failed"));
+    console.error(chalk149.red("jb inspectcode failed"));
     process.exit(1);
   }
   if (!existsSync40(reportPath)) {
-    console.error(chalk147.red("Report file not generated"));
+    console.error(chalk149.red("Report file not generated"));
     process.exit(1);
   }
-  const xml = readFileSync34(reportPath, "utf8");
+  const xml = readFileSync35(reportPath, "utf8");
   unlinkSync10(reportPath);
   return xml;
 }
 
 // src/commands/dotnet/runRoslynInspect.ts
 import { execSync as execSync38 } from "child_process";
-import chalk148 from "chalk";
+import chalk150 from "chalk";
 function resolveMsbuildPath() {
   const { run: run4 } = loadConfig();
   const configs = resolveRunConfigs(run4, getConfigDir());
@@ -15831,9 +16028,9 @@ function assertMsbuildInstalled() {
   try {
     execSync38(`"${msbuild}" -version`, { stdio: "pipe" });
   } catch {
-    console.error(chalk148.red(`msbuild not found at: ${msbuild}`));
+    console.error(chalk150.red(`msbuild not found at: ${msbuild}`));
     console.error(
-      chalk148.yellow(
+      chalk150.yellow(
         "Configure it via a 'build' run entry in .claude/assist.yml or add msbuild to PATH."
       )
     );
@@ -15880,17 +16077,17 @@ function runEngine(resolved, changedFiles2, options2) {
 // src/commands/dotnet/inspect.ts
 function logScope(changedFiles2) {
   if (changedFiles2 === null) {
-    console.log(chalk149.dim("Inspecting full solution..."));
+    console.log(chalk151.dim("Inspecting full solution..."));
   } else {
     console.log(
-      chalk149.dim(`Inspecting ${changedFiles2.length} changed file(s)...`)
+      chalk151.dim(`Inspecting ${changedFiles2.length} changed file(s)...`)
     );
   }
 }
 function reportResults(issues, elapsed) {
   if (issues.length > 0) displayIssues(issues);
-  else console.log(chalk149.green("No issues found"));
-  console.log(chalk149.dim(`Completed in ${formatElapsed(elapsed)}`));
+  else console.log(chalk151.green("No issues found"));
+  console.log(chalk151.dim(`Completed in ${formatElapsed(elapsed)}`));
   if (issues.length > 0) process.exit(1);
 }
 async function inspect(sln, options2) {
@@ -15901,7 +16098,7 @@ async function inspect(sln, options2) {
   const scope = parseScope(options2.scope);
   const changedFiles2 = getChangedCsFiles(scope);
   if (changedFiles2 !== null && changedFiles2.length === 0) {
-    console.log(chalk149.green("No changed .cs files found"));
+    console.log(chalk151.green("No changed .cs files found"));
     return;
   }
   logScope(changedFiles2);
@@ -16284,25 +16481,25 @@ function fetchRepoCommitAuthors(org, repo, since) {
 }
 
 // src/commands/github/printCountTable.ts
-import chalk150 from "chalk";
+import chalk152 from "chalk";
 function printCountTable(labelHeader, rows) {
   const labelWidth = Math.max(
     labelHeader.length,
     ...rows.map((row) => row.label.length)
   );
   const header = `${labelHeader.padEnd(labelWidth)}  Commits`;
-  console.log(chalk150.dim(header));
-  console.log(chalk150.dim("-".repeat(header.length)));
+  console.log(chalk152.dim(header));
+  console.log(chalk152.dim("-".repeat(header.length)));
   for (const row of rows) {
     console.log(`${row.label.padEnd(labelWidth)}  ${row.count}`);
   }
 }
 
 // src/commands/github/printRepoAuthorBreakdown.ts
-import chalk151 from "chalk";
+import chalk153 from "chalk";
 function printRepoAuthorBreakdown(repos2) {
   for (const repo of repos2) {
-    console.log(chalk151.bold(repo.name));
+    console.log(chalk153.bold(repo.name));
     const authorWidth = Math.max(
       0,
       ...repo.authors.map((a) => a.author.length)
@@ -16409,7 +16606,7 @@ async function countPendingHandovers(orm, origin) {
 import {
   existsSync as existsSync42,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync35,
+  readFileSync as readFileSync36,
   rmSync as rmSync3,
   statSync as statSync6
 } from "fs";
@@ -16472,7 +16669,7 @@ function collectMarkdown(dir) {
   return out;
 }
 async function migrateFile(orm, origin, file, createdAt) {
-  const content = readFileSync35(file, "utf8");
+  const content = readFileSync36(file, "utf8");
   await saveHandover(orm, {
     origin,
     summary: summariseHandoverContent(content),
@@ -16620,7 +16817,7 @@ function registerHandover(program2) {
 }
 
 // src/commands/jira/acceptanceCriteria.ts
-import chalk152 from "chalk";
+import chalk154 from "chalk";
 
 // src/commands/jira/adfToText.ts
 function renderInline(node) {
@@ -16687,7 +16884,7 @@ function acceptanceCriteria(issueKey) {
   const parsed = fetchIssue(issueKey, field);
   const acValue = parsed?.fields?.[field];
   if (!acValue) {
-    console.log(chalk152.yellow(`No acceptance criteria found on ${issueKey}.`));
+    console.log(chalk154.yellow(`No acceptance criteria found on ${issueKey}.`));
     return;
   }
   if (typeof acValue === "string") {
@@ -16753,14 +16950,14 @@ async function jiraAuth() {
 }
 
 // src/commands/jira/viewIssue.ts
-import chalk153 from "chalk";
+import chalk155 from "chalk";
 function viewIssue(issueKey) {
   const parsed = fetchIssue(issueKey, "summary,description");
   const fields = parsed?.fields;
   const summary = fields?.summary;
   const description = fields?.description;
   if (summary) {
-    console.log(chalk153.bold(summary));
+    console.log(chalk155.bold(summary));
   }
   if (description) {
     if (summary) console.log();
@@ -16774,7 +16971,7 @@ function viewIssue(issueKey) {
   }
   if (!summary && !description) {
     console.log(
-      chalk153.yellow(`No summary or description found on ${issueKey}.`)
+      chalk155.yellow(`No summary or description found on ${issueKey}.`)
     );
   }
 }
@@ -16829,18 +17026,18 @@ function registerRefineLaunch(program2, resumeFlag) {
 
 // src/commands/reviewPrComments.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import { randomUUID as randomUUID3 } from "crypto";
-import chalk154 from "chalk";
+import { randomUUID as randomUUID4 } from "crypto";
+import chalk156 from "chalk";
 async function reviewPrComments(number) {
   if (number) {
     try {
       execFileSync5("gh", ["pr", "checkout", number], { stdio: "inherit" });
     } catch {
-      console.error(chalk154.red(`gh pr checkout ${number} failed; aborting.`));
+      console.error(chalk156.red(`gh pr checkout ${number} failed; aborting.`));
       process.exit(1);
     }
   }
-  const claudeSessionId = randomUUID3();
+  const claudeSessionId = randomUUID4();
   emitActivity({
     kind: "command",
     name: "review-pr-comments",
@@ -16909,15 +17106,15 @@ function registerList(program2) {
 // src/commands/mermaid/index.ts
 import { mkdirSync as mkdirSync16, readdirSync as readdirSync9 } from "fs";
 import { resolve as resolve13 } from "path";
-import chalk157 from "chalk";
+import chalk159 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
-import { readFileSync as readFileSync36, writeFileSync as writeFileSync31 } from "fs";
+import { readFileSync as readFileSync37, writeFileSync as writeFileSync31 } from "fs";
 import { basename as basename11, extname as extname2, resolve as resolve12 } from "path";
-import chalk156 from "chalk";
+import chalk158 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
-import chalk155 from "chalk";
+import chalk157 from "chalk";
 async function renderBlock(krokiUrl, source) {
   const response = await fetch(`${krokiUrl}/mermaid/svg`, {
     method: "POST",
@@ -16926,7 +17123,7 @@ async function renderBlock(krokiUrl, source) {
   });
   if (!response.ok) {
     console.error(
-      chalk155.red(
+      chalk157.red(
         `Kroki request failed: ${response.status} ${response.statusText}`
       )
     );
@@ -16938,25 +17135,25 @@ async function renderBlock(krokiUrl, source) {
 
 // src/commands/mermaid/exportFile.ts
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
-  const content = readFileSync36(file, "utf8");
+  const content = readFileSync37(file, "utf8");
   const blocks = extractMermaidBlocks(content);
   const stem = basename11(file, extname2(file));
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
-        chalk156.red(
+        chalk158.red(
           `${file}: --index ${onlyIndex} out of range (file has ${blocks.length} diagram(s))`
         )
       );
       process.exit(1);
     }
     console.log(
-      chalk156.gray(
+      chalk158.gray(
         `${file} \u2014 rendering diagram ${onlyIndex} of ${blocks.length}`
       )
     );
   } else {
-    console.log(chalk156.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
+    console.log(chalk158.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
   }
   for (const [i, source] of blocks.entries()) {
     const idx = i + 1;
@@ -16964,7 +17161,7 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
     const outPath = resolve12(outDir, `${stem}-${idx}.svg`);
     const svg = await renderBlock(krokiUrl, source);
     writeFileSync31(outPath, svg, "utf8");
-    console.log(chalk156.green(`  \u2192 ${outPath}`));
+    console.log(chalk158.green(`  \u2192 ${outPath}`));
   }
 }
 function extractMermaidBlocks(markdown) {
@@ -16980,18 +17177,18 @@ async function mermaidExport(file, options2 = {}) {
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
       console.error(
-        chalk157.red(`--index must be a positive integer (got ${options2.index})`)
+        chalk159.red(`--index must be a positive integer (got ${options2.index})`)
       );
       process.exit(1);
     }
     if (!file) {
-      console.error(chalk157.red("--index requires a file argument"));
+      console.error(chalk159.red("--index requires a file argument"));
       process.exit(1);
     }
   }
   const files = file ? [file] : readdirSync9(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
   if (files.length === 0) {
-    console.log(chalk157.gray("No markdown files found in current directory."));
+    console.log(chalk159.gray("No markdown files found in current directory."));
     return;
   }
   for (const f of files) {
@@ -17024,7 +17221,7 @@ function registerMermaid(program2) {
 import { mkdir as mkdir4 } from "fs/promises";
 import { createServer as createServer2 } from "http";
 import { dirname as dirname24 } from "path";
-import chalk159 from "chalk";
+import chalk161 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
 var corsHeaders = {
@@ -17103,7 +17300,7 @@ function createNetcapHandler(options2) {
 import { cp, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { networkInterfaces } from "os";
 import { join as join47 } from "path";
-import chalk158 from "chalk";
+import chalk160 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
 import { dirname as dirname23, join as join46 } from "path";
@@ -17147,7 +17344,7 @@ async function prepareExtensionForLoad(port, filter = "") {
   const host = lanIPv4();
   if (!host) {
     console.log(
-      chalk158.yellow("could not determine the WSL IP for the extension")
+      chalk160.yellow("could not determine the WSL IP for the extension")
     );
     await configureBackground(source, "127.0.0.1", port, filter);
     return source;
@@ -17158,7 +17355,7 @@ async function prepareExtensionForLoad(port, filter = "") {
     return WSL_WINDOWS_PATH;
   } catch {
     console.log(
-      chalk158.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
+      chalk160.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
     );
     return source;
   }
@@ -17191,30 +17388,30 @@ async function netcap(options2) {
   let count7 = 0;
   const handler = createNetcapHandler({
     outPath,
-    onPing: () => console.log(chalk159.dim("ping from extension")),
+    onPing: () => console.log(chalk161.dim("ping from extension")),
     onCapture: (entry) => {
       count7 += 1;
       console.log(
-        chalk159.green(`captured #${count7}`),
-        chalk159.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
+        chalk161.green(`captured #${count7}`),
+        chalk161.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
       );
     }
   });
   const server = createServer2(handler);
   server.listen(port, () => {
     console.log(
-      chalk159.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
+      chalk161.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
     );
-    console.log(chalk159.dim(`appending captures to ${outPath}`));
+    console.log(chalk161.dim(`appending captures to ${outPath}`));
     if (filter)
-      console.log(chalk159.dim(`forwarding only URLs matching "${filter}"`));
-    console.log(chalk159.dim(`load the unpacked extension from ${extensionPath}`));
-    console.log(chalk159.dim("press Ctrl-C to stop"));
+      console.log(chalk161.dim(`forwarding only URLs matching "${filter}"`));
+    console.log(chalk161.dim(`load the unpacked extension from ${extensionPath}`));
+    console.log(chalk161.dim("press Ctrl-C to stop"));
   });
   process.on("SIGINT", () => {
     server.close();
     console.log(
-      chalk159.bold(
+      chalk161.bold(
         `
 netcap stopped \u2014 captured ${count7} ${count7 === 1 ? "entry" : "entries"} to ${outPath}`
       )
@@ -17226,10 +17423,10 @@ netcap stopped \u2014 captured ${count7} ${count7 === 1 ? "entry" : "entries"} t
 // src/commands/netcap/netcapExtract.ts
 import { writeFileSync as writeFileSync32 } from "fs";
 import { join as join50 } from "path";
-import chalk160 from "chalk";
+import chalk162 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
-import { readFileSync as readFileSync37 } from "fs";
+import { readFileSync as readFileSync38 } from "fs";
 
 // src/commands/netcap/parseRscRows.ts
 var isRscRef = (v) => typeof v === "string" && /^\$[0-9a-fL@]/.test(v);
@@ -17625,7 +17822,7 @@ function extractVoyagerPosts(body) {
 
 // src/commands/netcap/extractPostsFromCapture.ts
 function captureEntries(captureFile) {
-  const lines = readFileSync37(captureFile, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync38(captureFile, "utf8").split("\n").filter(Boolean);
   const entries = [];
   for (const line of lines) {
     let entry;
@@ -17674,8 +17871,8 @@ function netcapExtract(file) {
   writeFileSync32(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
-    chalk160.green(`extracted ${posts.length} posts`),
-    chalk160.dim(`-> ${outFile}`)
+    chalk162.green(`extracted ${posts.length} posts`),
+    chalk162.dim(`-> ${outFile}`)
   );
 }
 
@@ -17696,7 +17893,7 @@ function registerNetcap(program2) {
 }
 
 // src/commands/news/add/index.ts
-import chalk161 from "chalk";
+import chalk163 from "chalk";
 import enquirer8 from "enquirer";
 async function add2(url) {
   if (!url) {
@@ -17718,10 +17915,10 @@ async function add2(url) {
   const { orm } = await getReady();
   const added = await addFeed(orm, url);
   if (!added) {
-    console.log(chalk161.yellow("Feed already exists"));
+    console.log(chalk163.yellow("Feed already exists"));
     return;
   }
-  console.log(chalk161.green(`Added feed: ${url}`));
+  console.log(chalk163.green(`Added feed: ${url}`));
 }
 
 // src/commands/registerNews.ts
@@ -17768,7 +17965,7 @@ function registerPiHook(program2) {
 }
 
 // src/commands/prompts/printPromptsTable.ts
-import chalk162 from "chalk";
+import chalk164 from "chalk";
 function truncate(str, max) {
   if (str.length <= max) return str;
   return `${str.slice(0, max - 1)}\u2026`;
@@ -17786,14 +17983,14 @@ function printPromptsTable(rows) {
     "Command".padEnd(commandWidth),
     "Repos"
   ].join("  ");
-  console.log(chalk162.dim(header));
-  console.log(chalk162.dim("-".repeat(header.length)));
+  console.log(chalk164.dim(header));
+  console.log(chalk164.dim("-".repeat(header.length)));
   for (const row of rows) {
     const count7 = String(row.count).padStart(countWidth);
     const tool = row.tool.padEnd(toolWidth);
     const command = truncate(row.command, 60).padEnd(commandWidth);
     console.log(
-      `${chalk162.yellow(count7)}  ${tool}  ${command}  ${chalk162.dim(row.repos)}`
+      `${chalk164.yellow(count7)}  ${tool}  ${command}  ${chalk164.dim(row.repos)}`
     );
   }
 }
@@ -18164,7 +18361,7 @@ import { tmpdir as tmpdir6 } from "os";
 import { join as join52 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync43, readFileSync as readFileSync38, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync39, unlinkSync as unlinkSync13 } from "fs";
 import { join as join51 } from "path";
 import { parse as parse2 } from "yaml";
 function getCachePath(prNumber) {
@@ -18175,7 +18372,7 @@ function loadCommentsCache(prNumber) {
   if (!existsSync43(cachePath)) {
     return null;
   }
-  const content = readFileSync38(cachePath, "utf8");
+  const content = readFileSync39(cachePath, "utf8");
   return parse2(content);
 }
 function deleteCommentsCache(prNumber) {
@@ -18360,20 +18557,20 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 }
 
 // src/commands/prs/listComments/printComments.ts
-import chalk163 from "chalk";
+import chalk165 from "chalk";
 function formatForHuman(comment3) {
   if (comment3.type === "review") {
-    const stateColor = comment3.state === "APPROVED" ? chalk163.green : comment3.state === "CHANGES_REQUESTED" ? chalk163.red : chalk163.yellow;
+    const stateColor = comment3.state === "APPROVED" ? chalk165.green : comment3.state === "CHANGES_REQUESTED" ? chalk165.red : chalk165.yellow;
     return [
-      `${chalk163.cyan("Review")} by ${chalk163.bold(comment3.user)} ${stateColor(`[${comment3.state}]`)}`,
+      `${chalk165.cyan("Review")} by ${chalk165.bold(comment3.user)} ${stateColor(`[${comment3.state}]`)}`,
       comment3.body,
       ""
     ].join("\n");
   }
   const location = comment3.line ? `:${comment3.line}` : "";
   return [
-    `${chalk163.cyan("Line comment")} by ${chalk163.bold(comment3.user)} on ${chalk163.dim(`${comment3.path}${location}`)}`,
-    chalk163.dim(comment3.diff_hunk.split("\n").slice(-3).join("\n")),
+    `${chalk165.cyan("Line comment")} by ${chalk165.bold(comment3.user)} on ${chalk165.dim(`${comment3.path}${location}`)}`,
+    chalk165.dim(comment3.diff_hunk.split("\n").slice(-3).join("\n")),
     comment3.body,
     ""
   ].join("\n");
@@ -18463,13 +18660,13 @@ import { execSync as execSync46 } from "child_process";
 import enquirer9 from "enquirer";
 
 // src/commands/prs/prs/displayPaginated/printPr.ts
-import chalk164 from "chalk";
+import chalk166 from "chalk";
 var STATUS_MAP = {
-  MERGED: (pr) => pr.mergedAt ? { label: chalk164.magenta("merged"), date: pr.mergedAt } : null,
-  CLOSED: (pr) => pr.closedAt ? { label: chalk164.red("closed"), date: pr.closedAt } : null
+  MERGED: (pr) => pr.mergedAt ? { label: chalk166.magenta("merged"), date: pr.mergedAt } : null,
+  CLOSED: (pr) => pr.closedAt ? { label: chalk166.red("closed"), date: pr.closedAt } : null
 };
 function defaultStatus(pr) {
-  return { label: chalk164.green("opened"), date: pr.createdAt };
+  return { label: chalk166.green("opened"), date: pr.createdAt };
 }
 function getStatus2(pr) {
   return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -18478,11 +18675,11 @@ function formatDate(dateStr) {
   return new Date(dateStr).toISOString().split("T")[0];
 }
 function formatPrHeader(pr, status3) {
-  return `${chalk164.cyan(`#${pr.number}`)} ${pr.title} ${chalk164.dim(`(${pr.author.login},`)} ${status3.label} ${chalk164.dim(`${formatDate(status3.date)})`)}`;
+  return `${chalk166.cyan(`#${pr.number}`)} ${pr.title} ${chalk166.dim(`(${pr.author.login},`)} ${status3.label} ${chalk166.dim(`${formatDate(status3.date)})`)}`;
 }
 function logPrDetails(pr) {
   console.log(
-    chalk164.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
+    chalk166.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
   console.log();
 }
@@ -18696,7 +18893,7 @@ async function placePr(prNumber, title, body, options2) {
 }
 
 // src/commands/prs/previewAndPlace.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/commands/prs/appendScreenshots.ts
 function appendScreenshots(body, screenshots) {
@@ -18708,99 +18905,15 @@ function appendScreenshots(body, screenshots) {
 ${screenshots.join("\n\n")}`;
 }
 
-// src/commands/prs/reportPrRejection.ts
-function reportPrRejection(decision) {
-  console.error(
-    `PR preview rejected${decision.reason ? `: ${decision.reason}` : "."}`
-  );
-  const comments3 = decision.comments ?? [];
-  if (comments3.length > 0) {
-    console.error(
-      `
-The reviewer left ${comments3.length} comment${comments3.length === 1 ? "" : "s"} on the preview. Address each one, then re-run this command:
-`
-    );
-    for (const [i, c] of comments3.entries()) {
-      const quoted = c.quote.split("\n").map((line) => `  > ${line}`).join("\n");
-      console.error(`${i + 1}. On:
-${quoted}
-   Comment: ${c.note}
-`);
-    }
-  }
-  process.exit(1);
-}
-
-// src/commands/prs/parseIncoming.ts
-function parseIncoming(line, requestId) {
-  try {
-    const msg = JSON.parse(line);
-    if (msg.type === "error" && (msg.message ?? "").includes("pr-preview"))
-      return { kind: "error", message: msg.message ?? "pr-preview failed" };
-    if (msg.type !== "pr-decision" || msg.requestId !== requestId) return null;
-    if (msg.decision !== "approve" && msg.decision !== "reject") return null;
-    return {
-      kind: "decision",
-      decision: {
-        decision: msg.decision,
-        reason: msg.reason,
-        comments: Array.isArray(msg.comments) ? msg.comments : void 0,
-        screenshots: Array.isArray(msg.screenshots) ? msg.screenshots : void 0
-      }
-    };
-  } catch {
-    return null;
-  }
-}
-
-// src/commands/prs/requestPrDecision.ts
-function requestPrDecision(request) {
-  return new Promise((resolve20, reject) => {
-    connectToDaemon().then((socket) => {
-      let settled = false;
-      const finish = (error, decision) => {
-        if (settled) return;
-        settled = true;
-        socket.destroy();
-        if (error) reject(error);
-        else resolve20(decision);
-      };
-      readSocketLines(socket, (line) => {
-        const incoming = parseIncoming(line, request.requestId);
-        if (!incoming) return;
-        if (incoming.kind === "error") finish(new Error(incoming.message));
-        else finish(void 0, incoming.decision);
-      });
-      socket.on("error", (error) => finish(error));
-      socket.on(
-        "close",
-        () => finish(new Error("daemon closed before a decision was made"))
-      );
-      socket.write(`${JSON.stringify({ type: "pr-preview", ...request })}
-`);
-    }, reject);
-  });
-}
-
 // src/commands/prs/previewAndPlace.ts
 async function previewAndPlace(args) {
-  console.log("Awaiting your approval in the assist web UI preview pane\u2026");
-  let decision;
-  try {
-    decision = await requestPrDecision({
-      sessionId: args.sessionId,
-      requestId: randomUUID4(),
-      title: args.title,
-      body: args.body,
-      prNumber: args.prNumber
-    });
-  } catch (error) {
-    console.error(
-      `Error: ${error instanceof Error ? error.message : String(error)}`
-    );
-    process.exit(1);
-  }
-  if (decision.decision === "reject") reportPrRejection(decision);
+  const decision = await awaitPreviewApproval("PR preview", {
+    sessionId: args.sessionId,
+    requestId: randomUUID5(),
+    title: args.title,
+    body: args.body,
+    prNumber: args.prNumber
+  });
   const body = appendScreenshots(args.body, decision.screenshots ?? []);
   await placePr(args.prNumber, args.title, body, args.options);
 }
@@ -19081,10 +19194,10 @@ function registerPrs(program2) {
 }
 
 // src/commands/ravendb/ravendbAuth.ts
-import chalk170 from "chalk";
+import chalk172 from "chalk";
 
 // src/shared/createConnectionAuth.ts
-import chalk165 from "chalk";
+import chalk167 from "chalk";
 function listConnections(connections, format) {
   if (connections.length === 0) {
     console.log("No connections configured.");
@@ -19097,7 +19210,7 @@ function listConnections(connections, format) {
 function removeConnection(connections, name, save) {
   const filtered = connections.filter((c) => c.name !== name);
   if (filtered.length === connections.length) {
-    console.error(chalk165.red(`Connection "${name}" not found.`));
+    console.error(chalk167.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   save(filtered);
@@ -19143,15 +19256,15 @@ function saveConnections(connections) {
 }
 
 // src/commands/ravendb/promptConnection.ts
-import chalk168 from "chalk";
+import chalk170 from "chalk";
 
 // src/commands/ravendb/selectOpSecret.ts
-import chalk167 from "chalk";
+import chalk169 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
 import { execSync as execSync49 } from "child_process";
-import chalk166 from "chalk";
+import chalk168 from "chalk";
 function opExec(args) {
   return execSync49(`op ${args}`, {
     encoding: "utf8",
@@ -19164,7 +19277,7 @@ function searchItems(search2) {
     items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
-      chalk166.red(
+      chalk168.red(
         "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
       )
     );
@@ -19178,7 +19291,7 @@ function getItemFields(itemId2) {
     const item = JSON.parse(opExec(`item get "${itemId2}" --format=json`));
     return item.fields.filter((f) => f.reference && f.label);
   } catch {
-    console.error(chalk166.red("Failed to get item details from 1Password."));
+    console.error(chalk168.red("Failed to get item details from 1Password."));
     process.exit(1);
   }
 }
@@ -19197,7 +19310,7 @@ async function selectOpSecret(searchTerm) {
   }).run();
   const items2 = searchItems(search2);
   if (items2.length === 0) {
-    console.error(chalk167.red(`No items found matching "${search2}".`));
+    console.error(chalk169.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId2 = await selectOne(
@@ -19206,7 +19319,7 @@ async function selectOpSecret(searchTerm) {
   );
   const fields = getItemFields(itemId2);
   if (fields.length === 0) {
-    console.error(chalk167.red("No fields with references found on this item."));
+    console.error(chalk169.red("No fields with references found on this item."));
     process.exit(1);
   }
   const ref = await selectOne(
@@ -19220,7 +19333,7 @@ async function selectOpSecret(searchTerm) {
 async function promptConnection(existingNames) {
   const name = await promptInput("name", "Connection name:");
   if (existingNames.includes(name)) {
-    console.error(chalk168.red(`Connection "${name}" already exists.`));
+    console.error(chalk170.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput(
@@ -19229,22 +19342,22 @@ async function promptConnection(existingNames) {
   );
   const database = await promptInput("database", "Database name:");
   if (!name || !url || !database) {
-    console.error(chalk168.red("All fields are required."));
+    console.error(chalk170.red("All fields are required."));
     process.exit(1);
   }
   const apiKeyRef = await selectOpSecret();
-  console.log(chalk168.dim(`Using: ${apiKeyRef}`));
+  console.log(chalk170.dim(`Using: ${apiKeyRef}`));
   return { name, url, database, apiKeyRef };
 }
 
 // src/commands/ravendb/ravendbSetConnection.ts
-import chalk169 from "chalk";
+import chalk171 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(chalk169.red(`Connection "${name}" not found.`));
+    console.error(chalk171.red(`Connection "${name}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -19260,16 +19373,16 @@ function ravendbSetConnection(name) {
 var ravendbAuth = createConnectionAuth({
   load: loadConnections,
   save: saveConnections,
-  format: (c) => `${chalk170.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
+  format: (c) => `${chalk172.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
   promptNew: promptConnection,
   onFirst: (c) => ravendbSetConnection(c.name)
 });
 
 // src/commands/ravendb/ravendbCollections.ts
-import chalk174 from "chalk";
+import chalk176 from "chalk";
 
 // src/commands/ravendb/ravenFetch.ts
-import chalk172 from "chalk";
+import chalk174 from "chalk";
 
 // src/commands/ravendb/getAccessToken.ts
 var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -19306,10 +19419,10 @@ ${errorText}`
 
 // src/commands/ravendb/resolveOpSecret.ts
 import { execSync as execSync50 } from "child_process";
-import chalk171 from "chalk";
+import chalk173 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
-    console.error(chalk171.red(`Invalid secret reference: must start with op://`));
+    console.error(chalk173.red(`Invalid secret reference: must start with op://`));
     process.exit(1);
   }
   try {
@@ -19319,7 +19432,7 @@ function resolveOpSecret(reference) {
     }).trim();
   } catch {
     console.error(
-      chalk171.red(
+      chalk173.red(
         "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
       )
     );
@@ -19346,7 +19459,7 @@ async function ravenFetch(connection, path71) {
   if (!response.ok) {
     const body = await response.text();
     console.error(
-      chalk172.red(`RavenDB error: ${response.status} ${response.statusText}`)
+      chalk174.red(`RavenDB error: ${response.status} ${response.statusText}`)
     );
     console.error(body.substring(0, 500));
     process.exit(1);
@@ -19355,7 +19468,7 @@ async function ravenFetch(connection, path71) {
 }
 
 // src/commands/ravendb/resolveConnection.ts
-import chalk173 from "chalk";
+import chalk175 from "chalk";
 function loadRavendb() {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb;
@@ -19369,7 +19482,7 @@ function resolveConnection(name) {
   const connectionName = name ?? defaultConnection;
   if (!connectionName) {
     console.error(
-      chalk173.red(
+      chalk175.red(
         "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
       )
     );
@@ -19377,7 +19490,7 @@ function resolveConnection(name) {
   }
   const connection = connections.find((c) => c.name === connectionName);
   if (!connection) {
-    console.error(chalk173.red(`Connection "${connectionName}" not found.`));
+    console.error(chalk175.red(`Connection "${connectionName}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -19408,7 +19521,7 @@ async function ravendbCollections(connectionName) {
     return;
   }
   for (const c of collections) {
-    console.log(`${chalk174.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+    console.log(`${chalk176.bold(c.Name)}  ${c.CountOfDocuments} docs`);
   }
 }
 
@@ -19427,10 +19540,10 @@ var ravendbConfigHelp = [
 ];
 
 // src/commands/ravendb/ravendbQuery.ts
-import chalk176 from "chalk";
+import chalk178 from "chalk";
 
 // src/commands/ravendb/fetchAllPages.ts
-import chalk175 from "chalk";
+import chalk177 from "chalk";
 
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
@@ -19468,7 +19581,7 @@ async function fetchAllPages(connection, opts) {
     allResults.push(...results);
     start3 += results.length;
     process.stderr.write(
-      `\r${chalk175.dim(`Fetched ${allResults.length}/${totalResults}`)}`
+      `\r${chalk177.dim(`Fetched ${allResults.length}/${totalResults}`)}`
     );
     if (start3 >= totalResults) break;
     if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
@@ -19483,7 +19596,7 @@ async function fetchAllPages(connection, opts) {
 async function ravendbQuery(connectionName, collection, options2) {
   const resolved = resolveArgs(connectionName, collection);
   if (!resolved.collection && !options2.query) {
-    console.error(chalk176.red("Provide a collection name or --query filter."));
+    console.error(chalk178.red("Provide a collection name or --query filter."));
     process.exit(1);
   }
   const { collection: col } = resolved;
@@ -19522,7 +19635,7 @@ import { spawn as spawn5 } from "child_process";
 import * as path36 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk177 from "chalk";
+import chalk179 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -19531,43 +19644,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk177.red(`
+  console.error(chalk179.red(`
 Refactor check failed:
 `));
-  console.error(chalk177.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk179.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk177.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk179.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk177.yellow(
+    chalk179.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk177.gray(`    assist refactor ignore <file>
+  console.error(chalk179.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk177.cyan(`
+    console.error(chalk179.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk177.cyan(
+      chalk179.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk177.cyan(
+      chalk179.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(
-      chalk177.cyan(
+      chalk179.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -19723,7 +19836,7 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/extract/index.ts
 import path44 from "path";
-import chalk180 from "chalk";
+import chalk182 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
@@ -20322,23 +20435,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 
 // src/commands/refactor/extract/displayPlan.ts
 import path40 from "path";
-import chalk178 from "chalk";
+import chalk180 from "chalk";
 function section2(title) {
   return `
-  ${chalk178.cyan(title)}`;
+  ${chalk180.cyan(title)}`;
 }
 function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section2("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
     const rel = path40.relative(cwd, imp.file.getFilePath());
-    console.log(`    ${chalk178.dim(rel)}: \u2192 import from "${imp.relPath}"`);
+    console.log(`    ${chalk180.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
 function displayPlan(functionName, relDest, plan2, cwd) {
-  console.log(chalk178.bold(`Extract: ${functionName} \u2192 ${relDest}
+  console.log(chalk180.bold(`Extract: ${functionName} \u2192 ${relDest}
 `));
-  console.log(`  ${chalk178.cyan("Functions to move:")}`);
+  console.log(`  ${chalk180.cyan("Functions to move:")}`);
   for (const name of plan2.extractedNames) {
     console.log(`    ${name}`);
   }
@@ -20372,7 +20485,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import path43 from "path";
-import chalk179 from "chalk";
+import chalk181 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
@@ -20464,7 +20577,7 @@ function loadProjectFile(file) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk179.red(`File not found in project: ${file}`));
+    console.log(chalk181.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   return { project, sourceFile };
@@ -20487,19 +20600,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(chalk180.green("\nExtraction complete"));
+    console.log(chalk182.green("\nExtraction complete"));
   } else {
-    console.log(chalk180.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk182.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/ignore.ts
 import fs28 from "fs";
-import chalk181 from "chalk";
+import chalk183 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore2(file) {
   if (!fs28.existsSync(file)) {
-    console.error(chalk181.red(`Error: File does not exist: ${file}`));
+    console.error(chalk183.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs28.readFileSync(file, "utf8");
@@ -20515,7 +20628,7 @@ function ignore2(file) {
     fs28.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk181.green(
+    chalk183.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -20524,12 +20637,12 @@ function ignore2(file) {
 // src/commands/refactor/rename/index.ts
 import fs31 from "fs";
 import path49 from "path";
-import chalk184 from "chalk";
+import chalk186 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs30 from "fs";
 import path46 from "path";
-import chalk182 from "chalk";
+import chalk184 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
 import path45 from "path";
@@ -20634,13 +20747,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs30.writeFileSync(file, content, "utf8");
-    console.log(chalk182.cyan(`  Updated imports in ${path46.relative(cwd, file)}`));
+    console.log(chalk184.cyan(`  Updated imports in ${path46.relative(cwd, file)}`));
   }
   const destDir = path46.dirname(destPath);
   if (!fs30.existsSync(destDir)) fs30.mkdirSync(destDir, { recursive: true });
   fs30.renameSync(sourcePath, destPath);
   console.log(
-    chalk182.white(
+    chalk184.white(
       `  Moved ${path46.relative(cwd, sourcePath)} \u2192 ${path46.relative(cwd, destPath)}`
     )
   );
@@ -20727,16 +20840,16 @@ function computeRenameRewrites(sourcePath, destPath) {
 
 // src/commands/refactor/rename/printRenamePreview.ts
 import path48 from "path";
-import chalk183 from "chalk";
+import chalk185 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
-      chalk183.dim(
+      chalk185.dim(
         `  ${path48.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
-  console.log(chalk183.dim("Dry run. Use --apply to execute."));
+  console.log(chalk185.dim("Dry run. Use --apply to execute."));
 }
 
 // src/commands/refactor/rename/index.ts
@@ -20747,20 +20860,20 @@ async function rename(source, destination, options2 = {}) {
   const relSource = path49.relative(cwd, sourcePath);
   const relDest = path49.relative(cwd, destPath);
   if (!fs31.existsSync(sourcePath)) {
-    console.log(chalk184.red(`File not found: ${source}`));
+    console.log(chalk186.red(`File not found: ${source}`));
     process.exit(1);
   }
   if (destPath !== sourcePath && fs31.existsSync(destPath)) {
-    console.log(chalk184.red(`Destination already exists: ${destination}`));
+    console.log(chalk186.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
-  console.log(chalk184.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  console.log(chalk184.dim("Loading project..."));
-  console.log(chalk184.dim("Scanning imports across the project..."));
+  console.log(chalk186.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk186.dim("Loading project..."));
+  console.log(chalk186.dim("Scanning imports across the project..."));
   const rewrites = computeRenameRewrites(sourcePath, destPath);
   const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
   console.log(
-    chalk184.dim(
+    chalk186.dim(
       `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
     )
   );
@@ -20769,11 +20882,11 @@ async function rename(source, destination, options2 = {}) {
     return;
   }
   applyRename(rewrites, sourcePath, destPath, cwd);
-  console.log(chalk184.green("Done"));
+  console.log(chalk186.green("Done"));
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import chalk185 from "chalk";
+import chalk187 from "chalk";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
 import { SyntaxKind as SyntaxKind15 } from "ts-morph";
@@ -20819,33 +20932,33 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const { project, sourceFile } = loadProjectFile(file);
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk185.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk187.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(
-    chalk185.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk187.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines] of grouped) {
     console.log(
-      `  ${chalk185.dim(refFile)}: lines ${chalk185.cyan(lines.join(", "))}`
+      `  ${chalk187.dim(refFile)}: lines ${chalk187.cyan(lines.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk185.green(`
+    console.log(chalk187.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk185.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk187.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
 import path57 from "path";
-import chalk188 from "chalk";
+import chalk190 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
 import path51 from "path";
@@ -20924,50 +21037,50 @@ function clusterFiles(graph) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path53 from "path";
-import chalk186 from "chalk";
+import chalk188 from "chalk";
 function relPath(filePath) {
   return path53.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk186.bold("\nFile moves:"));
+  console.log(chalk188.bold("\nFile moves:"));
   for (const move2 of plan2.moves) {
     console.log(
-      `  ${chalk186.red(relPath(move2.from))} \u2192 ${chalk186.green(relPath(move2.to))}`
+      `  ${chalk188.red(relPath(move2.from))} \u2192 ${chalk188.green(relPath(move2.to))}`
     );
-    console.log(chalk186.dim(`    ${move2.reason}`));
+    console.log(chalk188.dim(`    ${move2.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk186.bold(`
+  console.log(chalk188.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk186.cyan(relPath(file))}:`);
+    console.log(`  ${chalk188.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk186.red(`"${oldSpecifier}"`)} \u2192 ${chalk186.green(`"${newSpecifier}"`)}`
+        `    ${chalk188.red(`"${oldSpecifier}"`)} \u2192 ${chalk188.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk186.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk186.yellow(`  ${w}`));
+    console.log(chalk188.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk188.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk186.bold("\nNew directories:"));
+    console.log(chalk188.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk186.green(`  ${dir}/`));
+      console.log(chalk188.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk186.dim(
+    chalk188.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -20977,18 +21090,18 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 // src/commands/refactor/restructure/executePlan.ts
 import fs32 from "fs";
 import path54 from "path";
-import chalk187 from "chalk";
+import chalk189 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs32.writeFileSync(file, content, "utf8");
     console.log(
-      chalk187.cyan(`  Rewrote imports in ${path54.relative(process.cwd(), file)}`)
+      chalk189.cyan(`  Rewrote imports in ${path54.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs32.mkdirSync(dir, { recursive: true });
-    console.log(chalk187.green(`  Created ${path54.relative(process.cwd(), dir)}/`));
+    console.log(chalk189.green(`  Created ${path54.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
     const targetDir = path54.dirname(move2.to);
@@ -20997,7 +21110,7 @@ function executePlan(plan2) {
     }
     fs32.renameSync(move2.from, move2.to);
     console.log(
-      chalk187.white(
+      chalk189.white(
         `  Moved ${path54.relative(process.cwd(), move2.from)} \u2192 ${path54.relative(process.cwd(), move2.to)}`
       )
     );
@@ -21012,7 +21125,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs32.rmdirSync(dir);
       console.log(
-        chalk187.dim(
+        chalk189.dim(
           `  Removed empty directory ${path54.relative(process.cwd(), dir)}`
         )
       );
@@ -21145,22 +21258,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk188.yellow("No files found matching pattern"));
+    console.log(chalk190.yellow("No files found matching pattern"));
     return;
   }
   const tsConfigPath = findTsConfig(path57.resolve(files[0]));
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk188.green("No restructuring needed"));
+    console.log(chalk190.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk188.bold("\nApplying changes..."));
+    console.log(chalk190.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk188.green("\nRestructuring complete"));
+    console.log(chalk190.green("\nRestructuring complete"));
   } else {
-    console.log(chalk188.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk190.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -21482,7 +21595,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync39 } from "fs";
+import { readFileSync as readFileSync40 } from "fs";
 
 // src/commands/review/parseFindings.ts
 var SEVERITIES = ["blocker", "major", "minor", "nit"];
@@ -21743,18 +21856,18 @@ function partitionFindingsByDiff(findings, index3) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk189 from "chalk";
+import chalk191 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk189.yellow(
+    chalk191.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(
-      `  ${chalk189.yellow("\xB7")} ${finding.title} ${chalk189.dim(
+      `  ${chalk191.yellow("\xB7")} ${finding.title} ${chalk191.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -21773,18 +21886,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk190 from "chalk";
+import chalk192 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk190.yellow(
+    chalk192.yellow(
       `Skipped ${unlocated.length} finding(s) without a parseable file:line:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk190.dim("missing");
+    const where = finding.location || chalk192.dim("missing");
     console.warn(
-      `  ${chalk190.yellow("\xB7")} ${finding.title} ${chalk190.dim(`(${where})`)}`
+      `  ${chalk192.yellow("\xB7")} ${finding.title} ${chalk192.dim(`(${where})`)}`
     );
   }
 }
@@ -21797,7 +21910,7 @@ async function confirmPost(prNumber, count7, options2) {
 async function postReviewToPr(synthesisPath, options2) {
   const prInfo = fetchPrDiffInfo();
   const prNumber = prInfo.prNumber;
-  const markdown = readFileSync39(synthesisPath, "utf8");
+  const markdown = readFileSync40(synthesisPath, "utf8");
   const findings = parseFindings(markdown);
   if (findings.length === 0) {
     console.log("Synthesis contains no findings; nothing to post.");
@@ -22681,7 +22794,7 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync40 } from "fs";
+import { readFileSync as readFileSync41 } 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.
@@ -22737,7 +22850,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary2(synthesisPath) {
-  const markdown = readFileSync40(synthesisPath, "utf8");
+  const markdown = readFileSync41(synthesisPath, "utf8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -22956,7 +23069,7 @@ function registerReview(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk192 from "chalk";
+import chalk194 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -22985,10 +23098,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk191 from "chalk";
+import chalk193 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk191.red(`Connection "${name}" already exists.`));
+    console.error(chalk193.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -23006,7 +23119,7 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk192.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk194.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
@@ -23026,10 +23139,10 @@ var seqConfigHelp = [
 ];
 
 // src/commands/seq/seqQuery.ts
-import chalk196 from "chalk";
+import chalk198 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk193 from "chalk";
+import chalk195 from "chalk";
 async function fetchSeq(conn, path71, params) {
   const url = `${conn.url}${path71}?${params}`;
   const response = await fetch(url, {
@@ -23040,7 +23153,7 @@ async function fetchSeq(conn, path71, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk193.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk195.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -23099,23 +23212,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk194 from "chalk";
+import chalk196 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk194.bgRed.white;
+      return chalk196.bgRed.white;
     case "Error":
-      return chalk194.red;
+      return chalk196.red;
     case "Warning":
-      return chalk194.yellow;
+      return chalk196.yellow;
     case "Information":
-      return chalk194.cyan;
+      return chalk196.cyan;
     case "Debug":
-      return chalk194.gray;
+      return chalk196.gray;
     case "Verbose":
-      return chalk194.dim;
+      return chalk196.dim;
     default:
-      return chalk194.white;
+      return chalk196.white;
   }
 }
 function levelAbbrev(level) {
@@ -23156,12 +23269,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk194.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk196.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(chalk194.red(`  ${line}`));
+      lines.push(chalk196.red(`  ${line}`));
     }
   }
   return lines.join("\n");
@@ -23194,11 +23307,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk195 from "chalk";
+import chalk197 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk195.red(
+      chalk197.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -23207,7 +23320,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(chalk195.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk197.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -23236,7 +23349,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count7) })
   );
   if (events.length === 0) {
-    console.log(chalk196.yellow("No events found."));
+    console.log(chalk198.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -23247,11 +23360,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk196.dim(`
+  console.log(chalk198.dim(`
 ${events.length} events`));
   if (events.length >= count7) {
     console.log(
-      chalk196.yellow(
+      chalk198.yellow(
         `Results limited to ${count7}. Use --count to retrieve more.`
       )
     );
@@ -23259,10 +23372,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk197 from "chalk";
+import chalk199 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk197.red(`Connection "${name}" not found.`));
+    console.error(chalk199.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -23311,7 +23424,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk199 from "chalk";
+import chalk201 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -23340,7 +23453,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk198 from "chalk";
+import chalk200 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -23348,7 +23461,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk198.red(`Invalid port "${portStr}".`));
+    console.error(chalk200.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -23361,13 +23474,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk199.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk201.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk200 from "chalk";
+import chalk202 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -23376,7 +23489,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk200.yellow("(no rows)"));
+    console.log(chalk202.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -23384,13 +23497,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(chalk200.dim(header));
-  console.log(chalk200.dim("-".repeat(header.length)));
+  console.log(chalk202.dim(header));
+  console.log(chalk202.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(chalk200.dim(`
+  console.log(chalk202.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -23464,7 +23577,7 @@ var sqlConfigHelp = [
 ];
 
 // src/commands/sql/sqlMutate.ts
-import chalk201 from "chalk";
+import chalk203 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -23498,7 +23611,7 @@ function isMutation(sql25) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk201.red(
+      chalk203.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -23508,18 +23621,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk201.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk203.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk202 from "chalk";
+import chalk204 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk202.red(
+      chalk204.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -23534,7 +23647,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk202.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk204.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -23681,7 +23794,7 @@ function list4() {
 import {
   existsSync as existsSync49,
   mkdirSync as mkdirSync19,
-  readFileSync as readFileSync41,
+  readFileSync as readFileSync42,
   renameSync as renameSync2,
   writeFileSync as writeFileSync38
 } from "fs";
@@ -23893,7 +24006,7 @@ function formatChatLog(messages) {
 // src/commands/transcript/move.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function convertVttToMarkdown(inputPath) {
-  const cues = parseVtt(readFileSync41(inputPath, "utf8"));
+  const cues = parseVtt(readFileSync42(inputPath, "utf8"));
   const messages = cuesToChatMessages(deduplicateCues(cues));
   return formatChatLog(messages);
 }
@@ -24078,14 +24191,14 @@ function devices() {
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync50, readFileSync as readFileSync42 } from "fs";
+import { existsSync as existsSync50, readFileSync as readFileSync43 } from "fs";
 function logs(options2) {
   if (!existsSync50(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count7 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync42(voicePaths.log, "utf8").trim();
+  const content = readFileSync43(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -24112,7 +24225,7 @@ import { join as join61 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync56 } from "child_process";
-import { existsSync as existsSync51, mkdirSync as mkdirSync20, readFileSync as readFileSync43, writeFileSync as writeFileSync39 } from "fs";
+import { existsSync as existsSync51, mkdirSync as mkdirSync20, readFileSync as readFileSync44, writeFileSync as writeFileSync39 } from "fs";
 import { join as join60 } from "path";
 function isProcessAlive2(pid) {
   try {
@@ -24126,7 +24239,7 @@ function checkLockFile() {
   const lockFile = getLockFile();
   if (!existsSync51(lockFile)) return;
   try {
-    const lock2 = JSON.parse(readFileSync43(lockFile, "utf8"));
+    const lock2 = JSON.parse(readFileSync44(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock2.pid}, env: ${lock2.env}). Stop it first with: assist voice stop`
@@ -24228,7 +24341,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync52, readFileSync as readFileSync44 } from "fs";
+import { existsSync as existsSync52, readFileSync as readFileSync45 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -24239,7 +24352,7 @@ function isProcessAlive3(pid) {
 }
 function readRecentLogs(count7) {
   if (!existsSync52(voicePaths.log)) return [];
-  const lines = readFileSync44(voicePaths.log, "utf8").trim().split("\n");
+  const lines = readFileSync45(voicePaths.log, "utf8").trim().split("\n");
   return lines.slice(-count7);
 }
 function status2() {
@@ -24247,7 +24360,7 @@ function status2() {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync44(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync45(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -24266,13 +24379,13 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync53, readFileSync as readFileSync45, unlinkSync as unlinkSync19 } from "fs";
+import { existsSync as existsSync53, readFileSync as readFileSync46, unlinkSync as unlinkSync19 } from "fs";
 function stop2() {
   if (!existsSync53(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync45(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync46(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -24349,7 +24462,7 @@ function registerVoice(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk203 from "chalk";
+import chalk205 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -24480,13 +24593,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk203.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk205.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk203.white("http://localhost:14523/callback\n"));
-  console.log(chalk203.blue("Opening browser for authorization..."));
-  console.log(chalk203.dim("Waiting for authorization callback..."));
+  console.log(chalk205.white("http://localhost:14523/callback\n"));
+  console.log(chalk205.blue("Opening browser for authorization..."));
+  console.log(chalk205.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk203.dim("Exchanging code for tokens..."));
+  console.log(chalk205.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -24502,13 +24615,13 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk203.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk205.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import { readdirSync as readdirSync11, readFileSync as readFileSync46, statSync as statSync9 } from "fs";
+import { readdirSync as readdirSync11, readFileSync as readFileSync47, statSync as statSync9 } from "fs";
 import { join as join63 } from "path";
 function findPortFile(roamDir) {
   let entries;
@@ -24534,7 +24647,7 @@ function postRoamActivity(app, event) {
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync46(portFile, "utf8").trim();
+    port = readFileSync47(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -25045,7 +25158,7 @@ import { execSync as execSync58 } from "child_process";
 import { existsSync as existsSync56, mkdirSync as mkdirSync24, unlinkSync as unlinkSync21, writeFileSync as writeFileSync42 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
 import { join as join67, resolve as resolve17 } from "path";
-import chalk204 from "chalk";
+import chalk206 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -25196,13 +25309,13 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve17(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk204.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk206.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk204.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk206.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk204.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk206.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -25258,7 +25371,7 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/reportStolenSocket.ts
-import { readFileSync as readFileSync47 } from "fs";
+import { readFileSync as readFileSync48 } from "fs";
 function reportStolenSocket(socketPid) {
   if (!socketPid) return;
   const filePid = readPidFile();
@@ -25270,7 +25383,7 @@ function reportStolenSocket(socketPid) {
 function readPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync47(daemonPaths.pid, "utf8").trim(),
+      readFileSync48(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -25337,25 +25450,25 @@ function recentDaemonLogLines() {
 }
 
 // src/commands/sessions/daemon/persistedSessionSchema.ts
-import { z as z5 } from "zod";
-var persistedSessionSchema = z5.object({
-  name: z5.string(),
-  title: z5.string().optional(),
-  subtitle: z5.string().optional(),
-  commandType: z5.enum(["claude", "run", "assist"]),
-  harness: z5.enum(["claude", "codex", "pi"]).optional(),
-  status: z5.enum(["running", "waiting", "done", "error", "stopped"]).optional(),
-  cwd: z5.string(),
-  startedAt: z5.number(),
-  runningMs: z5.number().optional(),
-  claudeSessionId: z5.string().optional(),
-  initialPrompt: z5.string().optional(),
-  runName: z5.string().optional(),
-  runArgs: z5.array(z5.string()).optional(),
-  assistArgs: z5.array(z5.string()).optional(),
+import { z as z6 } from "zod";
+var persistedSessionSchema = z6.object({
+  name: z6.string(),
+  title: z6.string().optional(),
+  subtitle: z6.string().optional(),
+  commandType: z6.enum(["claude", "run", "assist"]),
+  harness: z6.enum(["claude", "codex", "pi"]).optional(),
+  status: z6.enum(["running", "waiting", "done", "error", "stopped"]).optional(),
+  cwd: z6.string(),
+  startedAt: z6.number(),
+  runningMs: z6.number().optional(),
+  claudeSessionId: z6.string().optional(),
+  initialPrompt: z6.string().optional(),
+  runName: z6.string().optional(),
+  runArgs: z6.array(z6.string()).optional(),
+  assistArgs: z6.array(z6.string()).optional(),
   activity: activitySchema.optional(),
-  starred: z5.boolean().optional(),
-  undurable: z5.object({ reason: z5.string(), removesTree: z5.boolean().optional() }).optional()
+  starred: z6.boolean().optional(),
+  undurable: z6.object({ reason: z6.string(), removesTree: z6.boolean().optional() }).optional()
 });
 
 // src/commands/sessions/daemon/toPersistedSession.ts
@@ -25523,9 +25636,9 @@ function createAutoExit(exit, graceMs = DEFAULT_GRACE_MS) {
 }
 
 // src/commands/sessions/daemon/loadActiveSelection.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var ACTIVE_FILE = "active.json";
-var activeSelectionSchema = z6.record(z6.string(), z6.string());
+var activeSelectionSchema = z7.record(z7.string(), z7.string());
 function loadActiveSelection() {
   const parsed = activeSelectionSchema.safeParse(
     loadJson(ACTIVE_FILE)
@@ -25732,7 +25845,7 @@ var ClientHub = class extends Set {
 };
 
 // src/commands/sessions/daemon/createSession.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // src/commands/sessions/daemon/resolveRunConfig.ts
 function resolveRunConfig(name, cwd) {
@@ -25871,7 +25984,7 @@ function sessionBase(id, status3) {
 // src/commands/sessions/daemon/createSession.ts
 function createSession(id, prompt, cwd, design, harness, holdPty) {
   if (harness === "pi") return createPiSession(id, prompt, cwd, holdPty);
-  const claudeSessionId = randomUUID5();
+  const claudeSessionId = randomUUID6();
   return {
     ...sessionBase(id, prompt ? "running" : "waiting"),
     name: prompt?.slice(0, 40) || `Session ${id}`,
@@ -26502,15 +26615,20 @@ function setPrPreview(sessions, waiters, notify2, client, d) {
     return;
   }
   const prNumber = typeof d.prNumber === "number" ? d.prNumber : null;
+  const kind = d.kind === "backlog-item" ? "backlog-item" : "pr";
+  const itemType = d.itemType === "bug" ? "bug" : "story";
   session.pendingPrPreview = {
     requestId: d.requestId,
     title: d.title,
     body: d.body,
-    prNumber
+    prNumber,
+    kind,
+    itemType: kind === "backlog-item" ? itemType : void 0
   };
   waiters.set(id, client);
+  const target = kind === "backlog-item" ? `backlog ${itemType}` : prNumber === null ? "create" : `edit #${prNumber}`;
   daemonLog(
-    `pr-preview set: id=${id} requestId=${d.requestId} target=${prNumber === null ? "create" : `edit #${prNumber}`}`
+    `pr-preview set: id=${id} requestId=${d.requestId} kind=${kind} target=${target}`
   );
   notify2();
 }
@@ -27036,7 +27154,7 @@ function respawnSession(session, respawn, status3, clients, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/respawnPlan.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/commands/sessions/daemon/assistResumeArgs.ts
 function assistResumeArgs(session) {
@@ -27077,7 +27195,7 @@ function respawnPlan(session) {
   return null;
 }
 function freshClaudePlan(session, prompt, cwd) {
-  const claudeSessionId = randomUUID6();
+  const claudeSessionId = randomUUID7();
   return {
     spawn: () => {
       session.claudeSessionId = claudeSessionId;
@@ -28197,14 +28315,14 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync69, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync69, readFileSync as readFileSync50 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
     if (!existsSync69(sessionsFile)) return false;
-    const data = JSON.parse(readFileSync49(sessionsFile, "utf8"));
+    const data = JSON.parse(readFileSync50(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
     const message2 = error instanceof Error ? error.message : String(error);
@@ -29432,7 +29550,7 @@ function handleConnection(socket, manager) {
 import { unlinkSync as unlinkSync22, writeFileSync as writeFileSync43 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync50 } from "fs";
+import { readFileSync as readFileSync51 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -29443,7 +29561,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync50(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync51(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -29632,7 +29750,7 @@ var sessionsConfigHelp = [
 
 // src/commands/sessions/summarise/index.ts
 import * as fs41 from "fs";
-import chalk205 from "chalk";
+import chalk207 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs40 from "fs";
@@ -29706,22 +29824,22 @@ ${firstMessage}`);
 async function summarise2(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk205.yellow("No sessions found."));
+    console.log(chalk207.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk205.green("All sessions already summarised."));
+    console.log(chalk207.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk205.cyan(
+    chalk207.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk205.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk205.yellow(`, ${failed2} skipped`) : "")
+    chalk207.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk207.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -29741,16 +29859,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk205.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk207.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk205.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk207.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk205.yellow("skip")}
+      process.stdout.write(` ${chalk207.yellow("skip")}
 `);
     }
   }
@@ -29771,7 +29889,7 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk207 from "chalk";
+import chalk209 from "chalk";
 
 // src/shared/contextLevel.ts
 function contextLevel(pct) {
@@ -29781,7 +29899,7 @@ function contextLevel(pct) {
 }
 
 // src/commands/buildLimitsSegment.ts
-import chalk206 from "chalk";
+import chalk208 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -29812,9 +29930,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk206.green,
-  warn: chalk206.yellow,
-  over: chalk206.red
+  ok: chalk208.green,
+  warn: chalk208.yellow,
+  over: chalk208.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -29845,7 +29963,7 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync52, statSync as statSync12 } from "fs";
+import { readFileSync as readFileSync53, statSync as statSync12 } from "fs";
 import { isAbsolute as isAbsolute3, join as join73, resolve as resolve18 } from "path";
 function resolveGitDir(cwd) {
   const dotGit = join73(cwd, ".git");
@@ -29860,7 +29978,7 @@ function resolveGitDir(cwd) {
   }
   let contents;
   try {
-    contents = readFileSync52(dotGit, "utf8");
+    contents = readFileSync53(dotGit, "utf8");
   } catch {
     return null;
   }
@@ -29878,7 +29996,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync52(join73(gitDir, "HEAD"), "utf8");
+    head = readFileSync53(join73(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -29910,7 +30028,7 @@ async function relayUsage(claudeSessionId, transcriptPath, usedPct) {
 }
 
 // src/commands/statusLine.ts
-chalk207.level = 3;
+chalk209.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
@@ -29918,9 +30036,9 @@ function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
   switch (contextLevel(pct)) {
     case "red":
-      return chalk207.red(label2);
+      return chalk209.red(label2);
     case "yellow":
-      return chalk207.yellow(label2);
+      return chalk209.yellow(label2);
     default:
       return label2;
   }
@@ -29933,7 +30051,7 @@ async function statusLine() {
   const usedPct = data.context_window.used_percentage ?? 0;
   const dir = data.workspace?.current_dir ?? data.cwd;
   const branch2 = dir ? readGitBranch(toGitCwd(dir)) : null;
-  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk207.cyan(branch2)} | ` : "";
+  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk209.cyan(branch2)} | ` : "";
   console.log(
     `${branchSegment}${model} | Tokens - ${formatNumber(totalIn)} \u2191 : ${formatNumber(totalOut)} \u2193 | Context - ${colorizePercent(usedPct)}${buildLimitsSegment(data.rate_limits)}`
   );
@@ -29954,14 +30072,14 @@ import { fileURLToPath as fileURLToPath9 } from "url";
 // src/commands/sync/syncClaudeMd.ts
 import * as fs42 from "fs";
 import * as path61 from "path";
-import chalk209 from "chalk";
+import chalk211 from "chalk";
 
 // src/commands/sync/printAutoConfirmHint.ts
-import chalk208 from "chalk";
+import chalk210 from "chalk";
 var autoConfirmHintCommand = "assist config set sync.autoConfirm true --global";
 function printAutoConfirmHint() {
   console.log(
-    chalk208.dim(
+    chalk210.dim(
       `Tip: run \`${autoConfirmHintCommand}\` to overwrite automatically next time`
     )
   );
@@ -29977,14 +30095,14 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
     const targetContent = fs42.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk209.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk211.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       if (!options2?.yes) {
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk209.red("Overwrite existing CLAUDE.md?"),
+          chalk211.red("Overwrite existing CLAUDE.md?"),
           false
         );
         if (!confirm) {
@@ -30179,7 +30297,7 @@ function syncPi(claudeDir) {
 // src/commands/sync/syncSettings.ts
 import * as fs47 from "fs";
 import * as path68 from "path";
-import chalk210 from "chalk";
+import chalk212 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path68.join(claudeDir, "settings.json");
   const target = path68.join(targetBase, "settings.json");
@@ -30198,7 +30316,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk210.yellow(
+          chalk212.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
@@ -30206,7 +30324,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
         printDiff(targetContent, mergedContent);
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk210.red("Overwrite existing settings.json?"),
+          chalk212.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -30305,10 +30423,10 @@ async function update2() {
 }
 
 // src/reportCliError.ts
-import chalk211 from "chalk";
+import chalk213 from "chalk";
 function reportCliError(error) {
   if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError) {
-    console.error(chalk211.red(error.message));
+    console.error(chalk213.red(error.message));
   } else {
     console.error(error);
   }