@staff0rd/assist 0.579.0 → 0.581.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.579.0",
+  version: "0.581.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -3847,9 +3847,9 @@ function extractCsharpComments(content) {
 
 // src/commands/verify/blockCodeComments/collectCsharpComments.ts
 function collectCsharpComments(content) {
-  const headerLines = csharpHeaderLineCount(content);
+  const headerLines2 = csharpHeaderLineCount(content);
   return extractCsharpComments(content).filter(
-    (comment3) => comment3.line > headerLines
+    (comment3) => comment3.line > headerLines2
   );
 }
 
@@ -3883,7 +3883,7 @@ function collectHashComments(content, options2) {
 function collectComments(sourceFile) {
   const seen = /* @__PURE__ */ new Set();
   const comments3 = [];
-  const collect6 = (node) => {
+  const collect7 = (node) => {
     for (const range of [
       ...node.getLeadingCommentRanges(),
       ...node.getTrailingCommentRanges()
@@ -3894,8 +3894,8 @@ function collectComments(sourceFile) {
       comments3.push({ pos, text: range.getText() });
     }
   };
-  collect6(sourceFile);
-  sourceFile.forEachDescendant(collect6);
+  collect7(sourceFile);
+  sourceFile.forEachDescendant(collect7);
   return comments3;
 }
 
@@ -11939,7 +11939,7 @@ import { execFile as execFile5 } from "child_process";
 import { promisify as promisify5 } from "util";
 var execFileAsync4 = promisify5(execFile5);
 var CACHE_TTL_MS4 = 3e4;
-function createCachedGhJson(args, parse3, fallback, options2 = {}) {
+function createCachedGhJson(args, parse4, fallback, options2 = {}) {
   const { cacheFallback = true } = options2;
   const cache5 = /* @__PURE__ */ new Map();
   return async (cwd, extraArgs = []) => {
@@ -11954,7 +11954,7 @@ function createCachedGhJson(args, parse3, fallback, options2 = {}) {
         windowsHide: true,
         cwd: toGitCwd(cwd)
       });
-      value = parse3(stdout);
+      value = parse4(stdout);
     } catch {
       value = fallback;
     }
@@ -21042,6 +21042,38 @@ function applyAndVerifySubtree(target, plan2, context) {
   writeLineNow(chalk163.green("Subtree normalised"));
 }
 
+// src/commands/github/issue/fixStructure/assertChainTypesExist.ts
+function assertChainTypesExist(chain2, issueTypes) {
+  const missing = chain2.filter(
+    (level) => !issueTypes.some(
+      (type) => normaliseTypeName(type.name) === normaliseTypeName(level)
+    )
+  );
+  if (missing.length === 0) return;
+  throw new Error(
+    `The organisation has no ${missing.join(", ")} issue type${missing.length === 1 ? "" : "s"}. It has ${issueTypes.map((type) => type.name).join(", ")}`
+  );
+}
+
+// src/commands/github/issue/fixStructure/parseTypeChain.ts
+function parseTypeChain(value) {
+  const chain2 = value.split(/[,>]/).map((name) => name.trim()).filter((name) => name.length > 0);
+  if (chain2.length < 2) {
+    throw new Error(
+      `--type-chain needs at least two levels, like Epic,Story,Subtask, not "${value}"`
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const level of chain2) {
+    const key = normaliseTypeName(level);
+    if (seen.has(key)) {
+      throw new Error(`--type-chain repeats ${level}; each level must differ`);
+    }
+    seen.add(key);
+  }
+  return chain2;
+}
+
 // src/commands/github/issue/fixStructure/printFixStructurePlan.ts
 import chalk164 from "chalk";
 function annotate(entry) {
@@ -21175,9 +21207,11 @@ var defaultTypeChain = ["Epic", "Story", "Subtask"];
 
 // src/commands/github/issue/fixStructure/fixStructure.ts
 function fixStructure(target, options2) {
-  const chain2 = defaultTypeChain;
   try {
+    const chain2 = options2.typeChain ? parseTypeChain(options2.typeChain) : defaultTypeChain;
     const resolved = resolveFixStructureTarget(target, options2.repo);
+    const issueTypes = resolveOrgIssueTypes(resolved.owner);
+    assertChainTypesExist(chain2, issueTypes);
     const root = fetchRootIssue(resolved);
     const { index: index3, asserted } = resolveRootLevelIndex(
       chain2,
@@ -21188,8 +21222,8 @@ function fixStructure(target, options2) {
       chain: chain2,
       rootLevelIndex: index3,
       rootAsserted: asserted,
-      issueTypes: resolveOrgIssueTypes(resolved.owner),
-      stripLabels: []
+      issueTypes,
+      stripLabels: options2.stripLabel ?? []
     };
     const plan2 = planSubtree(root, context);
     printFixStructurePlan(plan2, chain2, options2.apply === true);
@@ -21204,18 +21238,31 @@ function fixStructure(target, options2) {
 // src/commands/github/issue/fixStructure/registerFixStructure.ts
 var chain = defaultTypeChain.join(" > ");
 var levels = defaultTypeChain.map((name) => name.toLowerCase()).join("|");
+function collect4(value, previous) {
+  return previous.concat([value]);
+}
 function registerFixStructure(issueCommand) {
   issueCommand.command("fix-structure <target>").description("Normalise the issue types across one issue subtree").option(
     "-R, --repo <owner/repo>",
     "Repository a bare issue number belongs to"
   ).option(
     "--level <level>",
-    `The target's own position in the ${chain} chain, when it cannot be inferred from its type`
+    "The target's own position in the type chain, when it cannot be inferred from its type"
+  ).option(
+    "--type-chain <names>",
+    `Comma-separated issue type chain, parent level first (default: ${defaultTypeChain.join(",")})`
+  ).option(
+    "--strip-label <label>",
+    "Legacy marker label to remove from every issue in the subtree that carries it (repeatable)",
+    collect4,
+    []
   ).option("--apply", "Write the planned changes instead of reporting them").addHelpText(
     "after",
     `
-Walks the subtree reachable from <target> via sub-issues and reports the type each issue should carry: every level below the target is typed to the next level down the ${chain} chain. Nothing outside the subtree is ever read or written.
-The target's own level is inferred from its issue type, so aiming at a story types its children as subtasks. When the target's type is not in the chain the level cannot be inferred, and --level ${levels} asserts it instead \u2014 which also plans the target's own type.
+Walks the subtree reachable from <target> via sub-issues and reports the type each issue should carry: every level below the target is typed to the next level down the chain. Nothing outside the subtree is ever read or written.
+The chain defaults to ${chain} and --type-chain replaces it, so a backlog on other type names is normalised the same way; every level named must already exist as an issue type on the organisation, or the run fails listing the ones that do.
+The target's own level is inferred from its issue type, so aiming at a story types its children as subtasks. When the target's type is not in the chain the level cannot be inferred, and --level ${levels} (or whichever levels --type-chain names) asserts it instead \u2014 which also plans the target's own type.
+No label is touched unless --strip-label names it; each one is repeatable, matched case-insensitively, and removed by the label id found on that issue, since label ids differ per repository.
 The target is owner/repo#number, a github.com issue URL, or a bare number with --repo.
 Without --apply nothing is written. With --apply each write is announced before it is issued, and the subtree is re-walked afterwards so any residual drift fails the run.
 Anything nested below the leaf level fails the run before a single write, naming the offender and its parent.`
@@ -22871,7 +22918,8 @@ function registerMermaid(program2) {
 }
 
 // src/commands/miro/runExtract.ts
-import { stringify } from "yaml";
+import chalk171 from "chalk";
+import { stringify as stringify2 } from "yaml";
 
 // src/commands/miro/MiroExtractError.ts
 var MiroExtractError = class extends Error {
@@ -22881,6 +22929,52 @@ var MiroExtractError = class extends Error {
   }
 };
 
+// src/commands/miro/parseAnchorId.ts
+function parseAnchorId(value) {
+  const trimmed = value.trim();
+  const link3 = /[?&]moveToWidget=([^&#]+)/.exec(trimmed);
+  return link3 ? decodeURIComponent(link3[1]).trim() : trimmed;
+}
+
+// src/commands/miro/anchorSource.ts
+function anchorSource(options2) {
+  if (options2.topLeft && options2.bottomRight)
+    return {
+      pick: false,
+      topLeft: parseAnchorId(options2.topLeft),
+      bottomRight: parseAnchorId(options2.bottomRight)
+    };
+  const sessionId = process.env.ASSIST_SESSION_ID;
+  if (process.env.ASSIST_SESSION !== "1" || !sessionId)
+    throw new MiroExtractError(
+      "Both --top-left <id|link> and --bottom-right <id|link> are required: there is no assist session to host the picker pane."
+    );
+  return { pick: true, sessionId };
+}
+
+// src/commands/miro/applyIgnore.ts
+function applyIgnore(texts, ignore3) {
+  const dropped = new Set(ignore3);
+  const present = new Set(texts);
+  return {
+    texts: texts.filter((text18) => !dropped.has(text18)),
+    unmatched: [...new Set(ignore3)].filter((entry) => !present.has(entry))
+  };
+}
+
+// src/commands/miro/miroSource.ts
+function boardId(url) {
+  return url ? /\/board\/([^/?]+)/.exec(url)?.[1] : void 0;
+}
+function miroSource(items2, anchorId) {
+  const anchor = items2.find((item) => item.id === anchorId);
+  const ordered = anchor ? [anchor, ...items2] : items2;
+  return {
+    board: boardId(ordered.find((item) => item.miro_url)?.miro_url),
+    frame: ordered.find((item) => item.parent?.id)?.parent?.id
+  };
+}
+
 // src/commands/miro/stripHtml.ts
 var namedEntities = {
   amp: "&",
@@ -22939,13 +23033,6 @@ function normaliseItems(items2) {
   return items2.map(toItem);
 }
 
-// src/commands/miro/parseAnchorId.ts
-function parseAnchorId(value) {
-  const trimmed = value.trim();
-  const link3 = /[?&]moveToWidget=([^&#]+)/.exec(trimmed);
-  return link3 ? decodeURIComponent(link3[1]).trim() : trimmed;
-}
-
 // src/commands/miro/pickAnchors.ts
 import { randomUUID as randomUUID12 } from "crypto";
 
@@ -22985,8 +23072,25 @@ async function pickAnchors(sessionId, items2) {
   return [selection.topLeft, selection.bottomRight];
 }
 
+// src/commands/miro/readIgnoreList.ts
+import { existsSync as existsSync54, readFileSync as readFileSync40 } from "fs";
+import { parse as parse2 } from "yaml";
+function readIgnoreList(file) {
+  if (!existsSync54(file))
+    throw new MiroExtractError(
+      `No ignore file at ${file}. Write a YAML list of the box texts to drop, or omit --ignore.`
+    );
+  const parsed = parse2(readFileSync40(file, "utf8"));
+  if (parsed === null || parsed === void 0) return [];
+  if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string"))
+    throw new MiroExtractError(
+      `${file} must be a YAML list of box texts to drop, one string per entry.`
+    );
+  return parsed.map((entry) => entry.trim()).filter(Boolean);
+}
+
 // src/commands/miro/readMiroItems.ts
-import { readFileSync as readFileSync40 } from "fs";
+import { readFileSync as readFileSync41 } from "fs";
 function tryParse(text18) {
   try {
     return JSON.parse(text18);
@@ -23015,7 +23119,7 @@ function parsePages(raw, file) {
   return Array.isArray(parsed) ? parsed.map(toPage) : [toPage(parsed)];
 }
 function readMiroItems(file) {
-  const items2 = parsePages(readFileSync40(file, "utf8"), file).flatMap(
+  const items2 = parsePages(readFileSync41(file, "utf8"), file).flatMap(
     (page) => page.data ?? []
   );
   if (items2.length === 0)
@@ -23048,7 +23152,33 @@ function selectBoxes(items2, topLeftId, bottomRightId) {
     right: bottomRight.right,
     bottom: bottomRight.bottom
   };
-  return items2.filter((item) => isBox(item) && centreInside(rect, item)).sort((a, b) => a.left - b.left || a.top - b.top);
+  const boxes = items2.filter((item) => isBox(item) && centreInside(rect, item)).sort((a, b) => a.left - b.left || a.top - b.top);
+  return { rect, boxes };
+}
+
+// src/commands/miro/uniqueTexts.ts
+function uniqueTexts(boxes) {
+  return [...new Set(boxes.map((box) => box.text))];
+}
+
+// src/commands/miro/writeExtract.ts
+import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync33 } from "fs";
+import { dirname as dirname27 } from "path";
+import { stringify } from "yaml";
+function headerLines(header) {
+  const { rect } = header;
+  return [
+    `# board: ${header.board ?? "unknown"}`,
+    `# frame: ${header.frame ?? "unknown"}`,
+    `# top-left: ${header.topLeft}`,
+    `# bottom-right: ${header.bottomRight}`,
+    `# rectangle: ${rect.left},${rect.top} to ${rect.right},${rect.bottom}`
+  ];
+}
+function writeExtract(file, header, texts) {
+  mkdirSync19(dirname27(file), { recursive: true });
+  writeFileSync33(file, `${headerLines(header).join("\n")}
+${stringify(texts)}`);
 }
 
 // src/commands/miro/runExtract.ts
@@ -23059,26 +23189,37 @@ function requireItems(file) {
     );
   return file;
 }
-function anchorSource(options2) {
-  if (options2.topLeft && options2.bottomRight)
-    return {
-      pick: false,
-      topLeft: parseAnchorId(options2.topLeft),
-      bottomRight: parseAnchorId(options2.bottomRight)
-    };
-  const sessionId = process.env.ASSIST_SESSION_ID;
-  if (process.env.ASSIST_SESSION !== "1" || !sessionId)
-    throw new MiroExtractError(
-      "Both --top-left <id|link> and --bottom-right <id|link> are required: there is no assist session to host the picker pane."
-    );
-  return { pick: true, sessionId };
+function warnUnmatched(file, unmatched) {
+  if (unmatched.length === 0) return;
+  const entries = unmatched.map((entry) => `  - ${entry}`).join("\n");
+  console.error(
+    chalk171.yellow(
+      `${unmatched.length} ${unmatched.length === 1 ? "entry" : "entries"} in ${file} matched no box text:
+${entries}`
+    )
+  );
 }
 async function runExtract(options2) {
   const source = anchorSource(options2);
-  const items2 = normaliseItems(readMiroItems(requireItems(options2.items)));
+  const raw = readMiroItems(requireItems(options2.items));
+  const items2 = normaliseItems(raw);
   const [topLeft, bottomRight] = source.pick ? await pickAnchors(source.sessionId, items2) : [source.topLeft, source.bottomRight];
-  const boxes = selectBoxes(items2, topLeft, bottomRight);
-  process.stdout.write(stringify(boxes.map((box) => box.text)));
+  const selection = selectBoxes(items2, topLeft, bottomRight);
+  const ignore3 = options2.ignore ? readIgnoreList(options2.ignore) : [];
+  const kept = applyIgnore(uniqueTexts(selection.boxes), ignore3);
+  if (options2.ignore) warnUnmatched(options2.ignore, kept.unmatched);
+  if (!options2.out) {
+    process.stdout.write(stringify2(kept.texts));
+    return;
+  }
+  writeExtract(
+    options2.out,
+    { ...miroSource(raw, topLeft), topLeft, bottomRight, rect: selection.rect },
+    kept.texts
+  );
+  console.log(
+    `Wrote ${kept.texts.length} ${kept.texts.length === 1 ? "box" : "boxes"} to ${options2.out}`
+  );
 }
 
 // src/commands/miro/registerMiro.ts
@@ -23090,14 +23231,14 @@ function registerMiro(program2) {
   ).option(
     "--bottom-right <id>",
     "Widget id or ?moveToWidget=<id> link of the bottom-right box"
-  ).action(runExtract);
+  ).option("--ignore <file>", "YAML list of box texts to drop from the output").option("--out <file>", "Write the YAML to this file instead of stdout").action(runExtract);
 }
 
 // src/commands/netcap/netcap.ts
 import { mkdir as mkdir4 } from "fs/promises";
 import { createServer as createServer2 } from "http";
-import { dirname as dirname28 } from "path";
-import chalk172 from "chalk";
+import { dirname as dirname29 } from "path";
+import chalk173 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
 var corsHeaders = {
@@ -23176,12 +23317,12 @@ function createNetcapHandler(options2) {
 import { cp, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { networkInterfaces } from "os";
 import { join as join58 } from "path";
-import chalk171 from "chalk";
+import chalk172 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname27, join as join57 } from "path";
+import { dirname as dirname28, join as join57 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
-var moduleDir = dirname27(fileURLToPath6(import.meta.url));
+var moduleDir = dirname28(fileURLToPath6(import.meta.url));
 function netcapExtensionDir() {
   return join57(moduleDir, "commands", "netcap", "netcap-extension");
 }
@@ -23220,7 +23361,7 @@ async function prepareExtensionForLoad(port, filter = "") {
   const host = lanIPv4();
   if (!host) {
     console.log(
-      chalk171.yellow("could not determine the WSL IP for the extension")
+      chalk172.yellow("could not determine the WSL IP for the extension")
     );
     await configureBackground(source, "127.0.0.1", port, filter);
     return source;
@@ -23231,7 +23372,7 @@ async function prepareExtensionForLoad(port, filter = "") {
     return WSL_WINDOWS_PATH;
   } catch {
     console.log(
-      chalk171.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
+      chalk172.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
     );
     return source;
   }
@@ -23259,35 +23400,35 @@ async function netcap(options2) {
   const port = Number(options2.port);
   const outPath = resolveNetcapOutPath(options2.out);
   const filter = options2.filter ?? "";
-  await mkdir4(dirname28(outPath), { recursive: true });
+  await mkdir4(dirname29(outPath), { recursive: true });
   const extensionPath = await prepareExtensionForLoad(port, filter);
   let count8 = 0;
   const handler = createNetcapHandler({
     outPath,
-    onPing: () => console.log(chalk172.dim("ping from extension")),
+    onPing: () => console.log(chalk173.dim("ping from extension")),
     onCapture: (entry) => {
       count8 += 1;
       console.log(
-        chalk172.green(`captured #${count8}`),
-        chalk172.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
+        chalk173.green(`captured #${count8}`),
+        chalk173.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
       );
     }
   });
   const server = createServer2(handler);
   server.listen(port, () => {
     console.log(
-      chalk172.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
+      chalk173.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
     );
-    console.log(chalk172.dim(`appending captures to ${outPath}`));
+    console.log(chalk173.dim(`appending captures to ${outPath}`));
     if (filter)
-      console.log(chalk172.dim(`forwarding only URLs matching "${filter}"`));
-    console.log(chalk172.dim(`load the unpacked extension from ${extensionPath}`));
-    console.log(chalk172.dim("press Ctrl-C to stop"));
+      console.log(chalk173.dim(`forwarding only URLs matching "${filter}"`));
+    console.log(chalk173.dim(`load the unpacked extension from ${extensionPath}`));
+    console.log(chalk173.dim("press Ctrl-C to stop"));
   });
   process.on("SIGINT", () => {
     server.close();
     console.log(
-      chalk172.bold(
+      chalk173.bold(
         `
 netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} to ${outPath}`
       )
@@ -23297,12 +23438,12 @@ netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} t
 }
 
 // src/commands/netcap/netcapExtract.ts
-import { writeFileSync as writeFileSync33 } from "fs";
+import { writeFileSync as writeFileSync34 } from "fs";
 import { join as join61 } from "path";
-import chalk173 from "chalk";
+import chalk174 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
-import { readFileSync as readFileSync41 } from "fs";
+import { readFileSync as readFileSync42 } from "fs";
 
 // src/commands/netcap/parseRscRows.ts
 var isRscRef = (v) => typeof v === "string" && /^\$[0-9a-fL@]/.test(v);
@@ -23698,7 +23839,7 @@ function extractVoyagerPosts(body) {
 
 // src/commands/netcap/extractPostsFromCapture.ts
 function captureEntries(captureFile) {
-  const lines2 = readFileSync41(captureFile, "utf8").split("\n").filter(Boolean);
+  const lines2 = readFileSync42(captureFile, "utf8").split("\n").filter(Boolean);
   const entries = [];
   for (const line of lines2) {
     let entry;
@@ -23744,11 +23885,11 @@ function netcapExtract(file) {
   const captureFile = file ?? defaultCapturePath();
   const posts = extractPostsFromCapture(captureFile);
   const outFile = join61(captureFile, "..", "posts.json");
-  writeFileSync33(outFile, `${JSON.stringify(posts, null, 2)}
+  writeFileSync34(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
-    chalk173.green(`extracted ${posts.length} posts`),
-    chalk173.dim(`-> ${outFile}`)
+    chalk174.green(`extracted ${posts.length} posts`),
+    chalk174.dim(`-> ${outFile}`)
   );
 }
 
@@ -23769,7 +23910,7 @@ function registerNetcap(program2) {
 }
 
 // src/commands/news/add/index.ts
-import chalk174 from "chalk";
+import chalk175 from "chalk";
 import enquirer8 from "enquirer";
 async function add2(url) {
   if (!url) {
@@ -23791,10 +23932,10 @@ async function add2(url) {
   const { orm } = await getReady();
   const added = await addFeed(orm, url);
   if (!added) {
-    console.log(chalk174.yellow("Feed already exists"));
+    console.log(chalk175.yellow("Feed already exists"));
     return;
   }
-  console.log(chalk174.green(`Added feed: ${url}`));
+  console.log(chalk175.green(`Added feed: ${url}`));
 }
 
 // src/commands/registerNews.ts
@@ -23841,7 +23982,7 @@ function registerPiHook(program2) {
 }
 
 // src/commands/prompts/printPromptsTable.ts
-import chalk175 from "chalk";
+import chalk176 from "chalk";
 function truncate(str, max) {
   if (str.length <= max) return str;
   return `${str.slice(0, max - 1)}\u2026`;
@@ -23859,14 +24000,14 @@ function printPromptsTable(rows) {
     "Command".padEnd(commandWidth),
     "Repos"
   ].join("  ");
-  console.log(chalk175.dim(header));
-  console.log(chalk175.dim("-".repeat(header.length)));
+  console.log(chalk176.dim(header));
+  console.log(chalk176.dim("-".repeat(header.length)));
   for (const row of rows) {
     const count8 = String(row.count).padStart(countWidth);
     const tool = row.tool.padEnd(toolWidth);
     const command = truncate(row.command, 60).padEnd(commandWidth);
     console.log(
-      `${chalk175.yellow(count8)}  ${tool}  ${command}  ${chalk175.dim(row.repos)}`
+      `${chalk176.yellow(count8)}  ${tool}  ${command}  ${chalk176.dim(row.repos)}`
     );
   }
 }
@@ -24267,13 +24408,13 @@ import { execSync as execSync45 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
 import { execSync as execSync44 } from "child_process";
-import { unlinkSync as unlinkSync14, writeFileSync as writeFileSync34 } from "fs";
+import { unlinkSync as unlinkSync14, writeFileSync as writeFileSync35 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
 import { join as join63 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync54, readFileSync as readFileSync42, unlinkSync as unlinkSync13 } from "fs";
-import { parse as parse2 } from "yaml";
+import { existsSync as existsSync55, readFileSync as readFileSync43, unlinkSync as unlinkSync13 } from "fs";
+import { parse as parse3 } from "yaml";
 
 // src/commands/prs/commentsCachePath.ts
 import { homedir as homedir21 } from "os";
@@ -24292,15 +24433,15 @@ function commentsCachePath(org, repo, prNumber) {
 // src/commands/prs/loadCommentsCache.ts
 function loadCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (!existsSync54(cachePath)) {
+  if (!existsSync55(cachePath)) {
     return null;
   }
-  const content = readFileSync42(cachePath, "utf8");
-  return parse2(content);
+  const content = readFileSync43(cachePath, "utf8");
+  return parse3(content);
 }
 function deleteCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (existsSync54(cachePath)) {
+  if (existsSync55(cachePath)) {
     unlinkSync13(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
@@ -24329,7 +24470,7 @@ function replyToComment(org, repo, prNumber, commentId, message3) {
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
   const queryFile = join63(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
-  writeFileSync34(queryFile, mutation);
+  writeFileSync35(queryFile, mutation);
   try {
     execSync44(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
@@ -24411,13 +24552,13 @@ function fixed(commentId, sha) {
 
 // src/commands/prs/fetchThreadIds.ts
 import { execSync as execSync46 } from "child_process";
-import { unlinkSync as unlinkSync15, writeFileSync as writeFileSync35 } from "fs";
+import { unlinkSync as unlinkSync15, writeFileSync as writeFileSync36 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
 import { join as join64 } from "path";
 var THREAD_QUERY = `query($owner: String!, $repo: String!, $prNumber: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $prNumber) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 100) { nodes { databaseId } } } } } } }`;
 function fetchThreadIds(org, repo, prNumber) {
   const queryFile = join64(tmpdir7(), `gh-query-${Date.now()}.graphql`);
-  writeFileSync35(queryFile, THREAD_QUERY);
+  writeFileSync36(queryFile, THREAD_QUERY);
   try {
     const result = execSync46(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
@@ -24485,9 +24626,9 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 }
 
 // src/commands/prs/listComments/updateCommentsCache.ts
-import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync36 } from "fs";
-import { dirname as dirname29 } from "path";
-import { stringify as stringify2 } from "yaml";
+import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync37 } from "fs";
+import { dirname as dirname30 } from "path";
+import { stringify as stringify3 } from "yaml";
 
 // src/commands/prs/removeStaleCommentsCaches.ts
 import { readdirSync as readdirSync12, unlinkSync as unlinkSync16 } from "fs";
@@ -24509,13 +24650,13 @@ function removeStaleCommentsCaches(cwd = process.cwd()) {
 // src/commands/prs/listComments/updateCommentsCache.ts
 function writeCommentsCache(org, repo, prNumber, comments3) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  mkdirSync19(dirname29(cachePath), { recursive: true });
+  mkdirSync20(dirname30(cachePath), { recursive: true });
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  writeFileSync36(cachePath, stringify2(cacheData));
+  writeFileSync37(cachePath, stringify3(cacheData));
 }
 function updateCommentsCache(org, repo, prNumber, comments3) {
   removeStaleCommentsCaches();
@@ -24533,13 +24674,13 @@ function agentFooter(unresolvedCount) {
 }
 
 // src/commands/prs/listComments/commentStyle.ts
-import chalk176 from "chalk";
+import chalk177 from "chalk";
 var plain = (text18) => text18;
 function colouredState(state) {
   const label2 = `[${state}]`;
-  if (state === "APPROVED") return chalk176.green(label2);
-  if (state === "CHANGES_REQUESTED") return chalk176.red(label2);
-  return chalk176.yellow(label2);
+  if (state === "APPROVED") return chalk177.green(label2);
+  if (state === "CHANGES_REQUESTED") return chalk177.red(label2);
+  return chalk177.yellow(label2);
 }
 function commentStyle() {
   if (isClaudeCode()) {
@@ -24553,9 +24694,9 @@ function commentStyle() {
     };
   }
   return {
-    cyan: chalk176.cyan,
-    bold: chalk176.bold,
-    dim: chalk176.dim,
+    cyan: chalk177.cyan,
+    bold: chalk177.bold,
+    dim: chalk177.dim,
     state: colouredState,
     diffHunk: true,
     agent: false
@@ -24725,13 +24866,13 @@ import { execSync as execSync48 } from "child_process";
 import enquirer9 from "enquirer";
 
 // src/commands/prs/prs/displayPaginated/printPr.ts
-import chalk177 from "chalk";
+import chalk178 from "chalk";
 var STATUS_MAP = {
-  MERGED: (pr) => pr.mergedAt ? { label: chalk177.magenta("merged"), date: pr.mergedAt } : null,
-  CLOSED: (pr) => pr.closedAt ? { label: chalk177.red("closed"), date: pr.closedAt } : null
+  MERGED: (pr) => pr.mergedAt ? { label: chalk178.magenta("merged"), date: pr.mergedAt } : null,
+  CLOSED: (pr) => pr.closedAt ? { label: chalk178.red("closed"), date: pr.closedAt } : null
 };
 function defaultStatus(pr) {
-  return { label: chalk177.green("opened"), date: pr.createdAt };
+  return { label: chalk178.green("opened"), date: pr.createdAt };
 }
 function getStatus2(pr) {
   return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -24740,11 +24881,11 @@ function formatDate(dateStr) {
   return new Date(dateStr).toISOString().split("T")[0];
 }
 function formatPrHeader(pr, status3) {
-  return `${chalk177.cyan(`#${pr.number}`)} ${pr.title} ${chalk177.dim(`(${pr.author.login},`)} ${status3.label} ${chalk177.dim(`${formatDate(status3.date)})`)}`;
+  return `${chalk178.cyan(`#${pr.number}`)} ${pr.title} ${chalk178.dim(`(${pr.author.login},`)} ${status3.label} ${chalk178.dim(`${formatDate(status3.date)})`)}`;
 }
 function logPrDetails(pr) {
   console.log(
-    chalk177.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
+    chalk178.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
   console.log();
 }
@@ -25309,7 +25450,7 @@ ${prConcisenessGuidance}
 }
 
 // src/commands/registerPrsEdit.ts
-function collect4(value, previous) {
+function collect5(value, previous) {
   return previous.concat([value]);
 }
 function registerPrsEdit(prsCommand) {
@@ -25318,7 +25459,7 @@ function registerPrsEdit(prsCommand) {
   ).option("-t, --title <title>", "New title for the pull request").option("--what <what>", "Replace the ## What section").option("--why <why>", "Replace the ## Why section").option("--how <how>", "Replace the ## How section").option(
     "--resolves <key>",
     "Jira issue key resolved by this PR, appended to ## Why (repeatable)",
-    collect4,
+    collect5,
     []
   ).addHelpText("after", () => editHelpText()).action(edit);
 }
@@ -25418,7 +25559,7 @@ ${confirm}
 }
 
 // src/commands/registerPrsRaise.ts
-function collect5(value, previous) {
+function collect6(value, previous) {
   return previous.concat([value]);
 }
 function registerPrsRaise(prsCommand) {
@@ -25427,7 +25568,7 @@ function registerPrsRaise(prsCommand) {
   ).option("-t, --title <title>", "Title for the pull request").option("--what <what>", "What the change does (## What section)").option("--why <why>", "Why the change is needed (## Why section)").option("--how <how>", "How the change works (optional ## How section)").option(
     "--resolves <key>",
     "Jira issue key resolved by this PR, appended to ## Why (repeatable)",
-    collect5,
+    collect6,
     []
   ).option(
     "--force",
@@ -25435,15 +25576,15 @@ function registerPrsRaise(prsCommand) {
   ).option("-B, --base <branch>", "Branch into which the pull request merges").option("-H, --head <branch>", "Branch that contains the commits").option("-d, --draft", "Mark the pull request as a draft").option(
     "--no-draft",
     "Create a ready-for-review pull request, overriding prs.draft"
-  ).option("-w, --web", "Open the browser to create the pull request").option("-l, --label <label>", "Add a label (repeatable)", collect5, []).option(
+  ).option("-w, --web", "Open the browser to create the pull request").option("-l, --label <label>", "Add a label (repeatable)", collect6, []).option(
     "-a, --assignee <login>",
     "Assign a person by login (repeatable)",
-    collect5,
+    collect6,
     []
   ).option(
     "-r, --reviewer <handle>",
     "Request a review (repeatable)",
-    collect5,
+    collect6,
     []
   ).option("-m, --milestone <name>", "Add the pull request to a milestone").addHelpText("after", () => raiseHelpText()).action(raise);
   configHelp(raiseCommand, prsRaiseConfigHelp);
@@ -25459,10 +25600,10 @@ function registerPrs(program2) {
 }
 
 // src/commands/ravendb/ravendbAuth.ts
-import chalk183 from "chalk";
+import chalk184 from "chalk";
 
 // src/shared/createConnectionAuth.ts
-import chalk178 from "chalk";
+import chalk179 from "chalk";
 function listConnections(connections, format) {
   if (connections.length === 0) {
     console.log("No connections configured.");
@@ -25475,7 +25616,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(chalk178.red(`Connection "${name}" not found.`));
+    console.error(chalk179.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   save(filtered);
@@ -25521,15 +25662,15 @@ function saveConnections(connections) {
 }
 
 // src/commands/ravendb/promptConnection.ts
-import chalk181 from "chalk";
+import chalk182 from "chalk";
 
 // src/commands/ravendb/selectOpSecret.ts
-import chalk180 from "chalk";
+import chalk181 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
 import { execSync as execSync51 } from "child_process";
-import chalk179 from "chalk";
+import chalk180 from "chalk";
 function opExec(args) {
   return execSync51(`op ${args}`, {
     encoding: "utf8",
@@ -25542,7 +25683,7 @@ function searchItems(search2) {
     items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
-      chalk179.red(
+      chalk180.red(
         "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
       )
     );
@@ -25556,7 +25697,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(chalk179.red("Failed to get item details from 1Password."));
+    console.error(chalk180.red("Failed to get item details from 1Password."));
     process.exit(1);
   }
 }
@@ -25575,7 +25716,7 @@ async function selectOpSecret(searchTerm) {
   }).run();
   const items2 = searchItems(search2);
   if (items2.length === 0) {
-    console.error(chalk180.red(`No items found matching "${search2}".`));
+    console.error(chalk181.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId2 = await selectOne(
@@ -25584,7 +25725,7 @@ async function selectOpSecret(searchTerm) {
   );
   const fields = getItemFields(itemId2);
   if (fields.length === 0) {
-    console.error(chalk180.red("No fields with references found on this item."));
+    console.error(chalk181.red("No fields with references found on this item."));
     process.exit(1);
   }
   const ref = await selectOne(
@@ -25598,7 +25739,7 @@ async function selectOpSecret(searchTerm) {
 async function promptConnection(existingNames) {
   const name = await promptInput("name", "Connection name:");
   if (existingNames.includes(name)) {
-    console.error(chalk181.red(`Connection "${name}" already exists.`));
+    console.error(chalk182.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput(
@@ -25607,22 +25748,22 @@ async function promptConnection(existingNames) {
   );
   const database = await promptInput("database", "Database name:");
   if (!name || !url || !database) {
-    console.error(chalk181.red("All fields are required."));
+    console.error(chalk182.red("All fields are required."));
     process.exit(1);
   }
   const apiKeyRef = await selectOpSecret();
-  console.log(chalk181.dim(`Using: ${apiKeyRef}`));
+  console.log(chalk182.dim(`Using: ${apiKeyRef}`));
   return { name, url, database, apiKeyRef };
 }
 
 // src/commands/ravendb/ravendbSetConnection.ts
-import chalk182 from "chalk";
+import chalk183 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(chalk182.red(`Connection "${name}" not found.`));
+    console.error(chalk183.red(`Connection "${name}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -25638,16 +25779,16 @@ function ravendbSetConnection(name) {
 var ravendbAuth = createConnectionAuth({
   load: loadConnections,
   save: saveConnections,
-  format: (c) => `${chalk183.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
+  format: (c) => `${chalk184.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
   promptNew: promptConnection,
   onFirst: (c) => ravendbSetConnection(c.name)
 });
 
 // src/commands/ravendb/ravendbCollections.ts
-import chalk187 from "chalk";
+import chalk188 from "chalk";
 
 // src/commands/ravendb/ravenFetch.ts
-import chalk185 from "chalk";
+import chalk186 from "chalk";
 
 // src/commands/ravendb/getAccessToken.ts
 var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -25684,10 +25825,10 @@ ${errorText}`
 
 // src/commands/ravendb/resolveOpSecret.ts
 import { execSync as execSync52 } from "child_process";
-import chalk184 from "chalk";
+import chalk185 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
-    console.error(chalk184.red(`Invalid secret reference: must start with op://`));
+    console.error(chalk185.red(`Invalid secret reference: must start with op://`));
     process.exit(1);
   }
   try {
@@ -25697,7 +25838,7 @@ function resolveOpSecret(reference) {
     }).trim();
   } catch {
     console.error(
-      chalk184.red(
+      chalk185.red(
         "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
       )
     );
@@ -25724,7 +25865,7 @@ async function ravenFetch(connection, path80) {
   if (!response.ok) {
     const body = await response.text();
     console.error(
-      chalk185.red(`RavenDB error: ${response.status} ${response.statusText}`)
+      chalk186.red(`RavenDB error: ${response.status} ${response.statusText}`)
     );
     console.error(body.substring(0, 500));
     process.exit(1);
@@ -25733,7 +25874,7 @@ async function ravenFetch(connection, path80) {
 }
 
 // src/commands/ravendb/resolveConnection.ts
-import chalk186 from "chalk";
+import chalk187 from "chalk";
 function loadRavendb() {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb;
@@ -25747,7 +25888,7 @@ function resolveConnection(name) {
   const connectionName = name ?? defaultConnection;
   if (!connectionName) {
     console.error(
-      chalk186.red(
+      chalk187.red(
         "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
       )
     );
@@ -25755,7 +25896,7 @@ function resolveConnection(name) {
   }
   const connection = connections.find((c) => c.name === connectionName);
   if (!connection) {
-    console.error(chalk186.red(`Connection "${connectionName}" not found.`));
+    console.error(chalk187.red(`Connection "${connectionName}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -25786,15 +25927,15 @@ async function ravendbCollections(connectionName) {
     return;
   }
   for (const c of collections) {
-    console.log(`${chalk187.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+    console.log(`${chalk188.bold(c.Name)}  ${c.CountOfDocuments} docs`);
   }
 }
 
 // src/commands/ravendb/ravendbQuery.ts
-import chalk189 from "chalk";
+import chalk190 from "chalk";
 
 // src/commands/ravendb/fetchAllPages.ts
-import chalk188 from "chalk";
+import chalk189 from "chalk";
 
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
@@ -25832,7 +25973,7 @@ async function fetchAllPages(connection, opts) {
     allResults.push(...results);
     start3 += results.length;
     process.stderr.write(
-      `\r${chalk188.dim(`Fetched ${allResults.length}/${totalResults}`)}`
+      `\r${chalk189.dim(`Fetched ${allResults.length}/${totalResults}`)}`
     );
     if (start3 >= totalResults) break;
     if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
@@ -25847,7 +25988,7 @@ async function fetchAllPages(connection, opts) {
 async function ravendbQuery(connectionName, collection, options2) {
   const resolved = resolveArgs(connectionName, collection);
   if (!resolved.collection && !options2.query) {
-    console.error(chalk189.red("Provide a collection name or --query filter."));
+    console.error(chalk190.red("Provide a collection name or --query filter."));
     process.exit(1);
   }
   const { collection: col } = resolved;
@@ -25886,7 +26027,7 @@ import { spawn as spawn6 } from "child_process";
 import * as path42 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk190 from "chalk";
+import chalk191 from "chalk";
 var DEFAULT_MAX_LINES2 = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
   if (violations.length === 0) {
@@ -25895,43 +26036,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
     }
     return;
   }
-  console.error(chalk190.red(`
+  console.error(chalk191.red(`
 Refactor check failed:
 `));
-  console.error(chalk190.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk191.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk190.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk191.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk190.yellow(
+    chalk191.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk190.gray(`    assist refactor ignore <file>
+  console.error(chalk191.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk190.cyan(`
+    console.error(chalk191.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk190.cyan(
+      chalk191.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk190.cyan(
+      chalk191.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(
-      chalk190.cyan(
+      chalk191.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -26087,7 +26228,7 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/extract/index.ts
 import path50 from "path";
-import chalk193 from "chalk";
+import chalk194 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
@@ -26686,23 +26827,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 
 // src/commands/refactor/extract/displayPlan.ts
 import path46 from "path";
-import chalk191 from "chalk";
+import chalk192 from "chalk";
 function section2(title) {
   return `
-  ${chalk191.cyan(title)}`;
+  ${chalk192.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 = path46.relative(cwd, imp.file.getFilePath());
-    console.log(`    ${chalk191.dim(rel)}: \u2192 import from "${imp.relPath}"`);
+    console.log(`    ${chalk192.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
 function displayPlan(functionName, relDest, plan2, cwd) {
-  console.log(chalk191.bold(`Extract: ${functionName} \u2192 ${relDest}
+  console.log(chalk192.bold(`Extract: ${functionName} \u2192 ${relDest}
 `));
-  console.log(`  ${chalk191.cyan("Functions to move:")}`);
+  console.log(`  ${chalk192.cyan("Functions to move:")}`);
   for (const name of plan2.extractedNames) {
     console.log(`    ${name}`);
   }
@@ -26736,7 +26877,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import path49 from "path";
-import chalk192 from "chalk";
+import chalk193 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
@@ -26828,7 +26969,7 @@ function loadProjectFile(file) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk192.red(`File not found in project: ${file}`));
+    console.log(chalk193.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   return { project, sourceFile };
@@ -26851,19 +26992,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(chalk193.green("\nExtraction complete"));
+    console.log(chalk194.green("\nExtraction complete"));
   } else {
-    console.log(chalk193.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk194.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/ignore.ts
 import fs33 from "fs";
-import chalk194 from "chalk";
+import chalk195 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore2(file) {
   if (!fs33.existsSync(file)) {
-    console.error(chalk194.red(`Error: File does not exist: ${file}`));
+    console.error(chalk195.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs33.readFileSync(file, "utf8");
@@ -26879,7 +27020,7 @@ function ignore2(file) {
     fs33.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk194.green(
+    chalk195.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -26888,12 +27029,12 @@ function ignore2(file) {
 // src/commands/refactor/rename/index.ts
 import fs36 from "fs";
 import path55 from "path";
-import chalk197 from "chalk";
+import chalk198 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs35 from "fs";
 import path52 from "path";
-import chalk195 from "chalk";
+import chalk196 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
 import path51 from "path";
@@ -26998,13 +27139,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs35.writeFileSync(file, content, "utf8");
-    console.log(chalk195.cyan(`  Updated imports in ${path52.relative(cwd, file)}`));
+    console.log(chalk196.cyan(`  Updated imports in ${path52.relative(cwd, file)}`));
   }
   const destDir = path52.dirname(destPath);
   if (!fs35.existsSync(destDir)) fs35.mkdirSync(destDir, { recursive: true });
   fs35.renameSync(sourcePath, destPath);
   console.log(
-    chalk195.white(
+    chalk196.white(
       `  Moved ${path52.relative(cwd, sourcePath)} \u2192 ${path52.relative(cwd, destPath)}`
     )
   );
@@ -27091,16 +27232,16 @@ function computeRenameRewrites(sourcePath, destPath) {
 
 // src/commands/refactor/rename/printRenamePreview.ts
 import path54 from "path";
-import chalk196 from "chalk";
+import chalk197 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
-      chalk196.dim(
+      chalk197.dim(
         `  ${path54.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
-  console.log(chalk196.dim("Dry run. Use --apply to execute."));
+  console.log(chalk197.dim("Dry run. Use --apply to execute."));
 }
 
 // src/commands/refactor/rename/index.ts
@@ -27111,20 +27252,20 @@ async function rename(source, destination, options2 = {}) {
   const relSource = path55.relative(cwd, sourcePath);
   const relDest = path55.relative(cwd, destPath);
   if (!fs36.existsSync(sourcePath)) {
-    console.log(chalk197.red(`File not found: ${source}`));
+    console.log(chalk198.red(`File not found: ${source}`));
     process.exit(1);
   }
   if (destPath !== sourcePath && fs36.existsSync(destPath)) {
-    console.log(chalk197.red(`Destination already exists: ${destination}`));
+    console.log(chalk198.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
-  console.log(chalk197.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  console.log(chalk197.dim("Loading project..."));
-  console.log(chalk197.dim("Scanning imports across the project..."));
+  console.log(chalk198.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk198.dim("Loading project..."));
+  console.log(chalk198.dim("Scanning imports across the project..."));
   const rewrites = computeRenameRewrites(sourcePath, destPath);
   const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
   console.log(
-    chalk197.dim(
+    chalk198.dim(
       `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
     )
   );
@@ -27133,11 +27274,11 @@ async function rename(source, destination, options2 = {}) {
     return;
   }
   applyRename(rewrites, sourcePath, destPath, cwd);
-  console.log(chalk197.green("Done"));
+  console.log(chalk198.green("Done"));
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import chalk198 from "chalk";
+import chalk199 from "chalk";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
 import { SyntaxKind as SyntaxKind15 } from "ts-morph";
@@ -27183,33 +27324,33 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const { project, sourceFile } = loadProjectFile(file);
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk198.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk199.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(
-    chalk198.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk199.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines2] of grouped) {
     console.log(
-      `  ${chalk198.dim(refFile)}: lines ${chalk198.cyan(lines2.join(", "))}`
+      `  ${chalk199.dim(refFile)}: lines ${chalk199.cyan(lines2.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk198.green(`
+    console.log(chalk199.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk198.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk199.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
 import path63 from "path";
-import chalk201 from "chalk";
+import chalk202 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
 import path57 from "path";
@@ -27288,50 +27429,50 @@ function clusterFiles(graph) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path59 from "path";
-import chalk199 from "chalk";
+import chalk200 from "chalk";
 function relPath(filePath) {
   return path59.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk199.bold("\nFile moves:"));
+  console.log(chalk200.bold("\nFile moves:"));
   for (const move2 of plan2.moves) {
     console.log(
-      `  ${chalk199.red(relPath(move2.from))} \u2192 ${chalk199.green(relPath(move2.to))}`
+      `  ${chalk200.red(relPath(move2.from))} \u2192 ${chalk200.green(relPath(move2.to))}`
     );
-    console.log(chalk199.dim(`    ${move2.reason}`));
+    console.log(chalk200.dim(`    ${move2.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk199.bold(`
+  console.log(chalk200.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk199.cyan(relPath(file))}:`);
+    console.log(`  ${chalk200.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk199.red(`"${oldSpecifier}"`)} \u2192 ${chalk199.green(`"${newSpecifier}"`)}`
+        `    ${chalk200.red(`"${oldSpecifier}"`)} \u2192 ${chalk200.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk199.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk199.yellow(`  ${w}`));
+    console.log(chalk200.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk200.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk199.bold("\nNew directories:"));
+    console.log(chalk200.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk199.green(`  ${dir}/`));
+      console.log(chalk200.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk199.dim(
+    chalk200.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -27341,18 +27482,18 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 // src/commands/refactor/restructure/executePlan.ts
 import fs37 from "fs";
 import path60 from "path";
-import chalk200 from "chalk";
+import chalk201 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs37.writeFileSync(file, content, "utf8");
     console.log(
-      chalk200.cyan(`  Rewrote imports in ${path60.relative(process.cwd(), file)}`)
+      chalk201.cyan(`  Rewrote imports in ${path60.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs37.mkdirSync(dir, { recursive: true });
-    console.log(chalk200.green(`  Created ${path60.relative(process.cwd(), dir)}/`));
+    console.log(chalk201.green(`  Created ${path60.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
     const targetDir = path60.dirname(move2.to);
@@ -27361,7 +27502,7 @@ function executePlan(plan2) {
     }
     fs37.renameSync(move2.from, move2.to);
     console.log(
-      chalk200.white(
+      chalk201.white(
         `  Moved ${path60.relative(process.cwd(), move2.from)} \u2192 ${path60.relative(process.cwd(), move2.to)}`
       )
     );
@@ -27376,7 +27517,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs37.rmdirSync(dir);
       console.log(
-        chalk200.dim(
+        chalk201.dim(
           `  Removed empty directory ${path60.relative(process.cwd(), dir)}`
         )
       );
@@ -27509,22 +27650,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk201.yellow("No files found matching pattern"));
+    console.log(chalk202.yellow("No files found matching pattern"));
     return;
   }
   const tsConfigPath = findTsConfig(path63.resolve(files[0]));
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk201.green("No restructuring needed"));
+    console.log(chalk202.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk201.bold("\nApplying changes..."));
+    console.log(chalk202.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk201.green("\nRestructuring complete"));
+    console.log(chalk202.green("\nRestructuring complete"));
   } else {
-    console.log(chalk201.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk202.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -27847,7 +27988,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync43 } from "fs";
+import { readFileSync as readFileSync44 } from "fs";
 
 // src/commands/review/carriedUnanchoredFindings.ts
 function carriedUnanchoredFindings(unanchored) {
@@ -28182,18 +28323,18 @@ function partitionFindingsByDiff(findings, index3) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk202 from "chalk";
+import chalk203 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk202.yellow(
+    chalk203.yellow(
       `Moved ${outOfDiff.length} finding(s) whose lines fall outside the PR diff into the review body (GitHub cannot anchor a comment on these):`
     )
   );
   for (const finding of outOfDiff) {
     const range = finding.startLine !== void 0 ? `${finding.startLine}-${finding.line}` : `${finding.line}`;
     console.warn(
-      `  ${chalk202.yellow("\xB7")} ${finding.title} ${chalk202.dim(
+      `  ${chalk203.yellow("\xB7")} ${finding.title} ${chalk203.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -28217,18 +28358,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk203 from "chalk";
+import chalk204 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk203.yellow(
+    chalk204.yellow(
       `Moved ${unlocated.length} finding(s) without a parseable file:line into the review body:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk203.dim("missing");
+    const where = finding.location || chalk204.dim("missing");
     console.warn(
-      `  ${chalk203.yellow("\xB7")} ${finding.title} ${chalk203.dim(`(${where})`)}`
+      `  ${chalk204.yellow("\xB7")} ${finding.title} ${chalk204.dim(`(${where})`)}`
     );
   }
 }
@@ -28295,7 +28436,7 @@ async function confirmPost(prNumber, work, options2) {
   return promptConfirm(`Post ${work} to PR #${prNumber}?`, false);
 }
 async function postFindingsToPr(prInfo, synthesisPath, options2) {
-  const markdown = readFileSync43(synthesisPath, "utf8");
+  const markdown = readFileSync44(synthesisPath, "utf8");
   const { inDiff, unanchored } = selectPostableFindings(markdown, prInfo);
   const carried = carriedUnanchoredFindings(unanchored);
   if (inDiff.length === 0 && carried.length === 0) return NOTHING_POSTED;
@@ -28431,16 +28572,16 @@ async function handlePostSynthesis(synthesisPath, prInfo, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync55, mkdirSync as mkdirSync20, unlinkSync as unlinkSync17, writeFileSync as writeFileSync37 } from "fs";
+import { existsSync as existsSync56, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync38 } from "fs";
 function clearReviewFiles(paths) {
   for (const path80 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync55(path80)) unlinkSync17(path80);
+    if (existsSync56(path80)) unlinkSync17(path80);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
-  mkdirSync20(paths.reviewDir, { recursive: true });
+  mkdirSync21(paths.reviewDir, { recursive: true });
   if (force) clearReviewFiles(paths);
-  writeFileSync37(paths.requestPath, requestBody);
+  writeFileSync38(paths.requestPath, requestBody);
 }
 
 // src/commands/review/cachedReviewerResult.ts
@@ -28661,7 +28802,7 @@ function printReviewerFailures(results) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync57, unlinkSync as unlinkSync19 } from "fs";
+import { existsSync as existsSync58, unlinkSync as unlinkSync19 } from "fs";
 
 // src/commands/review/buildReviewerStdin.ts
 var REVIEW_PROMPT = `You are acting as a reviewer for a proposed code change made by another engineer. The full review request \u2014 branch, base, changed files, and unified diff \u2014 is in the request file whose absolute path is given below.
@@ -28736,7 +28877,7 @@ The review request is at: ${requestPath}
 }
 
 // src/commands/review/runClaudeReviewer.ts
-import { writeFileSync as writeFileSync38 } from "fs";
+import { writeFileSync as writeFileSync39 } from "fs";
 
 // src/commands/review/finaliseReviewerSpinner.ts
 var SUMMARY_MAX_LEN = 80;
@@ -29072,7 +29213,7 @@ async function runClaudeReviewer(spec) {
     }
   });
   if (result.exitCode === 0 && finalText)
-    writeFileSync38(spec.outputPath, finalText);
+    writeFileSync39(spec.outputPath, finalText);
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
 
@@ -29090,7 +29231,7 @@ function resolveClaude(args) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync56, unlinkSync as unlinkSync18 } from "fs";
+import { existsSync as existsSync57, unlinkSync as unlinkSync18 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -29142,7 +29283,7 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner);
     }
   });
-  if (result.exitCode !== 0 && existsSync56(spec.outputPath)) {
+  if (result.exitCode !== 0 && existsSync57(spec.outputPath)) {
     unlinkSync18(spec.outputPath);
   }
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
@@ -29184,7 +29325,7 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync44 } from "fs";
+import { readFileSync as readFileSync45 } 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.
@@ -29249,7 +29390,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary2(synthesisPath) {
-  const markdown = readFileSync44(synthesisPath, "utf8");
+  const markdown = readFileSync45(synthesisPath, "utf8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -29297,7 +29438,7 @@ async function runAndSynthesise(args) {
     console.error("Both reviewers failed; skipping synthesis.");
     return { ok: false, failures };
   }
-  if (anyFresh && existsSync57(paths.synthesisPath)) {
+  if (anyFresh && existsSync58(paths.synthesisPath)) {
     unlinkSync19(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
@@ -29483,7 +29624,7 @@ function registerReview(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk205 from "chalk";
+import chalk206 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -29512,10 +29653,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk204 from "chalk";
+import chalk205 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk204.red(`Connection "${name}" already exists.`));
+    console.error(chalk205.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -29533,16 +29674,16 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk205.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk206.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk209 from "chalk";
+import chalk210 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk206 from "chalk";
+import chalk207 from "chalk";
 async function fetchSeq(conn, path80, params) {
   const url = `${conn.url}${path80}?${params}`;
   const response = await fetch(url, {
@@ -29553,7 +29694,7 @@ async function fetchSeq(conn, path80, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk206.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk207.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -29612,23 +29753,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk207 from "chalk";
+import chalk208 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk207.bgRed.white;
+      return chalk208.bgRed.white;
     case "Error":
-      return chalk207.red;
+      return chalk208.red;
     case "Warning":
-      return chalk207.yellow;
+      return chalk208.yellow;
     case "Information":
-      return chalk207.cyan;
+      return chalk208.cyan;
     case "Debug":
-      return chalk207.gray;
+      return chalk208.gray;
     case "Verbose":
-      return chalk207.dim;
+      return chalk208.dim;
     default:
-      return chalk207.white;
+      return chalk208.white;
   }
 }
 function levelAbbrev(level) {
@@ -29669,12 +29810,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk207.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk208.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines2 = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines2.push(chalk207.red(`  ${line}`));
+      lines2.push(chalk208.red(`  ${line}`));
     }
   }
   return lines2.join("\n");
@@ -29707,11 +29848,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk208 from "chalk";
+import chalk209 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk208.red(
+      chalk209.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -29720,7 +29861,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(chalk208.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk209.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -29749,7 +29890,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count8) })
   );
   if (events.length === 0) {
-    console.log(chalk209.yellow("No events found."));
+    console.log(chalk210.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -29760,11 +29901,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk209.dim(`
+  console.log(chalk210.dim(`
 ${events.length} events`));
   if (events.length >= count8) {
     console.log(
-      chalk209.yellow(
+      chalk210.yellow(
         `Results limited to ${count8}. Use --count to retrieve more.`
       )
     );
@@ -29772,10 +29913,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk210 from "chalk";
+import chalk211 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk210.red(`Connection "${name}" not found.`));
+    console.error(chalk211.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -29824,7 +29965,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk212 from "chalk";
+import chalk213 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -29853,7 +29994,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk211 from "chalk";
+import chalk212 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -29861,7 +30002,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk211.red(`Invalid port "${portStr}".`));
+    console.error(chalk212.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -29874,13 +30015,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk212.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk213.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk213 from "chalk";
+import chalk214 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -29889,7 +30030,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk213.yellow("(no rows)"));
+    console.log(chalk214.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -29897,13 +30038,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(chalk213.dim(header));
-  console.log(chalk213.dim("-".repeat(header.length)));
+  console.log(chalk214.dim(header));
+  console.log(chalk214.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(chalk213.dim(`
+  console.log(chalk214.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -29963,7 +30104,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk214 from "chalk";
+import chalk215 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -29997,7 +30138,7 @@ function isMutation(sql25) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk214.red(
+      chalk215.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -30007,18 +30148,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk214.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk215.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk215 from "chalk";
+import chalk216 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk215.red(
+      chalk216.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -30033,7 +30174,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk215.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk216.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -30178,7 +30319,7 @@ function reportPrune(label2, result, force) {
 // src/commands/sync/syncClaudeMd.ts
 import * as fs41 from "fs";
 import * as path66 from "path";
-import chalk216 from "chalk";
+import chalk217 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path66.join(claudeDir, "CLAUDE.md");
   const target = path66.join(targetBase, "CLAUDE.md");
@@ -30187,14 +30328,14 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
     const targetContent = fs41.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk216.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk217.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       if (!options2?.yes) {
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk216.red("Overwrite existing CLAUDE.md?"),
+          chalk217.red("Overwrite existing CLAUDE.md?"),
           false
         );
         if (!confirm) {
@@ -30427,7 +30568,7 @@ function syncPi(claudeDir, options2) {
 // src/commands/sync/syncSettings.ts
 import * as fs47 from "fs";
 import * as path73 from "path";
-import chalk217 from "chalk";
+import chalk218 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path73.join(claudeDir, "settings.json");
   const target = path73.join(targetBase, "settings.json");
@@ -30446,7 +30587,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk217.yellow(
+          chalk218.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
@@ -30454,7 +30595,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
         printDiff(targetContent, mergedContent);
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk217.red("Overwrite existing settings.json?"),
+          chalk218.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -30596,11 +30737,11 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync62, readdirSync as readdirSync19, statSync as statSync10 } from "fs";
+import { existsSync as existsSync63, readdirSync as readdirSync19, statSync as statSync10 } from "fs";
 import { join as join77 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync62(vttDir)) return;
+  if (!existsSync63(vttDir)) return;
   for (const entry of readdirSync19(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
     if (statSync10(join77(vttDir, entry)).isDirectory()) continue;
@@ -30610,11 +30751,11 @@ function list4() {
 
 // src/commands/transcript/move.ts
 import {
-  existsSync as existsSync63,
-  mkdirSync as mkdirSync26,
-  readFileSync as readFileSync49,
+  existsSync as existsSync64,
+  mkdirSync as mkdirSync27,
+  readFileSync as readFileSync50,
   renameSync as renameSync2,
-  writeFileSync as writeFileSync42
+  writeFileSync as writeFileSync43
 } from "fs";
 import { basename as basename21, join as join78 } from "path";
 
@@ -30824,13 +30965,13 @@ function formatChatLog(messages) {
 // src/commands/transcript/move.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function convertVttToMarkdown(inputPath) {
-  const cues = parseVtt(readFileSync49(inputPath, "utf8"));
+  const cues = parseVtt(readFileSync50(inputPath, "utf8"));
   const messages = cuesToChatMessages(deduplicateCues(cues));
   return formatChatLog(messages);
 }
 function archiveRawVtt(vttDir, sourcePath, filename) {
   const processedDir = join78(vttDir, "processed");
-  mkdirSync26(processedDir, { recursive: true });
+  mkdirSync27(processedDir, { recursive: true });
   renameSync2(sourcePath, join78(processedDir, filename));
 }
 function move(file, options2) {
@@ -30842,16 +30983,16 @@ function move(file, options2) {
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
   const filename = basename21(file);
   const sourcePath = join78(vttDir, filename);
-  if (!existsSync63(sourcePath)) {
+  if (!existsSync64(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
   const base = basename21(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
   const formattedDir = join78(transcriptsDir, client);
-  mkdirSync26(formattedDir, { recursive: true });
+  mkdirSync27(formattedDir, { recursive: true });
   const formattedPath = join78(formattedDir, outputName);
-  writeFileSync42(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
+  writeFileSync43(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
   const summaryPath = join78(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
@@ -30939,9 +31080,9 @@ import { join as join80 } from "path";
 
 // src/commands/voice/shared.ts
 import { homedir as homedir24 } from "os";
-import { dirname as dirname34, join as join79 } from "path";
+import { dirname as dirname35, join as join79 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
-var __dirname6 = dirname34(fileURLToPath8(import.meta.url));
+var __dirname6 = dirname35(fileURLToPath8(import.meta.url));
 var VOICE_DIR = join79(homedir24(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
@@ -30971,14 +31112,14 @@ function devices() {
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync64, readFileSync as readFileSync50 } from "fs";
+import { existsSync as existsSync65, readFileSync as readFileSync51 } from "fs";
 function logs(options2) {
-  if (!existsSync64(voicePaths.log)) {
+  if (!existsSync65(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count8 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync50(voicePaths.log, "utf8").trim();
+  const content = readFileSync51(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -31000,12 +31141,12 @@ function logs(options2) {
 
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync9 } from "child_process";
-import { mkdirSync as mkdirSync28 } from "fs";
+import { mkdirSync as mkdirSync29 } from "fs";
 import { join as join82 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync58 } from "child_process";
-import { existsSync as existsSync65, mkdirSync as mkdirSync27, readFileSync as readFileSync51, writeFileSync as writeFileSync43 } from "fs";
+import { existsSync as existsSync66, mkdirSync as mkdirSync28, readFileSync as readFileSync52, writeFileSync as writeFileSync44 } from "fs";
 import { join as join81 } from "path";
 function isProcessAlive2(pid) {
   try {
@@ -31017,9 +31158,9 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync65(lockFile)) return;
+  if (!existsSync66(lockFile)) return;
   try {
-    const lock2 = JSON.parse(readFileSync51(lockFile, "utf8"));
+    const lock2 = JSON.parse(readFileSync52(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`
@@ -31030,7 +31171,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync65(getVenvPython())) return;
+  if (existsSync66(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync58(
@@ -31043,8 +31184,8 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync27(join81(lockFile, ".."), { recursive: true });
-  writeFileSync43(
+  mkdirSync28(join81(lockFile, ".."), { recursive: true });
+  writeFileSync44(
     lockFile,
     JSON.stringify({
       pid,
@@ -31056,7 +31197,7 @@ function writeLockFile(pid) {
 
 // src/commands/voice/setup.ts
 function setup() {
-  mkdirSync28(voicePaths.dir, { recursive: true });
+  mkdirSync29(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
   const script = join82(getPythonDir(), "setup_models.py");
@@ -31072,7 +31213,7 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdirSync as mkdirSync29, writeFileSync as writeFileSync44 } from "fs";
+import { mkdirSync as mkdirSync30, writeFileSync as writeFileSync45 } from "fs";
 import { join as join83 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
@@ -31101,12 +31242,12 @@ function spawnBackground(python, script, env) {
     console.error("Failed to start voice daemon");
     process.exit(1);
   }
-  writeFileSync44(voicePaths.pid, String(pid));
+  writeFileSync45(voicePaths.pid, String(pid));
   writeLockFile(pid);
   console.log(`Voice daemon started (PID ${pid})`);
 }
 function start2(options2) {
-  mkdirSync29(voicePaths.dir, { recursive: true });
+  mkdirSync30(voicePaths.dir, { recursive: true });
   checkLockFile();
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
@@ -31121,7 +31262,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync66, readFileSync as readFileSync52 } from "fs";
+import { existsSync as existsSync67, readFileSync as readFileSync53 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -31131,16 +31272,16 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count8) {
-  if (!existsSync66(voicePaths.log)) return [];
-  const lines2 = readFileSync52(voicePaths.log, "utf8").trim().split("\n");
+  if (!existsSync67(voicePaths.log)) return [];
+  const lines2 = readFileSync53(voicePaths.log, "utf8").trim().split("\n");
   return lines2.slice(-count8);
 }
 function status2() {
-  if (!existsSync66(voicePaths.pid)) {
+  if (!existsSync67(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync52(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync53(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -31159,13 +31300,13 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync67, readFileSync as readFileSync53, unlinkSync as unlinkSync20 } from "fs";
+import { existsSync as existsSync68, readFileSync as readFileSync54, unlinkSync as unlinkSync20 } from "fs";
 function stop2() {
-  if (!existsSync67(voicePaths.pid)) {
+  if (!existsSync68(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync53(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync54(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -31178,7 +31319,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync67(lockFile)) unlinkSync20(lockFile);
+    if (existsSync68(lockFile)) unlinkSync20(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -31583,7 +31724,7 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/resolveRunCwd.ts
-import { existsSync as existsSync68 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 import { resolve as resolve18 } from "path";
 var MissingRunCwdError = class extends Error {
   constructor(runName, cwd) {
@@ -31596,25 +31737,25 @@ var MissingRunCwdError = class extends Error {
 function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
   if (!config.cwd) return void 0;
   const cwd = resolve18(baseDir, config.cwd);
-  if (!existsSync68(cwd)) throw new MissingRunCwdError(config.name, cwd);
+  if (!existsSync69(cwd)) throw new MissingRunCwdError(config.name, cwd);
   return cwd;
 }
 
 // src/commands/run/runCommandToCompletion.ts
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync70 } from "fs";
+import { existsSync as existsSync71 } from "fs";
 
 // src/commands/run/resolveCommand.ts
 import { execFileSync as execFileSync16 } from "child_process";
-import { existsSync as existsSync69 } from "fs";
-import { dirname as dirname35, join as join85, resolve as resolve19 } from "path";
+import { existsSync as existsSync70 } from "fs";
+import { dirname as dirname36, join as join85, resolve as resolve19 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync16("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
-    const gitRoot = resolve19(dirname35(gitPath), "..");
+    const gitRoot = resolve19(dirname36(gitPath), "..");
     const gitBash = join85(gitRoot, "bin", "bash.exe");
-    if (existsSync69(gitBash)) return gitBash;
+    if (existsSync70(gitBash)) return gitBash;
   } catch {
     return command;
   }
@@ -31624,7 +31765,7 @@ function resolveCommand2(command) {
 // src/commands/run/runCommandToCompletion.ts
 function runCommandToCompletion(command, args, env, cwd, quiet) {
   return new Promise((resolveResult) => {
-    if (cwd && !existsSync70(cwd)) {
+    if (cwd && !existsSync71(cwd)) {
       resolveResult({
         kind: "failed",
         message: `Failed to execute command: cwd ${cwd} does not exist`
@@ -31881,7 +32022,7 @@ function registerWatch(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk218 from "chalk";
+import chalk219 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -32012,13 +32153,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk218.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk219.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk218.white("http://localhost:14523/callback\n"));
-  console.log(chalk218.blue("Opening browser for authorization..."));
-  console.log(chalk218.dim("Waiting for authorization callback..."));
+  console.log(chalk219.white("http://localhost:14523/callback\n"));
+  console.log(chalk219.blue("Opening browser for authorization..."));
+  console.log(chalk219.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk218.dim("Exchanging code for tokens..."));
+  console.log(chalk219.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -32034,13 +32175,13 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk218.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk219.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import { readdirSync as readdirSync20, readFileSync as readFileSync54, statSync as statSync11 } from "fs";
+import { readdirSync as readdirSync20, readFileSync as readFileSync55, statSync as statSync11 } from "fs";
 import { join as join86 } from "path";
 function findPortFile(roamDir) {
   let entries;
@@ -32066,7 +32207,7 @@ function postRoamActivity(app, event) {
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync54(portFile, "utf8").trim();
+    port = readFileSync55(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -32194,7 +32335,7 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync30, writeFileSync as writeFileSync45 } from "fs";
+import { mkdirSync as mkdirSync31, writeFileSync as writeFileSync46 } from "fs";
 import { join as join87 } from "path";
 
 // src/commands/run/extractOption.ts
@@ -32257,7 +32398,7 @@ function saveNewRunConfig(name, command, args, cwd) {
 }
 function createCommandFile(name) {
   const dir = join87(".claude", "commands");
-  mkdirSync30(dir, { recursive: true });
+  mkdirSync31(dir, { recursive: true });
   const content = `---
 description: Run ${name}
 ---
@@ -32265,7 +32406,7 @@ description: Run ${name}
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
   const filePath = join87(dir, `${name}.md`);
-  writeFileSync45(filePath, content);
+  writeFileSync46(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add3() {
@@ -32320,7 +32461,7 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync71, unlinkSync as unlinkSync21 } from "fs";
+import { existsSync as existsSync72, unlinkSync as unlinkSync21 } from "fs";
 import { join as join88 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
@@ -32337,7 +32478,7 @@ function parseRemoveName() {
 }
 function deleteCommandFile(name) {
   const filePath = join88(".claude", "commands", `${name}.md`);
-  if (existsSync71(filePath)) {
+  if (existsSync72(filePath)) {
     unlinkSync21(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -32382,10 +32523,10 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync60 } from "child_process";
-import { existsSync as existsSync72, mkdirSync as mkdirSync31, unlinkSync as unlinkSync22, writeFileSync as writeFileSync46 } from "fs";
+import { existsSync as existsSync73, mkdirSync as mkdirSync32, unlinkSync as unlinkSync22, writeFileSync as writeFileSync47 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
 import { join as join89, resolve as resolve20 } from "path";
-import chalk219 from "chalk";
+import chalk220 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -32514,15 +32655,15 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync72(outputDir)) {
-    mkdirSync31(outputDir, { recursive: true });
+  if (!existsSync73(outputDir)) {
+    mkdirSync32(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve20(outputDir, `${processName}-${timestamp6}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
   const scriptPath = join89(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
-  writeFileSync46(scriptPath, captureWindowPs1, "utf8");
+  writeFileSync47(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync60(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
@@ -32536,13 +32677,13 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve20(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk219.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk220.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk219.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk220.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk219.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk220.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -32598,11 +32739,11 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/readDaemonPidFile.ts
-import { readFileSync as readFileSync55 } from "fs";
+import { readFileSync as readFileSync56 } from "fs";
 function readDaemonPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync55(daemonPaths.pid, "utf8").trim(),
+      readFileSync56(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -32755,7 +32896,7 @@ function requestDrain(socket, lines2) {
 }
 
 // src/commands/sessions/daemon/runDaemon.ts
-import { mkdirSync as mkdirSync35 } from "fs";
+import { mkdirSync as mkdirSync36 } from "fs";
 
 // src/commands/sessions/daemon/createAutoExit.ts
 var DEFAULT_GRACE_MS = 6e4;
@@ -32859,12 +33000,12 @@ function toSessionRunInfo({
 }
 
 // src/commands/sessions/daemon/worktree/joinRefusal.ts
-import { existsSync as existsSync73 } from "fs";
+import { existsSync as existsSync74 } from "fs";
 function joinRefusal(session) {
   if (session.commandType === "run") return "a server run has no agent stream";
   if (session.closing === true) return "the session is closing";
   if (!session.cwd) return "the session has no working directory";
-  if (!existsSync73(session.cwd))
+  if (!existsSync74(session.cwd))
     return "the session's workspace no longer exists";
   return void 0;
 }
@@ -33028,11 +33169,11 @@ function sessionBase(id, status3) {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
-import { existsSync as existsSync75 } from "fs";
+import { existsSync as existsSync76 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync74, statSync as statSync12 } from "fs";
+import { chmodSync, existsSync as existsSync75, statSync as statSync12 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path75 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -33047,7 +33188,7 @@ function ensureSpawnHelperExecutable() {
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync74(helper)) return;
+  if (!existsSync75(helper)) return;
   const mode = statSync12(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
@@ -33083,7 +33224,7 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
   });
 }
 function refuseMissingCwd(cwd, sessionId) {
-  if (!cwd || existsSync75(cwd)) return;
+  if (!cwd || existsSync76(cwd)) return;
   daemonLog(
     `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
   );
@@ -33265,11 +33406,11 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync77 } from "fs";
+import { existsSync as existsSync78 } from "fs";
 import { basename as basename22 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync76 } from "fs";
+import { existsSync as existsSync77 } from "fs";
 import { join as join92 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
@@ -33339,7 +33480,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync76(join92(worktreePath, ".git")))
+  if (!existsSync77(join92(worktreePath, ".git")))
     return "its .git link is already gone";
   if (/not a working tree|not a git repository/i.test(reason2(cause)))
     return "git no longer recognises it as a working tree";
@@ -33391,7 +33532,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync77(worktreePath)) {
+  if (!existsSync78(worktreePath)) {
     forgetWorktree(worktreePath);
     daemonLog(
       `worktree ${worktreePath} already gone; its record was forgotten`
@@ -33416,7 +33557,7 @@ async function reapWorktree(worktreePath, force = false) {
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync77(recorded)) return recorded;
+  if (recorded && existsSync78(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -33547,12 +33688,12 @@ function closeGateApplies(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync78, watch } from "fs";
+import { existsSync as existsSync79, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync78(common)) return void 0;
+  if (!common || !existsSync79(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -34029,10 +34170,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync79 } from "fs";
+import { existsSync as existsSync80 } from "fs";
 import { resolve as resolve21 } from "path";
 function exitDetail(session) {
-  if (session.cwd && !existsSync79(session.cwd))
+  if (session.cwd && !existsSync80(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
   return missingRunConfigCwd(session);
 }
@@ -34046,7 +34187,7 @@ function missingRunConfigCwd(session) {
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
   const configured = resolve21(runConfigBaseDirFrom(dir), config.cwd);
-  if (existsSync79(configured)) return void 0;
+  if (existsSync80(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
 
@@ -34087,8 +34228,8 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync80, mkdirSync as mkdirSync32, watch as watch2 } from "fs";
-import { dirname as dirname37 } from "path";
+import { existsSync as existsSync81, mkdirSync as mkdirSync33, watch as watch2 } from "fs";
+import { dirname as dirname38 } from "path";
 
 // src/commands/sessions/daemon/applyActivityToSession.ts
 function applyActivityToSession(session, activity2) {
@@ -34150,9 +34291,9 @@ var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
   const path80 = activityPath(session.id);
-  const dir = dirname37(path80);
+  const dir = dirname38(path80);
   try {
-    mkdirSync32(dir, { recursive: true });
+    mkdirSync33(dir, { recursive: true });
   } catch {
     return;
   }
@@ -34173,7 +34314,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read2, DEBOUNCE_MS2);
   });
-  if (existsSync80(path80)) read2();
+  if (existsSync81(path80)) read2();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -34355,10 +34496,10 @@ function headContainsSessionId(filePath, claudeSessionId) {
 }
 
 // src/commands/sessions/daemon/ensureProjectDirExists.ts
-import { mkdirSync as mkdirSync33 } from "fs";
+import { mkdirSync as mkdirSync34 } from "fs";
 function ensureProjectDirExists(dir, sessionId) {
   try {
-    mkdirSync33(dir, { recursive: true });
+    mkdirSync34(dir, { recursive: true });
     return true;
   } catch (error) {
     daemonLog(
@@ -35795,7 +35936,7 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync83 } from "fs";
+import { existsSync as existsSync84 } from "fs";
 import { basename as basename24 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -35850,9 +35991,9 @@ function bindResumedWorktree(session, cwd, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync82 } from "fs";
+import { existsSync as existsSync83 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync82(clone)) {
+  if (!existsSync83(clone)) {
     for (const { path: path80 } of paths) forgetWorktree(path80);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -36018,7 +36159,7 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
       );
       continue;
     }
-    if (!existsSync83(path80)) {
+    if (!existsSync84(path80)) {
       logVanishedTree(sessions, path80);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
@@ -36635,14 +36776,14 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync84, readFileSync as readFileSync57 } from "fs";
+import { existsSync as existsSync85, readFileSync as readFileSync58 } from "fs";
 import { posix as posix3 } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync84(sessionsFile)) return false;
-    const data = JSON.parse(readFileSync57(sessionsFile, "utf8"));
+    if (!existsSync85(sessionsFile)) return false;
+    const data = JSON.parse(readFileSync58(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
     const message3 = error instanceof Error ? error.message : String(error);
@@ -37376,7 +37517,7 @@ function setAutoAdvance(sessions, id, enabled) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
-import { existsSync as existsSync87 } from "fs";
+import { existsSync as existsSync88 } from "fs";
 
 // src/commands/sessions/daemon/resumeSession.ts
 function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
@@ -37407,10 +37548,10 @@ function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
-import { existsSync as existsSync86 } from "fs";
+import { existsSync as existsSync87 } from "fs";
 
 // src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
-import { copyFileSync as copyFileSync7, existsSync as existsSync85, mkdirSync as mkdirSync34 } from "fs";
+import { copyFileSync as copyFileSync7, existsSync as existsSync86, mkdirSync as mkdirSync35 } from "fs";
 import { join as join94 } from "path";
 function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
   const dir = projectDirForCwd(toCwd);
@@ -37421,7 +37562,7 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     return;
   }
   const dest = join94(dir, `${claudeSessionId}.jsonl`);
-  if (existsSync85(dest)) {
+  if (existsSync86(dest)) {
     daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
     return;
   }
@@ -37433,7 +37574,7 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     return;
   }
   try {
-    mkdirSync34(dir, { recursive: true });
+    mkdirSync35(dir, { recursive: true });
     copyFileSync7(source, dest);
     daemonLog(
       `transcript ${source} copied to ${dest} so ${toCwd} can resume it`
@@ -37472,7 +37613,7 @@ function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name, harness
 }
 function cloneForReapedTree(missingCwd) {
   const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
-  if (!clone || !existsSync86(clone))
+  if (!clone || !existsSync87(clone))
     throw new Error(
       `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
     );
@@ -37481,7 +37622,7 @@ function cloneForReapedTree(missingCwd) {
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
 function resumeInTree(ctx, sessionId, cwd, name, harness) {
-  if (!existsSync87(cwd))
+  if (!existsSync88(cwd))
     return resumeInReplacementTree(ctx, sessionId, cwd, name, harness);
   const id = ctx.spawnWith(
     (sid) => resumeSession(sid, sessionId, cwd, name, void 0, harness)
@@ -37825,10 +37966,10 @@ async function parseTranscript(sessionId) {
   if (rollout) return readMessages(rollout, parseCodexTranscriptLines);
   return [];
 }
-async function readMessages(filePath, parse3) {
+async function readMessages(filePath, parse4) {
   try {
     const raw = await fs54.promises.readFile(filePath, "utf8");
-    return parse3(raw.split("\n"));
+    return parse4(raw.split("\n"));
   } catch {
     return [];
   }
@@ -38057,10 +38198,10 @@ function handleConnection(socket, manager) {
 }
 
 // src/commands/sessions/daemon/onListening.ts
-import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync47 } from "fs";
+import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync48 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync58 } from "fs";
+import { readFileSync as readFileSync59 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -38071,7 +38212,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync58(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync59(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -38079,7 +38220,7 @@ function ownsPidFile() {
 
 // src/commands/sessions/daemon/onListening.ts
 function onListening(manager, checkAutoExit) {
-  writeFileSync47(daemonPaths.pid, String(process.pid));
+  writeFileSync48(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
     void manager.flushActiveMs().finally(() => {
@@ -38266,7 +38407,7 @@ async function recoverFromAddrInUse(server, manager, checkAutoExit) {
 
 // src/commands/sessions/daemon/runDaemon.ts
 async function runDaemon() {
-  mkdirSync35(daemonPaths.dir, { recursive: true });
+  mkdirSync36(daemonPaths.dir, { recursive: true });
   daemonLog(
     `starting (reason: ${process.env.ASSIST_DAEMON_SPAWN_REASON ?? "manual"})`
   );
@@ -38321,7 +38462,7 @@ function registerSetStatusCommand(cmd) {
 
 // src/commands/sessions/summarise/index.ts
 import * as fs56 from "fs";
-import chalk220 from "chalk";
+import chalk221 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs55 from "fs";
@@ -38380,22 +38521,22 @@ ${firstMessage}`);
 async function summarise2(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk220.yellow("No sessions found."));
+    console.log(chalk221.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk220.green("All sessions already summarised."));
+    console.log(chalk221.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk220.cyan(
+    chalk221.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk220.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk220.yellow(`, ${failed2} skipped`) : "")
+    chalk221.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk221.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -38415,16 +38556,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk220.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk221.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk220.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk221.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk220.yellow("skip")}
+      process.stdout.write(` ${chalk221.yellow("skip")}
 `);
     }
   }
@@ -38445,7 +38586,7 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk222 from "chalk";
+import chalk223 from "chalk";
 
 // src/shared/contextLevel.ts
 function contextLevel(pct) {
@@ -38455,7 +38596,7 @@ function contextLevel(pct) {
 }
 
 // src/commands/buildLimitsSegment.ts
-import chalk221 from "chalk";
+import chalk222 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -38493,9 +38634,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk221.green,
-  warn: chalk221.yellow,
-  over: chalk221.red
+  ok: chalk222.green,
+  warn: chalk222.yellow,
+  over: chalk222.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -38526,7 +38667,7 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync60, statSync as statSync15 } from "fs";
+import { readFileSync as readFileSync61, statSync as statSync15 } from "fs";
 import { isAbsolute as isAbsolute4, join as join95, resolve as resolve22 } from "path";
 function resolveGitDir(cwd) {
   const dotGit = join95(cwd, ".git");
@@ -38541,7 +38682,7 @@ function resolveGitDir(cwd) {
   }
   let contents;
   try {
-    contents = readFileSync60(dotGit, "utf8");
+    contents = readFileSync61(dotGit, "utf8");
   } catch {
     return null;
   }
@@ -38559,7 +38700,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync60(join95(gitDir, "HEAD"), "utf8");
+    head = readFileSync61(join95(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -38591,7 +38732,7 @@ async function relayUsage(claudeSessionId, transcriptPath2, usedPct) {
 }
 
 // src/commands/statusLine.ts
-chalk222.level = 3;
+chalk223.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
@@ -38599,9 +38740,9 @@ function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
   switch (contextLevel(pct)) {
     case "red":
-      return chalk222.red(label2);
+      return chalk223.red(label2);
     case "yellow":
-      return chalk222.yellow(label2);
+      return chalk223.yellow(label2);
     default:
       return label2;
   }
@@ -38614,7 +38755,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 ${chalk222.cyan(branch2)} | ` : "";
+  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk223.cyan(branch2)} | ` : "";
   console.log(
     `${branchSegment}${model} | Tokens - ${formatNumber(totalIn)} \u2191 : ${formatNumber(totalOut)} \u2193 | Context - ${colorizePercent(usedPct)}${buildLimitsSegment(data.rate_limits)}`
   );
@@ -38684,10 +38825,10 @@ async function update2() {
 }
 
 // src/reportCliError.ts
-import chalk223 from "chalk";
+import chalk224 from "chalk";
 function reportCliError(error) {
   if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError || error instanceof MissingRunCwdError || error instanceof MiroExtractError) {
-    console.error(chalk223.red(error.message));
+    console.error(chalk224.red(error.message));
   } else {
     console.error(error);
   }