@staff0rd/assist 0.583.0 → 0.585.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.583.0",
+  version: "0.585.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -483,6 +483,15 @@ var transcriptConfigSchema = z3.strictObject({
   transcriptsDir: z3.string(),
   summaryDir: z3.string()
 });
+var miroExtractSchema = z3.strictObject({
+  board: z3.string().optional(),
+  frame: z3.string().optional(),
+  topLeft: z3.string(),
+  bottomRight: z3.string(),
+  items: z3.string(),
+  ignore: z3.string().optional(),
+  out: z3.string().optional()
+});
 var DEFAULT_WAKE_WORDS = ["computer"];
 var DEFAULT_MODELS_DIR = "~/.assist/voice/models";
 var DEFAULT_BACKUP_DIR = "~/.assist/backups";
@@ -629,6 +638,9 @@ var assistConfigShape = {
   mermaid: z3.strictObject({
     krokiUrl: z3.string().default("https://kroki.io")
   }).default({ krokiUrl: "https://kroki.io" }),
+  miro: z3.strictObject({
+    extracts: z3.record(z3.string(), miroExtractSchema).optional()
+  }).optional(),
   deny: z3.array(
     z3.strictObject({
       pattern: z3.string(),
@@ -4489,6 +4501,15 @@ var mermaidConfigHelp = [
   }
 ];
 
+// src/commands/miro/miroConfigHelp.ts
+var miroConfigHelp = [
+  {
+    key: "miro.extracts",
+    setter: "assist miro extract --save <name>",
+    note: "named box selections (board, frame, anchors, items, ignore, out) replayed by miro extract <name>"
+  }
+];
+
 // src/commands/prs/prsConfigHelp.ts
 var prsRaiseConfigHelp = [
   {
@@ -4850,6 +4871,7 @@ var configHelpEntries = [
   ...harnessConfigHelp,
   ...jiraConfigHelp,
   ...mermaidConfigHelp,
+  ...miroConfigHelp,
   ...prsConfigHelp,
   ...ravendbConfigHelp,
   ...refactorConfigHelp,
@@ -5436,9 +5458,9 @@ var daemonPaths = {
 
 // src/commands/sessions/daemon/connectToDaemon.ts
 function connectToDaemon() {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     const socket = net.connect(daemonPaths.socket);
-    socket.once("connect", () => resolve24(socket));
+    socket.once("connect", () => resolve25(socket));
     socket.once("error", reject);
   });
 }
@@ -5591,7 +5613,7 @@ ${failed2.length} script(s) failed:`);
   }
 }
 function runEntry(entry) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     const startTime = Date.now();
     const child = spawnCommand(
       entry.fullCommand,
@@ -5603,7 +5625,7 @@ function runEntry(entry) {
     child.on("close", (code) => {
       const exitCode = code ?? 1;
       flushIfFailed(exitCode, chunks);
-      resolve24({
+      resolve25({
         script: entry.name,
         code: exitCode,
         durationMs: Date.now() - startTime
@@ -6757,8 +6779,8 @@ function spawnInherit(command, args, options2 = {}) {
     env,
     cwd: options2.cwd
   });
-  const done2 = new Promise((resolve24, reject) => {
-    child.on("close", (code) => resolve24(code ?? 0));
+  const done2 = new Promise((resolve25, reject) => {
+    child.on("close", (code) => resolve25(code ?? 0));
     child.on("error", reject);
   });
   return { child, done: done2 };
@@ -7905,7 +7927,7 @@ Failed to launch Claude for ${context}: ${message3}`)
 // src/commands/sessions/daemon/sendToDaemon.ts
 var WRITE_TIMEOUT_MS = 500;
 function sendToDaemon(message3) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     connectToDaemon().then((socket) => {
       const timer = setTimeout(() => {
         socket.destroy();
@@ -7919,7 +7941,7 @@ function sendToDaemon(message3) {
 `, () => {
         clearTimeout(timer);
         socket.end();
-        resolve24();
+        resolve25();
       });
     }, reject);
   });
@@ -7942,7 +7964,7 @@ function readSocketLines(socket, onLine) {
 // src/commands/sessions/daemon/sendToDaemonAwaitAck.ts
 var ACK_TIMEOUT_MS = 1e3;
 function sendToDaemonAwaitAck(message3) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     connectToDaemon().then((socket) => {
       let settled = false;
       const finish = (error) => {
@@ -7951,7 +7973,7 @@ function sendToDaemonAwaitAck(message3) {
         clearTimeout(timer);
         socket.destroy();
         if (error) reject(error);
-        else resolve24();
+        else resolve25();
       };
       const timer = setTimeout(
         () => finish(new Error("timed out awaiting daemon ack")),
@@ -8025,7 +8047,7 @@ async function deliverReliably(sessionId, status3, payload) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve24) => setTimeout(resolve24, ms));
+  return new Promise((resolve25) => setTimeout(resolve25, ms));
 }
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
@@ -9899,7 +9921,7 @@ function spawnDaemon(reason4) {
   child.unref();
 }
 function delay(ms) {
-  return new Promise((resolve24) => setTimeout(resolve24, ms));
+  return new Promise((resolve25) => setTimeout(resolve25, ms));
 }
 
 // src/commands/sessions/daemon/isWindowsCwd.ts
@@ -9965,10 +9987,10 @@ function gitInvocation(cwd, args) {
 }
 function git2(cwd, args) {
   const { file, argv, options: options2 } = gitInvocation(cwd, args);
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     execFile2(file, argv, options2, (error, stdout) => {
       if (error) reject(error);
-      else resolve24(stdout.toString());
+      else resolve25(stdout.toString());
     });
   });
 }
@@ -10389,12 +10411,12 @@ async function loadVisibleItems(req) {
 
 // src/commands/backlog/web/parseStatusBody.ts
 function readBody(req) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
     });
-    req.on("end", () => resolve24(body));
+    req.on("end", () => resolve25(body));
     req.on("error", reject);
   });
 }
@@ -12080,17 +12102,17 @@ async function stopDaemon() {
   }
 }
 function closedBeforeTimeout(socket) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     const timer = setTimeout(() => {
       socket.destroy();
-      resolve24(false);
+      resolve25(false);
     }, STOP_TIMEOUT_MS);
     socket.resume();
     socket.on("error", () => {
     });
     socket.once("close", () => {
       clearTimeout(timer);
-      resolve24(true);
+      resolve25(true);
     });
   });
 }
@@ -12141,8 +12163,8 @@ async function restartWeb(req, res, deps2 = {}) {
     respondJson(res, 400, { error: "Invalid target" });
     return;
   }
-  await new Promise((resolve24) => {
-    res.once("finish", resolve24);
+  await new Promise((resolve25) => {
+    res.once("finish", resolve25);
     respondJson(res, 200, { ok: true });
   });
   if (target === "daemon" || target === "both") {
@@ -14010,7 +14032,7 @@ function parsePreviewDecision(line, requestId) {
 
 // src/commands/sessions/shared/requestPreviewDecision.ts
 function requestPreviewDecision(request) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     connectToDaemon().then((socket) => {
       let settled = false;
       const finish = (error, decision) => {
@@ -14018,7 +14040,7 @@ function requestPreviewDecision(request) {
         settled = true;
         socket.destroy();
         if (error) reject(error);
-        else resolve24(decision);
+        else resolve25(decision);
       };
       readSocketLines(socket, (line) => {
         const incoming = parsePreviewDecision(line, request.requestId);
@@ -17423,12 +17445,12 @@ function hasSubcommands(helpText) {
 // src/commands/permitCliReads/runHelp.ts
 import { exec as exec2 } from "child_process";
 function runHelp(args) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     exec2(
       `${args.join(" ")} --help`,
       { encoding: "utf8", timeout: 3e4 },
       (_err, stdout, stderr) => {
-        resolve24(stdout || stderr || "");
+        resolve25(stdout || stderr || "");
       }
     );
   });
@@ -22604,7 +22626,7 @@ function placedByDaemon() {
 function seed(worktreePath, clone) {
   console.log(`Preparing ${worktreePath}\u2026`);
   return new Promise(
-    (resolve24) => seedWorktree(worktreePath, clone, resolve24)
+    (resolve25) => seedWorktree(worktreePath, clone, resolve25)
   );
 }
 async function moveToPrCheckoutTree() {
@@ -22917,10 +22939,6 @@ function registerMermaid(program2) {
   configHelp(cmd, mermaidConfigHelp);
 }
 
-// src/commands/miro/runExtract.ts
-import chalk171 from "chalk";
-import { stringify as stringify2 } from "yaml";
-
 // src/commands/miro/MiroExtractError.ts
 var MiroExtractError = class extends Error {
   constructor(message3) {
@@ -22952,16 +22970,6 @@ function anchorSource(options2) {
   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;
@@ -22975,6 +22983,137 @@ function miroSource(items2, anchorId) {
   };
 }
 
+// src/commands/miro/boardSource.ts
+function boardSource(raw, anchorId, options2) {
+  const derived = miroSource(raw, anchorId);
+  return {
+    board: options2.board ?? derived.board,
+    frame: options2.frame ?? derived.frame
+  };
+}
+
+// src/commands/miro/emitExtract.ts
+import { stringify as stringify2 } from "yaml";
+
+// 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/emitExtract.ts
+function emitExtract(out, header, texts) {
+  if (!out) {
+    process.stdout.write(stringify2(texts));
+    return;
+  }
+  writeExtract(out, header, texts);
+  console.log(
+    `Wrote ${texts.length} ${texts.length === 1 ? "box" : "boxes"} to ${out}`
+  );
+}
+
+// src/commands/miro/resolveExtractPath.ts
+import { isAbsolute as isAbsolute3, relative as relative5, resolve as resolve17 } from "path";
+function extractRoot(cwd) {
+  return findConfigUp(cwd)?.rootDir ?? cwd;
+}
+function resolveExtractPath(value, cwd) {
+  if (value === void 0) return void 0;
+  return isAbsolute3(value) ? value : resolve17(extractRoot(cwd), value);
+}
+function storedExtractPath(value, cwd) {
+  if (value === void 0) return void 0;
+  const absolute2 = resolve17(cwd, value);
+  const within = relative5(extractRoot(cwd), absolute2);
+  return within.startsWith("..") ? absolute2 : within;
+}
+
+// src/commands/miro/extractToSave.ts
+function defined2(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, field]) => field !== void 0)
+  );
+}
+function extractToSave(details, cwd = process.cwd()) {
+  return defined2({
+    board: details.board,
+    frame: details.frame,
+    topLeft: details.topLeft,
+    bottomRight: details.bottomRight,
+    items: storedExtractPath(details.items, cwd),
+    ignore: storedExtractPath(details.options.ignore, cwd),
+    out: storedExtractPath(details.options.out, cwd)
+  });
+}
+
+// src/commands/miro/keptTexts.ts
+import chalk171 from "chalk";
+
+// 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/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/uniqueTexts.ts
+function uniqueTexts(boxes) {
+  return [...new Set(boxes.map((box) => box.text))];
+}
+
+// src/commands/miro/keptTexts.ts
+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}`
+    )
+  );
+}
+function keptTexts(options2, boxes) {
+  const ignore3 = options2.ignore ? readIgnoreList(options2.ignore) : [];
+  const kept = applyIgnore(uniqueTexts(boxes), ignore3);
+  if (options2.ignore) warnUnmatched(options2.ignore, kept.unmatched);
+  return kept.texts;
+}
+
 // src/commands/miro/stripHtml.ts
 var namedEntities = {
   amp: "&",
@@ -23033,6 +23172,58 @@ function normaliseItems(items2) {
   return items2.map(toItem);
 }
 
+// src/commands/miro/saveMiroExtract.ts
+function saveToRepo(key, extract2, repo, { cwd, globalConfigPath }) {
+  const result = applyRepoConfigSet(
+    key,
+    extract2,
+    typeof repo === "string" ? repo : void 0,
+    cwd,
+    globalConfigPath
+  );
+  if (!result.ok) throw new MiroExtractError(result.errors.join("\n"));
+  return `${globalConfigFileLabel(globalConfigPath)} under repos.${result.label}`;
+}
+function saveMiroExtract(name, extract2, options2, paths = {}) {
+  const resolved = {
+    cwd: paths.cwd ?? process.cwd(),
+    globalConfigPath: paths.globalConfigPath ?? getGlobalConfigPath()
+  };
+  if (options2.repo !== void 0 && !options2.global)
+    throw new MiroExtractError(
+      "--repo writes to the global config; add -g (e.g. -g --repo)"
+    );
+  const key = `miro.extracts.${name}`;
+  if (options2.repo !== void 0)
+    return saveToRepo(key, extract2, options2.repo, resolved);
+  const result = applyConfigSet(
+    key,
+    extract2,
+    options2.global ?? false,
+    resolved.cwd,
+    resolved.globalConfigPath
+  );
+  if (!result.ok) throw new MiroExtractError(result.errors.join("\n"));
+  return result.target === "global" ? globalConfigFileLabel(resolved.globalConfigPath) : projectConfigPathFrom(resolved.cwd);
+}
+
+// src/commands/miro/offerSaveExtract.ts
+async function extractName(options2) {
+  if (options2.save) return options2.save;
+  if (!process.stdin.isTTY) return void 0;
+  if (!await promptConfirm("Save this selection as a named extract?", false))
+    return void 0;
+  const name = (await promptInput("name", "Extract name")).trim();
+  return name === "" ? void 0 : name;
+}
+async function offerSaveExtract(extract2, options2, paths = {}) {
+  const name = await extractName(options2);
+  if (!name) return;
+  console.log(
+    `Saved extract "${name}" to ${saveMiroExtract(name, extract2, options2, paths)}`
+  );
+}
+
 // src/commands/miro/pickAnchors.ts
 import { randomUUID as randomUUID12 } from "crypto";
 
@@ -23072,23 +23263,6 @@ 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 readFileSync41 } from "fs";
 function tryParse(text18) {
@@ -23129,6 +23303,89 @@ function readMiroItems(file) {
   return items2;
 }
 
+// src/commands/miro/resolveExtractOptions.ts
+import chalk172 from "chalk";
+
+// src/commands/miro/extractLayers.ts
+function extractsIn(layer) {
+  const value = getNestedValue(layer, "miro.extracts");
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function extractLayers(layers, cwd, globalConfigPath) {
+  const globalFile = globalConfigFileLabel(globalConfigPath);
+  return [
+    { file: projectConfigPathFrom(cwd), extracts: extractsIn(layers.project) },
+    {
+      file: `${globalFile} under repos.${layers.repoKey}`,
+      extracts: extractsIn(layers.repoOverride)
+    },
+    { file: globalFile, extracts: extractsIn(layers.global) }
+  ];
+}
+function unknownExtract(name, layers) {
+  const names = [
+    ...new Set(layers.flatMap((layer) => Object.keys(layer.extracts)))
+  ].sort();
+  if (names.length === 0)
+    return `No extract named "${name}" is configured. Pick a rectangle with no anchor flags, then save it as "${name}".`;
+  return `No extract named "${name}" is configured. Configured extracts: ${names.join(", ")}.`;
+}
+
+// src/commands/miro/mergeExtractOptions.ts
+function mergeExtractOptions(options2, extract2, cwd) {
+  return {
+    ...options2,
+    board: options2.board ?? extract2.board,
+    frame: options2.frame ?? extract2.frame,
+    topLeft: options2.topLeft ?? extract2.topLeft,
+    bottomRight: options2.bottomRight ?? extract2.bottomRight,
+    items: options2.items ?? resolveExtractPath(extract2.items, cwd),
+    ignore: options2.ignore ?? resolveExtractPath(extract2.ignore, cwd),
+    out: options2.out ?? resolveExtractPath(extract2.out, cwd)
+  };
+}
+
+// src/commands/miro/parseExtract.ts
+function parseExtract(name, value) {
+  const parsed = miroExtractSchema.safeParse(value);
+  if (parsed.success) return parsed.data;
+  const issues = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+  throw new MiroExtractError(`Extract "${name}" is not valid: ${issues}`);
+}
+
+// src/commands/miro/resolveMiroExtract.ts
+function resolveMiroExtract(name, options2, cwd = process.cwd(), globalConfigPath = getGlobalConfigPath()) {
+  const byPrecedence = extractLayers(
+    readRawConfigLayers(cwd, globalConfigPath),
+    cwd,
+    globalConfigPath
+  );
+  const found = byPrecedence.filter((layer) => name in layer.extracts);
+  if (found.length === 0)
+    throw new MiroExtractError(unknownExtract(name, byPrecedence));
+  const merged = Object.assign(
+    {},
+    ...[...found].reverse().map((layer) => layer.extracts[name])
+  );
+  return {
+    options: mergeExtractOptions(options2, parseExtract(name, merged), cwd),
+    from: found.map((layer) => layer.file).join(" merged with ")
+  };
+}
+
+// src/commands/miro/resolveExtractOptions.ts
+function resolveExtractOptions(name, options2, paths) {
+  if (!name) return options2;
+  const resolved = resolveMiroExtract(
+    name,
+    options2,
+    paths.cwd,
+    paths.globalConfigPath
+  );
+  console.error(chalk172.dim(`Extract "${name}" from ${resolved.from}`));
+  return resolved.options;
+}
+
 // src/commands/miro/selectBoxes.ts
 function findAnchor(items2, id) {
   const anchor = items2.find((item) => item.id === id);
@@ -23156,31 +23413,6 @@ function selectBoxes(items2, topLeftId, bottomRightId) {
   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
 function requireItems(file) {
   if (!file)
@@ -23189,56 +23421,70 @@ function requireItems(file) {
     );
   return file;
 }
-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 raw = readMiroItems(requireItems(options2.items));
+async function runExtract(name, options2, paths = {}) {
+  const resolved = resolveExtractOptions(name, options2, paths);
+  const source = anchorSource(resolved);
+  const itemsFile = requireItems(resolved.items);
+  const raw = readMiroItems(itemsFile);
   const items2 = normaliseItems(raw);
   const [topLeft, bottomRight] = source.pick ? await pickAnchors(source.sessionId, items2) : [source.topLeft, source.bottomRight];
   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}`
-  );
+  const board = boardSource(raw, topLeft, resolved);
+  emitExtract(
+    resolved.out,
+    { ...board, topLeft, bottomRight, rect: selection.rect },
+    keptTexts(resolved, selection.boxes)
+  );
+  if (source.pick || resolved.save)
+    await offerSaveExtract(
+      extractToSave(
+        { options: resolved, items: itemsFile, topLeft, bottomRight, ...board },
+        paths.cwd
+      ),
+      resolved,
+      paths
+    );
 }
 
 // src/commands/miro/registerMiro.ts
 function registerMiro(program2) {
   const miroCommand = program2.command("miro").description("Miro board utilities");
-  miroCommand.command("extract").description("Print the text of every box inside a rectangle on a board").option("--items <file>", "File of raw board_list_items response pages").option(
+  const extract2 = miroCommand.command("extract").description("Print the text of every box inside a rectangle on a board").argument(
+    "[name]",
+    "Named extract from config supplying every field; any flag overrides its field"
+  ).option("--items <file>", "File of raw board_list_items response pages").option(
     "--top-left <id>",
     "Widget id or ?moveToWidget=<id> link of the top-left box (omit both anchors to pick them in the assist web UI)"
   ).option(
     "--bottom-right <id>",
     "Widget id or ?moveToWidget=<id> link of the bottom-right box"
-  ).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);
+  ).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").option(
+    "--board <id>",
+    "Board id for the --out header (else read from the items)"
+  ).option(
+    "--frame <id>",
+    "Frame id for the --out header (else read from the items)"
+  ).option(
+    "--save <name>",
+    "Save the selection as this named extract without asking"
+  ).option("-g, --global", "Save the extract to global ~/.assist.yml").option(
+    "-r, --repo [name]",
+    "Requires -g: scope the saved extract to a repo's identity (defaults to the current repo)"
+  ).action(
+    (name, options2) => runExtract(name, options2)
+  );
+  configHelp(
+    extract2,
+    miroConfigHelp,
+    "Paths in a saved extract are resolved from the repo root."
+  );
 }
 
 // src/commands/netcap/netcap.ts
 import { mkdir as mkdir4 } from "fs/promises";
 import { createServer as createServer2 } from "http";
 import { dirname as dirname29 } from "path";
-import chalk173 from "chalk";
+import chalk174 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
 var corsHeaders = {
@@ -23317,7 +23563,7 @@ 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 chalk172 from "chalk";
+import chalk173 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
 import { dirname as dirname28, join as join57 } from "path";
@@ -23361,7 +23607,7 @@ async function prepareExtensionForLoad(port, filter = "") {
   const host = lanIPv4();
   if (!host) {
     console.log(
-      chalk172.yellow("could not determine the WSL IP for the extension")
+      chalk173.yellow("could not determine the WSL IP for the extension")
     );
     await configureBackground(source, "127.0.0.1", port, filter);
     return source;
@@ -23372,14 +23618,14 @@ async function prepareExtensionForLoad(port, filter = "") {
     return WSL_WINDOWS_PATH;
   } catch {
     console.log(
-      chalk172.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
+      chalk173.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
     );
     return source;
   }
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute as isAbsolute3, join as join60, resolve as resolve17 } from "path";
+import { isAbsolute as isAbsolute4, join as join60, resolve as resolve18 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
 import { homedir as homedir20 } from "os";
@@ -23391,7 +23637,7 @@ function defaultCapturePath() {
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
-  const dir = isAbsolute3(out) ? out : resolve17(process.cwd(), out);
+  const dir = isAbsolute4(out) ? out : resolve18(process.cwd(), out);
   return join60(dir, "capture.jsonl");
 }
 
@@ -23405,30 +23651,30 @@ async function netcap(options2) {
   let count8 = 0;
   const handler = createNetcapHandler({
     outPath,
-    onPing: () => console.log(chalk173.dim("ping from extension")),
+    onPing: () => console.log(chalk174.dim("ping from extension")),
     onCapture: (entry) => {
       count8 += 1;
       console.log(
-        chalk173.green(`captured #${count8}`),
-        chalk173.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
+        chalk174.green(`captured #${count8}`),
+        chalk174.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
       );
     }
   });
   const server = createServer2(handler);
   server.listen(port, () => {
     console.log(
-      chalk173.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
+      chalk174.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
     );
-    console.log(chalk173.dim(`appending captures to ${outPath}`));
+    console.log(chalk174.dim(`appending captures to ${outPath}`));
     if (filter)
-      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"));
+      console.log(chalk174.dim(`forwarding only URLs matching "${filter}"`));
+    console.log(chalk174.dim(`load the unpacked extension from ${extensionPath}`));
+    console.log(chalk174.dim("press Ctrl-C to stop"));
   });
   process.on("SIGINT", () => {
     server.close();
     console.log(
-      chalk173.bold(
+      chalk174.bold(
         `
 netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} to ${outPath}`
       )
@@ -23440,7 +23686,7 @@ netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} t
 // src/commands/netcap/netcapExtract.ts
 import { writeFileSync as writeFileSync34 } from "fs";
 import { join as join61 } from "path";
-import chalk174 from "chalk";
+import chalk175 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
 import { readFileSync as readFileSync42 } from "fs";
@@ -23482,25 +23728,25 @@ function isVisibleText(t) {
   return /[a-zA-Z]{3,}/.test(t);
 }
 var isHashtag = (t) => /^#[A-Za-z0-9_]+$/.test(t);
-function collectRscText(v, resolve24, sink2, seen) {
+function collectRscText(v, resolve25, sink2, seen) {
   if (v == null) return;
   if (typeof v === "string") {
     if (isRscRef(v)) {
       if (!seen.has(v)) {
         seen.add(v);
-        collectRscText(resolve24(v), resolve24, sink2, seen);
+        collectRscText(resolve25(v), resolve25, sink2, seen);
       }
     } else if (isHashtag(v)) sink2.hashtags.push(v);
     else if (isVisibleText(v)) sink2.text.push(v);
     return;
   }
   if (Array.isArray(v)) {
-    for (const x of v) collectRscText(x, resolve24, sink2, seen);
+    for (const x of v) collectRscText(x, resolve25, sink2, seen);
     return;
   }
   if (typeof v === "object") {
     for (const val of Object.values(v)) {
-      collectRscText(val, resolve24, sink2, seen);
+      collectRscText(val, resolve25, sink2, seen);
     }
   }
 }
@@ -23532,7 +23778,7 @@ function visitObjects(root, fn) {
     }
   }
 }
-function buildMentionMap(rows, resolve24) {
+function buildMentionMap(rows, resolve25) {
   const map = /* @__PURE__ */ new Map();
   visitObjects(rows, (o) => {
     const url = profileActionUrl(o);
@@ -23540,7 +23786,7 @@ function buildMentionMap(rows, resolve24) {
     const slug = slugFromProfileUrl(url);
     if (!slug || map.has(slug)) return;
     const sink2 = { text: [], hashtags: [] };
-    collectRscText(o.children, resolve24, sink2, /* @__PURE__ */ new Set());
+    collectRscText(o.children, resolve25, sink2, /* @__PURE__ */ new Set());
     const name = sink2.text.join(" ").replace(/\s+/g, " ").trim();
     map.set(slug, name ? { slug, name, url } : { slug, url });
   });
@@ -23626,10 +23872,10 @@ function buildPost(raw, mentionMap, author) {
 
 // src/commands/netcap/walkPostRow.ts
 var isCommentary = (o) => asObject(o.viewTrackingSpecs)?.viewName === "feed-commentary";
-function walkPostRow(v, resolve24, raw) {
+function walkPostRow(v, resolve25, raw) {
   if (v == null || typeof v !== "object") return;
   if (Array.isArray(v)) {
-    for (const x of v) walkPostRow(x, resolve24, raw);
+    for (const x of v) walkPostRow(x, resolve25, raw);
     return;
   }
   const o = v;
@@ -23643,9 +23889,9 @@ function walkPostRow(v, resolve24, raw) {
   }
   if (isCommentary(o)) {
     const sink2 = { text: raw.text, hashtags: raw.hashtags };
-    collectRscText(o.children, resolve24, sink2, /* @__PURE__ */ new Set());
+    collectRscText(o.children, resolve25, sink2, /* @__PURE__ */ new Set());
   }
-  for (const val of Object.values(o)) walkPostRow(val, resolve24, raw);
+  for (const val of Object.values(o)) walkPostRow(val, resolve25, raw);
 }
 
 // src/commands/netcap/extractLinkedInPosts.ts
@@ -23659,8 +23905,8 @@ function findCommentaryRows(rows) {
 }
 function extractLinkedInPosts(flight, author = findAuthorSlug(flight)) {
   const rows = parseRscRows(flight);
-  const resolve24 = makeRscResolver(rows);
-  const mentionMap = buildMentionMap(rows, resolve24);
+  const resolve25 = makeRscResolver(rows);
+  const mentionMap = buildMentionMap(rows, resolve25);
   const posts = [];
   for (const id of findCommentaryRows(rows)) {
     const raw = {
@@ -23670,7 +23916,7 @@ function extractLinkedInPosts(flight, author = findAuthorSlug(flight)) {
       links: [],
       related: []
     };
-    walkPostRow(rows[id], resolve24, raw);
+    walkPostRow(rows[id], resolve25, raw);
     const post = buildPost(raw, mentionMap, author);
     if (post) posts.push(post);
   }
@@ -23888,8 +24134,8 @@ function netcapExtract(file) {
   writeFileSync34(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
-    chalk174.green(`extracted ${posts.length} posts`),
-    chalk174.dim(`-> ${outFile}`)
+    chalk175.green(`extracted ${posts.length} posts`),
+    chalk175.dim(`-> ${outFile}`)
   );
 }
 
@@ -23910,7 +24156,7 @@ function registerNetcap(program2) {
 }
 
 // src/commands/news/add/index.ts
-import chalk175 from "chalk";
+import chalk176 from "chalk";
 import enquirer8 from "enquirer";
 async function add2(url) {
   if (!url) {
@@ -23932,10 +24178,10 @@ async function add2(url) {
   const { orm } = await getReady();
   const added = await addFeed(orm, url);
   if (!added) {
-    console.log(chalk175.yellow("Feed already exists"));
+    console.log(chalk176.yellow("Feed already exists"));
     return;
   }
-  console.log(chalk175.green(`Added feed: ${url}`));
+  console.log(chalk176.green(`Added feed: ${url}`));
 }
 
 // src/commands/registerNews.ts
@@ -23982,7 +24228,7 @@ function registerPiHook(program2) {
 }
 
 // src/commands/prompts/printPromptsTable.ts
-import chalk176 from "chalk";
+import chalk177 from "chalk";
 function truncate(str, max) {
   if (str.length <= max) return str;
   return `${str.slice(0, max - 1)}\u2026`;
@@ -24000,14 +24246,14 @@ function printPromptsTable(rows) {
     "Command".padEnd(commandWidth),
     "Repos"
   ].join("  ");
-  console.log(chalk176.dim(header));
-  console.log(chalk176.dim("-".repeat(header.length)));
+  console.log(chalk177.dim(header));
+  console.log(chalk177.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(
-      `${chalk176.yellow(count8)}  ${tool}  ${command}  ${chalk176.dim(row.repos)}`
+      `${chalk177.yellow(count8)}  ${tool}  ${command}  ${chalk177.dim(row.repos)}`
     );
   }
 }
@@ -24674,13 +24920,13 @@ function agentFooter(unresolvedCount) {
 }
 
 // src/commands/prs/listComments/commentStyle.ts
-import chalk177 from "chalk";
+import chalk178 from "chalk";
 var plain = (text18) => text18;
 function colouredState(state) {
   const label2 = `[${state}]`;
-  if (state === "APPROVED") return chalk177.green(label2);
-  if (state === "CHANGES_REQUESTED") return chalk177.red(label2);
-  return chalk177.yellow(label2);
+  if (state === "APPROVED") return chalk178.green(label2);
+  if (state === "CHANGES_REQUESTED") return chalk178.red(label2);
+  return chalk178.yellow(label2);
 }
 function commentStyle() {
   if (isClaudeCode()) {
@@ -24694,9 +24940,9 @@ function commentStyle() {
     };
   }
   return {
-    cyan: chalk177.cyan,
-    bold: chalk177.bold,
-    dim: chalk177.dim,
+    cyan: chalk178.cyan,
+    bold: chalk178.bold,
+    dim: chalk178.dim,
     state: colouredState,
     diffHunk: true,
     agent: false
@@ -24866,13 +25112,13 @@ import { execSync as execSync48 } from "child_process";
 import enquirer9 from "enquirer";
 
 // src/commands/prs/prs/displayPaginated/printPr.ts
-import chalk178 from "chalk";
+import chalk179 from "chalk";
 var STATUS_MAP = {
-  MERGED: (pr) => pr.mergedAt ? { label: chalk178.magenta("merged"), date: pr.mergedAt } : null,
-  CLOSED: (pr) => pr.closedAt ? { label: chalk178.red("closed"), date: pr.closedAt } : null
+  MERGED: (pr) => pr.mergedAt ? { label: chalk179.magenta("merged"), date: pr.mergedAt } : null,
+  CLOSED: (pr) => pr.closedAt ? { label: chalk179.red("closed"), date: pr.closedAt } : null
 };
 function defaultStatus(pr) {
-  return { label: chalk178.green("opened"), date: pr.createdAt };
+  return { label: chalk179.green("opened"), date: pr.createdAt };
 }
 function getStatus2(pr) {
   return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -24881,11 +25127,11 @@ function formatDate(dateStr) {
   return new Date(dateStr).toISOString().split("T")[0];
 }
 function formatPrHeader(pr, status3) {
-  return `${chalk178.cyan(`#${pr.number}`)} ${pr.title} ${chalk178.dim(`(${pr.author.login},`)} ${status3.label} ${chalk178.dim(`${formatDate(status3.date)})`)}`;
+  return `${chalk179.cyan(`#${pr.number}`)} ${pr.title} ${chalk179.dim(`(${pr.author.login},`)} ${status3.label} ${chalk179.dim(`${formatDate(status3.date)})`)}`;
 }
 function logPrDetails(pr) {
   console.log(
-    chalk178.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
+    chalk179.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
   console.log();
 }
@@ -25114,7 +25360,7 @@ function parseIncoming(line, type) {
   }
 }
 function requestSession(message3) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     connectToDaemon().then((socket) => {
       let settled = false;
       const finish = (error, sessionId) => {
@@ -25122,7 +25368,7 @@ function requestSession(message3) {
         settled = true;
         socket.destroy();
         if (error) reject(error);
-        else resolve24(sessionId);
+        else resolve25(sessionId);
       };
       readSocketLines(socket, (line) => {
         const incoming = parseIncoming(line, message3.type);
@@ -25600,10 +25846,10 @@ function registerPrs(program2) {
 }
 
 // src/commands/ravendb/ravendbAuth.ts
-import chalk184 from "chalk";
+import chalk185 from "chalk";
 
 // src/shared/createConnectionAuth.ts
-import chalk179 from "chalk";
+import chalk180 from "chalk";
 function listConnections(connections, format) {
   if (connections.length === 0) {
     console.log("No connections configured.");
@@ -25616,7 +25862,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(chalk179.red(`Connection "${name}" not found.`));
+    console.error(chalk180.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   save(filtered);
@@ -25662,15 +25908,15 @@ function saveConnections(connections) {
 }
 
 // src/commands/ravendb/promptConnection.ts
-import chalk182 from "chalk";
+import chalk183 from "chalk";
 
 // src/commands/ravendb/selectOpSecret.ts
-import chalk181 from "chalk";
+import chalk182 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
 import { execSync as execSync51 } from "child_process";
-import chalk180 from "chalk";
+import chalk181 from "chalk";
 function opExec(args) {
   return execSync51(`op ${args}`, {
     encoding: "utf8",
@@ -25683,7 +25929,7 @@ function searchItems(search2) {
     items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
-      chalk180.red(
+      chalk181.red(
         "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
       )
     );
@@ -25697,7 +25943,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(chalk180.red("Failed to get item details from 1Password."));
+    console.error(chalk181.red("Failed to get item details from 1Password."));
     process.exit(1);
   }
 }
@@ -25716,7 +25962,7 @@ async function selectOpSecret(searchTerm) {
   }).run();
   const items2 = searchItems(search2);
   if (items2.length === 0) {
-    console.error(chalk181.red(`No items found matching "${search2}".`));
+    console.error(chalk182.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId2 = await selectOne(
@@ -25725,7 +25971,7 @@ async function selectOpSecret(searchTerm) {
   );
   const fields = getItemFields(itemId2);
   if (fields.length === 0) {
-    console.error(chalk181.red("No fields with references found on this item."));
+    console.error(chalk182.red("No fields with references found on this item."));
     process.exit(1);
   }
   const ref = await selectOne(
@@ -25739,7 +25985,7 @@ async function selectOpSecret(searchTerm) {
 async function promptConnection(existingNames) {
   const name = await promptInput("name", "Connection name:");
   if (existingNames.includes(name)) {
-    console.error(chalk182.red(`Connection "${name}" already exists.`));
+    console.error(chalk183.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput(
@@ -25748,22 +25994,22 @@ async function promptConnection(existingNames) {
   );
   const database = await promptInput("database", "Database name:");
   if (!name || !url || !database) {
-    console.error(chalk182.red("All fields are required."));
+    console.error(chalk183.red("All fields are required."));
     process.exit(1);
   }
   const apiKeyRef = await selectOpSecret();
-  console.log(chalk182.dim(`Using: ${apiKeyRef}`));
+  console.log(chalk183.dim(`Using: ${apiKeyRef}`));
   return { name, url, database, apiKeyRef };
 }
 
 // src/commands/ravendb/ravendbSetConnection.ts
-import chalk183 from "chalk";
+import chalk184 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(chalk183.red(`Connection "${name}" not found.`));
+    console.error(chalk184.red(`Connection "${name}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -25779,16 +26025,16 @@ function ravendbSetConnection(name) {
 var ravendbAuth = createConnectionAuth({
   load: loadConnections,
   save: saveConnections,
-  format: (c) => `${chalk184.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
+  format: (c) => `${chalk185.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
   promptNew: promptConnection,
   onFirst: (c) => ravendbSetConnection(c.name)
 });
 
 // src/commands/ravendb/ravendbCollections.ts
-import chalk188 from "chalk";
+import chalk189 from "chalk";
 
 // src/commands/ravendb/ravenFetch.ts
-import chalk186 from "chalk";
+import chalk187 from "chalk";
 
 // src/commands/ravendb/getAccessToken.ts
 var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -25825,10 +26071,10 @@ ${errorText}`
 
 // src/commands/ravendb/resolveOpSecret.ts
 import { execSync as execSync52 } from "child_process";
-import chalk185 from "chalk";
+import chalk186 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
-    console.error(chalk185.red(`Invalid secret reference: must start with op://`));
+    console.error(chalk186.red(`Invalid secret reference: must start with op://`));
     process.exit(1);
   }
   try {
@@ -25838,7 +26084,7 @@ function resolveOpSecret(reference) {
     }).trim();
   } catch {
     console.error(
-      chalk185.red(
+      chalk186.red(
         "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
       )
     );
@@ -25865,7 +26111,7 @@ async function ravenFetch(connection, path80) {
   if (!response.ok) {
     const body = await response.text();
     console.error(
-      chalk186.red(`RavenDB error: ${response.status} ${response.statusText}`)
+      chalk187.red(`RavenDB error: ${response.status} ${response.statusText}`)
     );
     console.error(body.substring(0, 500));
     process.exit(1);
@@ -25874,7 +26120,7 @@ async function ravenFetch(connection, path80) {
 }
 
 // src/commands/ravendb/resolveConnection.ts
-import chalk187 from "chalk";
+import chalk188 from "chalk";
 function loadRavendb() {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb;
@@ -25888,7 +26134,7 @@ function resolveConnection(name) {
   const connectionName = name ?? defaultConnection;
   if (!connectionName) {
     console.error(
-      chalk187.red(
+      chalk188.red(
         "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
       )
     );
@@ -25896,7 +26142,7 @@ function resolveConnection(name) {
   }
   const connection = connections.find((c) => c.name === connectionName);
   if (!connection) {
-    console.error(chalk187.red(`Connection "${connectionName}" not found.`));
+    console.error(chalk188.red(`Connection "${connectionName}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -25927,15 +26173,15 @@ async function ravendbCollections(connectionName) {
     return;
   }
   for (const c of collections) {
-    console.log(`${chalk188.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+    console.log(`${chalk189.bold(c.Name)}  ${c.CountOfDocuments} docs`);
   }
 }
 
 // src/commands/ravendb/ravendbQuery.ts
-import chalk190 from "chalk";
+import chalk191 from "chalk";
 
 // src/commands/ravendb/fetchAllPages.ts
-import chalk189 from "chalk";
+import chalk190 from "chalk";
 
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
@@ -25973,7 +26219,7 @@ async function fetchAllPages(connection, opts) {
     allResults.push(...results);
     start3 += results.length;
     process.stderr.write(
-      `\r${chalk189.dim(`Fetched ${allResults.length}/${totalResults}`)}`
+      `\r${chalk190.dim(`Fetched ${allResults.length}/${totalResults}`)}`
     );
     if (start3 >= totalResults) break;
     if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
@@ -25988,7 +26234,7 @@ async function fetchAllPages(connection, opts) {
 async function ravendbQuery(connectionName, collection, options2) {
   const resolved = resolveArgs(connectionName, collection);
   if (!resolved.collection && !options2.query) {
-    console.error(chalk190.red("Provide a collection name or --query filter."));
+    console.error(chalk191.red("Provide a collection name or --query filter."));
     process.exit(1);
   }
   const { collection: col } = resolved;
@@ -26027,7 +26273,7 @@ import { spawn as spawn6 } from "child_process";
 import * as path42 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk191 from "chalk";
+import chalk192 from "chalk";
 var DEFAULT_MAX_LINES2 = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
   if (violations.length === 0) {
@@ -26036,43 +26282,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
     }
     return;
   }
-  console.error(chalk191.red(`
+  console.error(chalk192.red(`
 Refactor check failed:
 `));
-  console.error(chalk191.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk192.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk191.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk192.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk191.yellow(
+    chalk192.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk191.gray(`    assist refactor ignore <file>
+  console.error(chalk192.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk191.cyan(`
+    console.error(chalk192.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk191.cyan(
+      chalk192.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk191.cyan(
+      chalk192.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(
-      chalk191.cyan(
+      chalk192.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -26170,7 +26416,7 @@ function getViolations(pattern2, options2 = {}, maxLines = DEFAULT_MAX_LINES2) {
 
 // src/commands/refactor/check/index.ts
 function runScript(script, cwd) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     const child = spawn6("npm", ["run", script], {
       stdio: "pipe",
       shell: true,
@@ -26184,7 +26430,7 @@ function runScript(script, cwd) {
       output += data.toString();
     });
     child.on("close", (code) => {
-      resolve24({ script, code: code ?? 1, output });
+      resolve25({ script, code: code ?? 1, output });
     });
   });
 }
@@ -26228,7 +26474,7 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/extract/index.ts
 import path50 from "path";
-import chalk194 from "chalk";
+import chalk195 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
@@ -26827,23 +27073,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 
 // src/commands/refactor/extract/displayPlan.ts
 import path46 from "path";
-import chalk192 from "chalk";
+import chalk193 from "chalk";
 function section2(title) {
   return `
-  ${chalk192.cyan(title)}`;
+  ${chalk193.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(`    ${chalk192.dim(rel)}: \u2192 import from "${imp.relPath}"`);
+    console.log(`    ${chalk193.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
 function displayPlan(functionName, relDest, plan2, cwd) {
-  console.log(chalk192.bold(`Extract: ${functionName} \u2192 ${relDest}
+  console.log(chalk193.bold(`Extract: ${functionName} \u2192 ${relDest}
 `));
-  console.log(`  ${chalk192.cyan("Functions to move:")}`);
+  console.log(`  ${chalk193.cyan("Functions to move:")}`);
   for (const name of plan2.extractedNames) {
     console.log(`    ${name}`);
   }
@@ -26877,7 +27123,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import path49 from "path";
-import chalk193 from "chalk";
+import chalk194 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
@@ -26969,7 +27215,7 @@ function loadProjectFile(file) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk193.red(`File not found in project: ${file}`));
+    console.log(chalk194.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   return { project, sourceFile };
@@ -26992,19 +27238,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(chalk194.green("\nExtraction complete"));
+    console.log(chalk195.green("\nExtraction complete"));
   } else {
-    console.log(chalk194.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk195.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/ignore.ts
 import fs33 from "fs";
-import chalk195 from "chalk";
+import chalk196 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore2(file) {
   if (!fs33.existsSync(file)) {
-    console.error(chalk195.red(`Error: File does not exist: ${file}`));
+    console.error(chalk196.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs33.readFileSync(file, "utf8");
@@ -27020,7 +27266,7 @@ function ignore2(file) {
     fs33.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk195.green(
+    chalk196.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -27029,12 +27275,12 @@ function ignore2(file) {
 // src/commands/refactor/rename/index.ts
 import fs36 from "fs";
 import path55 from "path";
-import chalk198 from "chalk";
+import chalk199 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs35 from "fs";
 import path52 from "path";
-import chalk196 from "chalk";
+import chalk197 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
 import path51 from "path";
@@ -27139,13 +27385,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs35.writeFileSync(file, content, "utf8");
-    console.log(chalk196.cyan(`  Updated imports in ${path52.relative(cwd, file)}`));
+    console.log(chalk197.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(
-    chalk196.white(
+    chalk197.white(
       `  Moved ${path52.relative(cwd, sourcePath)} \u2192 ${path52.relative(cwd, destPath)}`
     )
   );
@@ -27232,16 +27478,16 @@ function computeRenameRewrites(sourcePath, destPath) {
 
 // src/commands/refactor/rename/printRenamePreview.ts
 import path54 from "path";
-import chalk197 from "chalk";
+import chalk198 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
-      chalk197.dim(
+      chalk198.dim(
         `  ${path54.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
-  console.log(chalk197.dim("Dry run. Use --apply to execute."));
+  console.log(chalk198.dim("Dry run. Use --apply to execute."));
 }
 
 // src/commands/refactor/rename/index.ts
@@ -27252,20 +27498,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(chalk198.red(`File not found: ${source}`));
+    console.log(chalk199.red(`File not found: ${source}`));
     process.exit(1);
   }
   if (destPath !== sourcePath && fs36.existsSync(destPath)) {
-    console.log(chalk198.red(`Destination already exists: ${destination}`));
+    console.log(chalk199.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
-  console.log(chalk198.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  console.log(chalk198.dim("Loading project..."));
-  console.log(chalk198.dim("Scanning imports across the project..."));
+  console.log(chalk199.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk199.dim("Loading project..."));
+  console.log(chalk199.dim("Scanning imports across the project..."));
   const rewrites = computeRenameRewrites(sourcePath, destPath);
   const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
   console.log(
-    chalk198.dim(
+    chalk199.dim(
       `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
     )
   );
@@ -27274,11 +27520,11 @@ async function rename(source, destination, options2 = {}) {
     return;
   }
   applyRename(rewrites, sourcePath, destPath, cwd);
-  console.log(chalk198.green("Done"));
+  console.log(chalk199.green("Done"));
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import chalk199 from "chalk";
+import chalk200 from "chalk";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
 import { SyntaxKind as SyntaxKind15 } from "ts-morph";
@@ -27324,33 +27570,33 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const { project, sourceFile } = loadProjectFile(file);
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk199.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk200.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(
-    chalk199.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk200.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines2] of grouped) {
     console.log(
-      `  ${chalk199.dim(refFile)}: lines ${chalk199.cyan(lines2.join(", "))}`
+      `  ${chalk200.dim(refFile)}: lines ${chalk200.cyan(lines2.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk199.green(`
+    console.log(chalk200.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk199.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk200.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
 import path63 from "path";
-import chalk202 from "chalk";
+import chalk203 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
 import path57 from "path";
@@ -27429,50 +27675,50 @@ function clusterFiles(graph) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path59 from "path";
-import chalk200 from "chalk";
+import chalk201 from "chalk";
 function relPath(filePath) {
   return path59.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk200.bold("\nFile moves:"));
+  console.log(chalk201.bold("\nFile moves:"));
   for (const move2 of plan2.moves) {
     console.log(
-      `  ${chalk200.red(relPath(move2.from))} \u2192 ${chalk200.green(relPath(move2.to))}`
+      `  ${chalk201.red(relPath(move2.from))} \u2192 ${chalk201.green(relPath(move2.to))}`
     );
-    console.log(chalk200.dim(`    ${move2.reason}`));
+    console.log(chalk201.dim(`    ${move2.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk200.bold(`
+  console.log(chalk201.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk200.cyan(relPath(file))}:`);
+    console.log(`  ${chalk201.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk200.red(`"${oldSpecifier}"`)} \u2192 ${chalk200.green(`"${newSpecifier}"`)}`
+        `    ${chalk201.red(`"${oldSpecifier}"`)} \u2192 ${chalk201.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk200.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk200.yellow(`  ${w}`));
+    console.log(chalk201.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk201.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk200.bold("\nNew directories:"));
+    console.log(chalk201.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk200.green(`  ${dir}/`));
+      console.log(chalk201.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk200.dim(
+    chalk201.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -27482,18 +27728,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 chalk201 from "chalk";
+import chalk202 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs37.writeFileSync(file, content, "utf8");
     console.log(
-      chalk201.cyan(`  Rewrote imports in ${path60.relative(process.cwd(), file)}`)
+      chalk202.cyan(`  Rewrote imports in ${path60.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs37.mkdirSync(dir, { recursive: true });
-    console.log(chalk201.green(`  Created ${path60.relative(process.cwd(), dir)}/`));
+    console.log(chalk202.green(`  Created ${path60.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
     const targetDir = path60.dirname(move2.to);
@@ -27502,7 +27748,7 @@ function executePlan(plan2) {
     }
     fs37.renameSync(move2.from, move2.to);
     console.log(
-      chalk201.white(
+      chalk202.white(
         `  Moved ${path60.relative(process.cwd(), move2.from)} \u2192 ${path60.relative(process.cwd(), move2.to)}`
       )
     );
@@ -27517,7 +27763,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs37.rmdirSync(dir);
       console.log(
-        chalk201.dim(
+        chalk202.dim(
           `  Removed empty directory ${path60.relative(process.cwd(), dir)}`
         )
       );
@@ -27650,22 +27896,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk202.yellow("No files found matching pattern"));
+    console.log(chalk203.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(chalk202.green("No restructuring needed"));
+    console.log(chalk203.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk202.bold("\nApplying changes..."));
+    console.log(chalk203.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk202.green("\nRestructuring complete"));
+    console.log(chalk203.green("\nRestructuring complete"));
   } else {
-    console.log(chalk202.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk203.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -28323,18 +28569,18 @@ function partitionFindingsByDiff(findings, index3) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk203 from "chalk";
+import chalk204 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk203.yellow(
+    chalk204.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(
-      `  ${chalk203.yellow("\xB7")} ${finding.title} ${chalk203.dim(
+      `  ${chalk204.yellow("\xB7")} ${finding.title} ${chalk204.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -28358,18 +28604,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk204 from "chalk";
+import chalk205 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk204.yellow(
+    chalk205.yellow(
       `Moved ${unlocated.length} finding(s) without a parseable file:line into the review body:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk204.dim("missing");
+    const where = finding.location || chalk205.dim("missing");
     console.warn(
-      `  ${chalk204.yellow("\xB7")} ${finding.title} ${chalk204.dim(`(${where})`)}`
+      `  ${chalk205.yellow("\xB7")} ${finding.title} ${chalk205.dim(`(${where})`)}`
     );
   }
 }
@@ -29135,12 +29381,12 @@ function onCloseResult(ctx, code) {
   return { ...closed, stderr: ctx.stderr.value, stdout: ctx.stdout.value };
 }
 function waitForChildExit(ctx) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     let settled = false;
     const settle = (result) => {
       if (settled) return;
       settled = true;
-      resolve24(result);
+      resolve25(result);
     };
     ctx.child.on("error", (err) => settle(onErrorResult(ctx, err)));
     ctx.child.on("close", (code) => settle(onCloseResult(ctx, code)));
@@ -29624,7 +29870,7 @@ function registerReview(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk206 from "chalk";
+import chalk207 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -29653,10 +29899,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk205 from "chalk";
+import chalk206 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk205.red(`Connection "${name}" already exists.`));
+    console.error(chalk206.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -29674,16 +29920,16 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk206.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk207.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk210 from "chalk";
+import chalk211 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk207 from "chalk";
+import chalk208 from "chalk";
 async function fetchSeq(conn, path80, params) {
   const url = `${conn.url}${path80}?${params}`;
   const response = await fetch(url, {
@@ -29694,7 +29940,7 @@ async function fetchSeq(conn, path80, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk207.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk208.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -29753,23 +29999,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk208 from "chalk";
+import chalk209 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk208.bgRed.white;
+      return chalk209.bgRed.white;
     case "Error":
-      return chalk208.red;
+      return chalk209.red;
     case "Warning":
-      return chalk208.yellow;
+      return chalk209.yellow;
     case "Information":
-      return chalk208.cyan;
+      return chalk209.cyan;
     case "Debug":
-      return chalk208.gray;
+      return chalk209.gray;
     case "Verbose":
-      return chalk208.dim;
+      return chalk209.dim;
     default:
-      return chalk208.white;
+      return chalk209.white;
   }
 }
 function levelAbbrev(level) {
@@ -29810,12 +30056,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk208.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk209.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(chalk208.red(`  ${line}`));
+      lines2.push(chalk209.red(`  ${line}`));
     }
   }
   return lines2.join("\n");
@@ -29848,11 +30094,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk209 from "chalk";
+import chalk210 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk209.red(
+      chalk210.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -29861,7 +30107,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(chalk209.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk210.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -29890,7 +30136,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count8) })
   );
   if (events.length === 0) {
-    console.log(chalk210.yellow("No events found."));
+    console.log(chalk211.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -29901,11 +30147,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk210.dim(`
+  console.log(chalk211.dim(`
 ${events.length} events`));
   if (events.length >= count8) {
     console.log(
-      chalk210.yellow(
+      chalk211.yellow(
         `Results limited to ${count8}. Use --count to retrieve more.`
       )
     );
@@ -29913,10 +30159,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk211 from "chalk";
+import chalk212 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk211.red(`Connection "${name}" not found.`));
+    console.error(chalk212.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -29965,7 +30211,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk213 from "chalk";
+import chalk214 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -29994,7 +30240,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk212 from "chalk";
+import chalk213 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -30002,7 +30248,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk212.red(`Invalid port "${portStr}".`));
+    console.error(chalk213.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -30015,13 +30261,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk213.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk214.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk214 from "chalk";
+import chalk215 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -30030,7 +30276,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk214.yellow("(no rows)"));
+    console.log(chalk215.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -30038,13 +30284,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(chalk214.dim(header));
-  console.log(chalk214.dim("-".repeat(header.length)));
+  console.log(chalk215.dim(header));
+  console.log(chalk215.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(chalk214.dim(`
+  console.log(chalk215.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -30104,7 +30350,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk215 from "chalk";
+import chalk216 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -30138,7 +30384,7 @@ function isMutation(sql25) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk215.red(
+      chalk216.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -30148,18 +30394,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk215.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk216.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk216 from "chalk";
+import chalk217 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk216.red(
+      chalk217.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -30174,7 +30420,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk216.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk217.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -30319,7 +30565,7 @@ function reportPrune(label2, result, force) {
 // src/commands/sync/syncClaudeMd.ts
 import * as fs41 from "fs";
 import * as path66 from "path";
-import chalk217 from "chalk";
+import chalk218 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path66.join(claudeDir, "CLAUDE.md");
   const target = path66.join(targetBase, "CLAUDE.md");
@@ -30328,14 +30574,14 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
     const targetContent = fs41.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk217.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk218.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       if (!options2?.yes) {
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk217.red("Overwrite existing CLAUDE.md?"),
+          chalk218.red("Overwrite existing CLAUDE.md?"),
           false
         );
         if (!confirm) {
@@ -30568,7 +30814,7 @@ function syncPi(claudeDir, options2) {
 // src/commands/sync/syncSettings.ts
 import * as fs47 from "fs";
 import * as path73 from "path";
-import chalk218 from "chalk";
+import chalk219 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path73.join(claudeDir, "settings.json");
   const target = path73.join(targetBase, "settings.json");
@@ -30587,7 +30833,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk218.yellow(
+          chalk219.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
@@ -30595,7 +30841,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
         printDiff(targetContent, mergedContent);
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk218.red("Overwrite existing settings.json?"),
+          chalk219.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -30675,9 +30921,9 @@ function createReadlineInterface() {
   });
 }
 function askQuestion(rl, question) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     rl.question(question, (answer) => {
-      resolve24(answer.trim());
+      resolve25(answer.trim());
     });
   });
 }
@@ -31725,7 +31971,7 @@ function resolveParams(params, cliArgs) {
 
 // src/commands/run/resolveRunCwd.ts
 import { existsSync as existsSync69 } from "fs";
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 var MissingRunCwdError = class extends Error {
   constructor(runName, cwd) {
     super(`run config "${runName}": cwd ${cwd} does not exist`);
@@ -31736,7 +31982,7 @@ var MissingRunCwdError = class extends Error {
 };
 function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
   if (!config.cwd) return void 0;
-  const cwd = resolve18(baseDir, config.cwd);
+  const cwd = resolve19(baseDir, config.cwd);
   if (!existsSync69(cwd)) throw new MissingRunCwdError(config.name, cwd);
   return cwd;
 }
@@ -31748,12 +31994,12 @@ import { existsSync as existsSync71 } from "fs";
 // src/commands/run/resolveCommand.ts
 import { execFileSync as execFileSync16 } from "child_process";
 import { existsSync as existsSync70 } from "fs";
-import { dirname as dirname36, join as join85, resolve as resolve19 } from "path";
+import { dirname as dirname36, join as join85, resolve as resolve20 } 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(dirname36(gitPath), "..");
+    const gitRoot = resolve20(dirname36(gitPath), "..");
     const gitBash = join85(gitRoot, "bin", "bash.exe");
     if (existsSync70(gitBash)) return gitBash;
   } catch {
@@ -31909,7 +32155,7 @@ function readMovement(cwd) {
 // src/commands/watch/pollForMovement.ts
 function pollForMovement(options2) {
   const { upstream, intervalMs, timeoutMs, timeout, cwd } = options2;
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     let settled = false;
     const finish = (outcome) => {
       if (settled) return;
@@ -31917,7 +32163,7 @@ function pollForMovement(options2) {
       clearInterval(ticker);
       clearTimeout(deadline);
       process.off("SIGINT", onInterrupt);
-      resolve24(outcome);
+      resolve25(outcome);
     };
     const onInterrupt = () => finish({ kind: "interrupted" });
     const ticker = setInterval(() => {
@@ -32022,7 +32268,7 @@ function registerWatch(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk219 from "chalk";
+import chalk220 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -32043,7 +32289,7 @@ function extractCode(url, expectedState) {
   return code;
 }
 function waitForCallback(port, expectedState) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     const timeout = setTimeout(() => {
       server.close();
       reject(new Error("Authorization timed out after 120 seconds"));
@@ -32060,7 +32306,7 @@ function waitForCallback(port, expectedState) {
         const code = extractCode(url, expectedState);
         respondHtml(res, 200, "Authorization successful!");
         server.close();
-        resolve24(code);
+        resolve25(code);
       } catch (error) {
         respondHtml(res, 400, error.message);
         server.close();
@@ -32153,13 +32399,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk219.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk220.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  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..."));
+  console.log(chalk220.white("http://localhost:14523/callback\n"));
+  console.log(chalk220.blue("Opening browser for authorization..."));
+  console.log(chalk220.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk219.dim("Exchanging code for tokens..."));
+  console.log(chalk220.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -32175,7 +32421,7 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk219.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk220.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
@@ -32525,8 +32771,8 @@ function registerRun(program2) {
 import { execSync as execSync60 } from "child_process";
 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 chalk220 from "chalk";
+import { join as join89, resolve as resolve21 } from "path";
+import chalk221 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -32659,7 +32905,7 @@ function buildOutputPath(outputDir, processName) {
     mkdirSync32(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return resolve20(outputDir, `${processName}-${timestamp6}.png`);
+  return resolve21(outputDir, `${processName}-${timestamp6}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
   const scriptPath = join89(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
@@ -32675,15 +32921,15 @@ function runPowerShellScript(processName, outputPath) {
 }
 function screenshot(processName) {
   const config = loadConfig();
-  const outputDir = resolve20(config.screenshot.outputDir);
+  const outputDir = resolve21(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk220.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk221.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk220.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk221.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk220.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk221.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -32708,10 +32954,10 @@ var STATUS_TIMEOUT_MS = 5e3;
 function queryDaemon(socket) {
   socket.write(`${JSON.stringify({ type: "ping" })}
 `);
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     const result = { sessions: [] };
     const pending = /* @__PURE__ */ new Set(["sessions", "pong"]);
-    const timer = setTimeout(() => resolve24(result), STATUS_TIMEOUT_MS);
+    const timer = setTimeout(() => resolve25(result), STATUS_TIMEOUT_MS);
     const lines2 = createInterface6({ input: socket });
     lines2.on("error", () => {
     });
@@ -32719,7 +32965,7 @@ function queryDaemon(socket) {
       applyLine(result, pending, line);
       if (pending.size === 0) {
         clearTimeout(timer);
-        resolve24(result);
+        resolve25(result);
       }
     });
   });
@@ -32815,11 +33061,11 @@ function clearPersistedSessionsOnDrain() {
 
 // src/commands/sessions/daemon/readDaemonMessage.ts
 function readDaemonMessage(lines2, timeoutMs, fallback, match) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     const finish = (value) => {
       clearTimeout(timer);
       lines2.off("line", onLine);
-      resolve24(value);
+      resolve25(value);
     };
     const timer = setTimeout(() => finish(fallback), timeoutMs);
     const onLine = (line) => {
@@ -34171,7 +34417,7 @@ function emitSessionOutput(session, clients, data) {
 
 // src/commands/sessions/daemon/exitReason.ts
 import { existsSync as existsSync80 } from "fs";
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } from "path";
 function exitDetail(session) {
   if (session.cwd && !existsSync80(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
@@ -34186,7 +34432,7 @@ function missingRunConfigCwd(session) {
   const dir = session.cwd ?? process.cwd();
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
-  const configured = resolve21(runConfigBaseDirFrom(dir), config.cwd);
+  const configured = resolve22(runConfigBaseDirFrom(dir), config.cwd);
   if (existsSync80(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
@@ -36657,7 +36903,7 @@ function windowsDaemonHost() {
 var CONNECT_TIMEOUT_MS = 2e3;
 var KEEPALIVE_PROBE_MS = 1e4;
 function connectToWindowsDaemon() {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     const socket = net2.connect(windowsDaemonPort(), windowsDaemonHost());
     socket.setTimeout(CONNECT_TIMEOUT_MS);
     socket.once("timeout", () => {
@@ -36667,7 +36913,7 @@ function connectToWindowsDaemon() {
     socket.once("connect", () => {
       socket.setTimeout(0);
       socket.setKeepAlive(true, KEEPALIVE_PROBE_MS);
-      resolve24(socket);
+      resolve25(socket);
     });
     socket.once("error", reject);
   });
@@ -36766,7 +37012,7 @@ async function waitForWindowsDaemon(launch) {
   );
 }
 function delay2(ms) {
-  return new Promise((resolve24) => setTimeout(resolve24, ms));
+  return new Promise((resolve25) => setTimeout(resolve25, ms));
 }
 
 // src/commands/sessions/daemon/defaultConnect.ts
@@ -37078,7 +37324,7 @@ async function healWindowsDaemon() {
   daemonLog("windows daemon: auto-heal: stale daemon stopped");
 }
 function runOnWindowsHost(command, timeoutMs) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     const child = spawn12("pwsh.exe", ["-Command", command], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -37098,7 +37344,7 @@ function runOnWindowsHost(command, timeoutMs) {
     });
     child.on("exit", (code) => {
       clearTimeout(timer);
-      if (code === 0) resolve24();
+      if (code === 0) resolve25();
       else
         reject(
           new Error(
@@ -38324,7 +38570,7 @@ function describePortHolder(port) {
   return holder !== void 0 && holder !== process.pid ? `PID ${holder} is listening on it \u2014 kill PID ${holder} to free the port` : "the port is held by another process or reserved by a Hyper-V/WSL dynamic port range \u2014 set sessions.windowsDaemonPort to a free port outside 49152-65535";
 }
 function bindBridge(manager, port) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     const bridge = net3.createServer((socket) => {
       socket.setKeepAlive(true, KEEPALIVE_PROBE_MS2);
       handleConnection(socket, manager);
@@ -38332,7 +38578,7 @@ function bindBridge(manager, port) {
     bridge.once("error", (error) => {
       bridge.close(() => {
       });
-      resolve24(error);
+      resolve25(error);
     });
     bridge.listen(port, () => {
       bridge.removeAllListeners("error");
@@ -38342,12 +38588,12 @@ function bindBridge(manager, port) {
         );
         exitAfterFlush(1);
       });
-      resolve24(null);
+      resolve25(null);
     });
   });
 }
 function delay3(ms) {
-  return new Promise((resolve24) => setTimeout(resolve24, ms));
+  return new Promise((resolve25) => setTimeout(resolve25, ms));
 }
 
 // src/commands/sessions/daemon/describeWedgedHolder.ts
@@ -38462,7 +38708,7 @@ function registerSetStatusCommand(cmd) {
 
 // src/commands/sessions/summarise/index.ts
 import * as fs56 from "fs";
-import chalk221 from "chalk";
+import chalk222 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs55 from "fs";
@@ -38521,22 +38767,22 @@ ${firstMessage}`);
 async function summarise2(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk221.yellow("No sessions found."));
+    console.log(chalk222.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk221.green("All sessions already summarised."));
+    console.log(chalk222.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk221.cyan(
+    chalk222.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk221.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk221.yellow(`, ${failed2} skipped`) : "")
+    chalk222.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk222.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -38556,16 +38802,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk221.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk222.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk221.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk222.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk221.yellow("skip")}
+      process.stdout.write(` ${chalk222.yellow("skip")}
 `);
     }
   }
@@ -38586,7 +38832,7 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk223 from "chalk";
+import chalk224 from "chalk";
 
 // src/shared/contextLevel.ts
 function contextLevel(pct) {
@@ -38596,7 +38842,7 @@ function contextLevel(pct) {
 }
 
 // src/commands/buildLimitsSegment.ts
-import chalk222 from "chalk";
+import chalk223 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -38634,9 +38880,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk222.green,
-  warn: chalk222.yellow,
-  over: chalk222.red
+  ok: chalk223.green,
+  warn: chalk223.yellow,
+  over: chalk223.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -38668,7 +38914,7 @@ function buildLimitsSegment(rateLimits) {
 
 // src/commands/readGitBranch.ts
 import { readFileSync as readFileSync61, statSync as statSync15 } from "fs";
-import { isAbsolute as isAbsolute4, join as join95, resolve as resolve22 } from "path";
+import { isAbsolute as isAbsolute5, join as join95, resolve as resolve23 } from "path";
 function resolveGitDir(cwd) {
   const dotGit = join95(cwd, ".git");
   let stat4;
@@ -38691,7 +38937,7 @@ function resolveGitDir(cwd) {
     return null;
   }
   const gitDir = match[1].trim();
-  return isAbsolute4(gitDir) ? gitDir : resolve22(cwd, gitDir);
+  return isAbsolute5(gitDir) ? gitDir : resolve23(cwd, gitDir);
 }
 function readGitBranch(cwd) {
   const gitDir = resolveGitDir(cwd);
@@ -38732,7 +38978,7 @@ async function relayUsage(claudeSessionId, transcriptPath2, usedPct) {
 }
 
 // src/commands/statusLine.ts
-chalk223.level = 3;
+chalk224.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
@@ -38740,9 +38986,9 @@ function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
   switch (contextLevel(pct)) {
     case "red":
-      return chalk223.red(label2);
+      return chalk224.red(label2);
     case "yellow":
-      return chalk223.yellow(label2);
+      return chalk224.yellow(label2);
     default:
       return label2;
   }
@@ -38755,7 +39001,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 ${chalk223.cyan(branch2)} | ` : "";
+  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk224.cyan(branch2)} | ` : "";
   console.log(
     `${branchSegment}${model} | Tokens - ${formatNumber(totalIn)} \u2191 : ${formatNumber(totalOut)} \u2193 | Context - ${colorizePercent(usedPct)}${buildLimitsSegment(data.rate_limits)}`
   );
@@ -38825,10 +39071,10 @@ async function update2() {
 }
 
 // src/reportCliError.ts
-import chalk224 from "chalk";
+import chalk225 from "chalk";
 function reportCliError(error) {
   if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError || error instanceof MissingRunCwdError || error instanceof MiroExtractError) {
-    console.error(chalk224.red(error.message));
+    console.error(chalk225.red(error.message));
   } else {
     console.error(error);
   }