@staff0rd/assist 0.623.1 → 0.624.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.623.1",
+  version: "0.624.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -705,6 +705,10 @@ var assistConfigShape = {
       suppress: z3.array(z3.string()).default([])
     }).default({ suppress: [] })
   }).optional(),
+  litellm: z3.strictObject({
+    baseUrl: z3.string().optional(),
+    apiKey: secretConfigValue(z3.string()).optional()
+  }).optional(),
   ravendb: z3.strictObject({
     connections: z3.array(
       z3.strictObject({
@@ -3076,6 +3080,20 @@ var jiraConfigHelp = [
   }
 ];
 
+// src/commands/litellm/litellmConfigHelp.ts
+var litellmConfigHelp = [
+  {
+    key: "litellm.baseUrl",
+    setter: "assist config set litellm.baseUrl https://...",
+    note: "LiteLLM proxy base URL"
+  },
+  {
+    key: "litellm.apiKey",
+    setter: "assist config set litellm.apiKey sk-...",
+    note: "LiteLLM proxy API key"
+  }
+];
+
 // src/commands/mermaid/mermaidConfigHelp.ts
 var mermaidConfigHelp = [
   {
@@ -3463,6 +3481,7 @@ var configHelpEntries = [
   ...dotnetConfigHelp,
   ...harnessConfigHelp,
   ...jiraConfigHelp,
+  ...litellmConfigHelp,
   ...mermaidConfigHelp,
   ...miroConfigHelp,
   ...prsConfigHelp,
@@ -23896,18 +23915,85 @@ function registerList(program2) {
   });
 }
 
+// src/commands/litellm/listModels.ts
+import chalk172 from "chalk";
+
+// src/commands/litellm/resolveLitellmConfig.ts
+import chalk171 from "chalk";
+function resolveLitellmConfig() {
+  const litellm = loadConfig().litellm;
+  const baseUrl = litellm?.baseUrl?.trim();
+  const apiKey = litellm?.apiKey?.trim();
+  if (!baseUrl || !apiKey) {
+    const missing = [
+      ...baseUrl ? [] : ["litellm.baseUrl"],
+      ...apiKey ? [] : ["litellm.apiKey"]
+    ];
+    console.error(chalk171.red("LiteLLM is not configured"));
+    for (const key of missing) {
+      const entry = litellmConfigHelp.find((help) => help.key === key);
+      console.error(
+        chalk171.red(`  ${key} is not set. Set it with: ${entry?.setter}`)
+      );
+    }
+    process.exit(1);
+  }
+  return { baseUrl: baseUrl.replace(/\/+$/, ""), apiKey };
+}
+
+// src/commands/litellm/listModels.ts
+function parseModelIds(body) {
+  const parsed = JSON.parse(body);
+  return (parsed.data ?? []).map((model) => model.id).filter((id) => typeof id === "string").sort();
+}
+async function listModels(options2) {
+  const { baseUrl, apiKey } = resolveLitellmConfig();
+  let response;
+  try {
+    response = await fetch(`${baseUrl}/v1/models`, {
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  } catch (error) {
+    const reason4 = error instanceof Error ? error.message : String(error);
+    console.error(
+      chalk172.red(`Failed to reach LiteLLM at ${baseUrl}: ${reason4}`)
+    );
+    process.exit(1);
+  }
+  const body = await response.text();
+  if (!response.ok) {
+    console.error(chalk172.red(`LiteLLM returned ${response.status}: ${body}`));
+    process.exit(1);
+  }
+  if (options2.json) {
+    console.log(body);
+    return;
+  }
+  for (const id of parseModelIds(body)) console.log(id);
+}
+
+// src/commands/registerLitellm.ts
+function registerLitellm(program2) {
+  const cmd = program2.command("litellm").description("LiteLLM proxy utilities");
+  const listModelsCommand = cmd.command("list-models").description("List the models the configured LiteLLM proxy serves").option("--json", "Output the raw /v1/models response body").action((options2) => listModels(options2));
+  configHelp(listModelsCommand, litellmConfigHelp);
+}
+
 // src/commands/mermaid/index.ts
 import { mkdirSync as mkdirSync18, readdirSync as readdirSync11 } from "fs";
 import { resolve as resolve16 } from "path";
-import chalk173 from "chalk";
+import chalk175 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
 import { readFileSync as readFileSync40, writeFileSync as writeFileSync32 } from "fs";
 import { basename as basename17, extname as extname2, resolve as resolve15 } from "path";
-import chalk172 from "chalk";
+import chalk174 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
-import chalk171 from "chalk";
+import chalk173 from "chalk";
 async function renderBlock(krokiUrl, source) {
   const response = await fetch(`${krokiUrl}/mermaid/svg`, {
     method: "POST",
@@ -23916,7 +24002,7 @@ async function renderBlock(krokiUrl, source) {
   });
   if (!response.ok) {
     console.error(
-      chalk171.red(
+      chalk173.red(
         `Kroki request failed: ${response.status} ${response.statusText}`
       )
     );
@@ -23934,19 +24020,19 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
-        chalk172.red(
+        chalk174.red(
           `${file}: --index ${onlyIndex} out of range (file has ${blocks.length} diagram(s))`
         )
       );
       process.exit(1);
     }
     console.log(
-      chalk172.gray(
+      chalk174.gray(
         `${file} \u2014 rendering diagram ${onlyIndex} of ${blocks.length}`
       )
     );
   } else {
-    console.log(chalk172.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
+    console.log(chalk174.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
   }
   for (const [i, source] of blocks.entries()) {
     const idx = i + 1;
@@ -23954,7 +24040,7 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
     const outPath = resolve15(outDir, `${stem}-${idx}.svg`);
     const svg = await renderBlock(krokiUrl, source);
     writeFileSync32(outPath, svg, "utf8");
-    console.log(chalk172.green(`  \u2192 ${outPath}`));
+    console.log(chalk174.green(`  \u2192 ${outPath}`));
   }
 }
 function extractMermaidBlocks(markdown) {
@@ -23970,18 +24056,18 @@ async function mermaidExport(file, options2 = {}) {
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
       console.error(
-        chalk173.red(`--index must be a positive integer (got ${options2.index})`)
+        chalk175.red(`--index must be a positive integer (got ${options2.index})`)
       );
       process.exit(1);
     }
     if (!file) {
-      console.error(chalk173.red("--index requires a file argument"));
+      console.error(chalk175.red("--index requires a file argument"));
       process.exit(1);
     }
   }
   const files = file ? [file] : readdirSync11(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
   if (files.length === 0) {
-    console.log(chalk173.gray("No markdown files found in current directory."));
+    console.log(chalk175.gray("No markdown files found in current directory."));
     return;
   }
   for (const f of files) {
@@ -24127,7 +24213,7 @@ function extractToSave(details, cwd = process.cwd()) {
 }
 
 // src/commands/miro/keptTexts.ts
-import chalk174 from "chalk";
+import chalk176 from "chalk";
 
 // src/commands/miro/applyIgnore.ts
 function applyIgnore(texts, ignore3) {
@@ -24166,7 +24252,7 @@ function warnUnmatched(file, unmatched) {
   if (unmatched.length === 0) return;
   const entries = unmatched.map((entry) => `  - ${entry}`).join("\n");
   console.error(
-    chalk174.yellow(
+    chalk176.yellow(
       `${unmatched.length} ${unmatched.length === 1 ? "entry" : "entries"} in ${file} matched no box text:
 ${entries}`
     )
@@ -24369,7 +24455,7 @@ function readMiroItems(file) {
 }
 
 // src/commands/miro/resolveExtractOptions.ts
-import chalk175 from "chalk";
+import chalk177 from "chalk";
 
 // src/commands/miro/extractLayers.ts
 function extractsIn(layer) {
@@ -24447,7 +24533,7 @@ function resolveExtractOptions(name, options2, paths) {
     paths.cwd,
     paths.globalConfigPath
   );
-  console.error(chalk175.dim(`Extract "${name}" from ${resolved.from}`));
+  console.error(chalk177.dim(`Extract "${name}" from ${resolved.from}`));
   return resolved.options;
 }
 
@@ -24549,7 +24635,7 @@ function registerMiro(program2) {
 import { mkdir as mkdir5 } from "fs/promises";
 import { createServer as createServer2 } from "http";
 import { dirname as dirname30 } from "path";
-import chalk177 from "chalk";
+import chalk179 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
 var corsHeaders = {
@@ -24628,7 +24714,7 @@ function createNetcapHandler(options2) {
 import { cp as cp4, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 import { networkInterfaces } from "os";
 import { join as join64 } from "path";
-import chalk176 from "chalk";
+import chalk178 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
 import { dirname as dirname29, join as join63 } from "path";
@@ -24672,7 +24758,7 @@ async function prepareExtensionForLoad(port, filter = "") {
   const host = lanIPv4();
   if (!host) {
     console.log(
-      chalk176.yellow("could not determine the WSL IP for the extension")
+      chalk178.yellow("could not determine the WSL IP for the extension")
     );
     await configureBackground(source, "127.0.0.1", port, filter);
     return source;
@@ -24683,7 +24769,7 @@ async function prepareExtensionForLoad(port, filter = "") {
     return WSL_WINDOWS_PATH3;
   } catch {
     console.log(
-      chalk176.yellow(`could not copy extension to ${WSL_WINDOWS_PATH3}`)
+      chalk178.yellow(`could not copy extension to ${WSL_WINDOWS_PATH3}`)
     );
     return source;
   }
@@ -24716,30 +24802,30 @@ async function netcap(options2) {
   let count8 = 0;
   const handler = createNetcapHandler({
     outPath,
-    onPing: () => console.log(chalk177.dim("ping from extension")),
+    onPing: () => console.log(chalk179.dim("ping from extension")),
     onCapture: (entry) => {
       count8 += 1;
       console.log(
-        chalk177.green(`captured #${count8}`),
-        chalk177.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
+        chalk179.green(`captured #${count8}`),
+        chalk179.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
       );
     }
   });
   const server = createServer2(handler);
   server.listen(port, () => {
     console.log(
-      chalk177.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
+      chalk179.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
     );
-    console.log(chalk177.dim(`appending captures to ${outPath}`));
+    console.log(chalk179.dim(`appending captures to ${outPath}`));
     if (filter)
-      console.log(chalk177.dim(`forwarding only URLs matching "${filter}"`));
-    console.log(chalk177.dim(`load the unpacked extension from ${extensionPath}`));
-    console.log(chalk177.dim("press Ctrl-C to stop"));
+      console.log(chalk179.dim(`forwarding only URLs matching "${filter}"`));
+    console.log(chalk179.dim(`load the unpacked extension from ${extensionPath}`));
+    console.log(chalk179.dim("press Ctrl-C to stop"));
   });
   process.on("SIGINT", () => {
     server.close();
     console.log(
-      chalk177.bold(
+      chalk179.bold(
         `
 netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} to ${outPath}`
       )
@@ -24751,7 +24837,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 join67 } from "path";
-import chalk178 from "chalk";
+import chalk180 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
 import { readFileSync as readFileSync43 } from "fs";
@@ -25199,8 +25285,8 @@ function netcapExtract(file) {
   writeFileSync34(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
-    chalk178.green(`extracted ${posts.length} posts`),
-    chalk178.dim(`-> ${outFile}`)
+    chalk180.green(`extracted ${posts.length} posts`),
+    chalk180.dim(`-> ${outFile}`)
   );
 }
 
@@ -25221,7 +25307,7 @@ function registerNetcap(program2) {
 }
 
 // src/commands/news/add/index.ts
-import chalk179 from "chalk";
+import chalk181 from "chalk";
 import enquirer8 from "enquirer";
 async function add2(url) {
   if (!url) {
@@ -25243,10 +25329,10 @@ async function add2(url) {
   const { orm } = await getReady();
   const added = await addFeed(orm, url);
   if (!added) {
-    console.log(chalk179.yellow("Feed already exists"));
+    console.log(chalk181.yellow("Feed already exists"));
     return;
   }
-  console.log(chalk179.green(`Added feed: ${url}`));
+  console.log(chalk181.green(`Added feed: ${url}`));
 }
 
 // src/commands/registerNews.ts
@@ -25293,7 +25379,7 @@ function registerPiHook(program2) {
 }
 
 // src/commands/prompts/printPromptsTable.ts
-import chalk180 from "chalk";
+import chalk182 from "chalk";
 function truncate(str, max) {
   if (str.length <= max) return str;
   return `${str.slice(0, max - 1)}\u2026`;
@@ -25311,14 +25397,14 @@ function printPromptsTable(rows) {
     "Command".padEnd(commandWidth),
     "Repos"
   ].join("  ");
-  console.log(chalk180.dim(header));
-  console.log(chalk180.dim("-".repeat(header.length)));
+  console.log(chalk182.dim(header));
+  console.log(chalk182.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(
-      `${chalk180.yellow(count8)}  ${tool}  ${command}  ${chalk180.dim(row.repos)}`
+      `${chalk182.yellow(count8)}  ${tool}  ${command}  ${chalk182.dim(row.repos)}`
     );
   }
 }
@@ -25892,13 +25978,13 @@ function agentFooter(unresolvedCount) {
 }
 
 // src/commands/prs/listComments/commentStyle.ts
-import chalk181 from "chalk";
+import chalk183 from "chalk";
 var plain = (text18) => text18;
 function colouredState(state) {
   const label2 = `[${state}]`;
-  if (state === "APPROVED") return chalk181.green(label2);
-  if (state === "CHANGES_REQUESTED") return chalk181.red(label2);
-  return chalk181.yellow(label2);
+  if (state === "APPROVED") return chalk183.green(label2);
+  if (state === "CHANGES_REQUESTED") return chalk183.red(label2);
+  return chalk183.yellow(label2);
 }
 function commentStyle() {
   if (isClaudeCode()) {
@@ -25912,9 +25998,9 @@ function commentStyle() {
     };
   }
   return {
-    cyan: chalk181.cyan,
-    bold: chalk181.bold,
-    dim: chalk181.dim,
+    cyan: chalk183.cyan,
+    bold: chalk183.bold,
+    dim: chalk183.dim,
     state: colouredState,
     diffHunk: true,
     agent: false
@@ -26084,13 +26170,13 @@ import { execSync as execSync49 } from "child_process";
 import enquirer9 from "enquirer";
 
 // src/commands/prs/prs/displayPaginated/printPr.ts
-import chalk182 from "chalk";
+import chalk184 from "chalk";
 var STATUS_MAP = {
-  MERGED: (pr) => pr.mergedAt ? { label: chalk182.magenta("merged"), date: pr.mergedAt } : null,
-  CLOSED: (pr) => pr.closedAt ? { label: chalk182.red("closed"), date: pr.closedAt } : null
+  MERGED: (pr) => pr.mergedAt ? { label: chalk184.magenta("merged"), date: pr.mergedAt } : null,
+  CLOSED: (pr) => pr.closedAt ? { label: chalk184.red("closed"), date: pr.closedAt } : null
 };
 function defaultStatus(pr) {
-  return { label: chalk182.green("opened"), date: pr.createdAt };
+  return { label: chalk184.green("opened"), date: pr.createdAt };
 }
 function getStatus2(pr) {
   return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -26099,11 +26185,11 @@ function formatDate(dateStr) {
   return new Date(dateStr).toISOString().split("T")[0];
 }
 function formatPrHeader(pr, status3) {
-  return `${chalk182.cyan(`#${pr.number}`)} ${pr.title} ${chalk182.dim(`(${pr.author.login},`)} ${status3.label} ${chalk182.dim(`${formatDate(status3.date)})`)}`;
+  return `${chalk184.cyan(`#${pr.number}`)} ${pr.title} ${chalk184.dim(`(${pr.author.login},`)} ${status3.label} ${chalk184.dim(`${formatDate(status3.date)})`)}`;
 }
 function logPrDetails(pr) {
   console.log(
-    chalk182.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
+    chalk184.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
   console.log();
 }
@@ -26818,10 +26904,10 @@ function registerPrs(program2) {
 }
 
 // src/commands/ravendb/ravendbAuth.ts
-import chalk188 from "chalk";
+import chalk190 from "chalk";
 
 // src/shared/createConnectionAuth.ts
-import chalk183 from "chalk";
+import chalk185 from "chalk";
 function listConnections(connections, format) {
   if (connections.length === 0) {
     console.log("No connections configured.");
@@ -26834,7 +26920,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(chalk183.red(`Connection "${name}" not found.`));
+    console.error(chalk185.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   save(filtered);
@@ -26880,15 +26966,15 @@ function saveConnections(connections) {
 }
 
 // src/commands/ravendb/promptConnection.ts
-import chalk186 from "chalk";
+import chalk188 from "chalk";
 
 // src/commands/ravendb/selectOpSecret.ts
-import chalk185 from "chalk";
+import chalk187 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
 import { execSync as execSync52 } from "child_process";
-import chalk184 from "chalk";
+import chalk186 from "chalk";
 function opExec(args) {
   return execSync52(`op ${args}`, {
     encoding: "utf8",
@@ -26901,7 +26987,7 @@ function searchItems(search2) {
     items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
-      chalk184.red(
+      chalk186.red(
         "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
       )
     );
@@ -26915,7 +27001,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(chalk184.red("Failed to get item details from 1Password."));
+    console.error(chalk186.red("Failed to get item details from 1Password."));
     process.exit(1);
   }
 }
@@ -26934,7 +27020,7 @@ async function selectOpSecret(searchTerm) {
   }).run();
   const items2 = searchItems(search2);
   if (items2.length === 0) {
-    console.error(chalk185.red(`No items found matching "${search2}".`));
+    console.error(chalk187.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId2 = await selectOne(
@@ -26943,7 +27029,7 @@ async function selectOpSecret(searchTerm) {
   );
   const fields = getItemFields(itemId2);
   if (fields.length === 0) {
-    console.error(chalk185.red("No fields with references found on this item."));
+    console.error(chalk187.red("No fields with references found on this item."));
     process.exit(1);
   }
   const ref = await selectOne(
@@ -26957,7 +27043,7 @@ async function selectOpSecret(searchTerm) {
 async function promptConnection(existingNames) {
   const name = await promptInput("name", "Connection name:");
   if (existingNames.includes(name)) {
-    console.error(chalk186.red(`Connection "${name}" already exists.`));
+    console.error(chalk188.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput(
@@ -26966,22 +27052,22 @@ async function promptConnection(existingNames) {
   );
   const database = await promptInput("database", "Database name:");
   if (!name || !url || !database) {
-    console.error(chalk186.red("All fields are required."));
+    console.error(chalk188.red("All fields are required."));
     process.exit(1);
   }
   const apiKeyRef = await selectOpSecret();
-  console.log(chalk186.dim(`Using: ${apiKeyRef}`));
+  console.log(chalk188.dim(`Using: ${apiKeyRef}`));
   return { name, url, database, apiKeyRef };
 }
 
 // src/commands/ravendb/ravendbSetConnection.ts
-import chalk187 from "chalk";
+import chalk189 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(chalk187.red(`Connection "${name}" not found.`));
+    console.error(chalk189.red(`Connection "${name}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -26997,16 +27083,16 @@ function ravendbSetConnection(name) {
 var ravendbAuth = createConnectionAuth({
   load: loadConnections,
   save: saveConnections,
-  format: (c) => `${chalk188.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
+  format: (c) => `${chalk190.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
   promptNew: promptConnection,
   onFirst: (c) => ravendbSetConnection(c.name)
 });
 
 // src/commands/ravendb/ravendbCollections.ts
-import chalk192 from "chalk";
+import chalk194 from "chalk";
 
 // src/commands/ravendb/ravenFetch.ts
-import chalk190 from "chalk";
+import chalk192 from "chalk";
 
 // src/commands/ravendb/getAccessToken.ts
 var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -27043,10 +27129,10 @@ ${errorText}`
 
 // src/commands/ravendb/resolveOpSecret.ts
 import { execSync as execSync53 } from "child_process";
-import chalk189 from "chalk";
+import chalk191 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
-    console.error(chalk189.red(`Invalid secret reference: must start with op://`));
+    console.error(chalk191.red(`Invalid secret reference: must start with op://`));
     process.exit(1);
   }
   try {
@@ -27056,7 +27142,7 @@ function resolveOpSecret(reference) {
     }).trim();
   } catch {
     console.error(
-      chalk189.red(
+      chalk191.red(
         "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
       )
     );
@@ -27083,7 +27169,7 @@ async function ravenFetch(connection, path90) {
   if (!response.ok) {
     const body = await response.text();
     console.error(
-      chalk190.red(`RavenDB error: ${response.status} ${response.statusText}`)
+      chalk192.red(`RavenDB error: ${response.status} ${response.statusText}`)
     );
     console.error(body.substring(0, 500));
     process.exit(1);
@@ -27092,7 +27178,7 @@ async function ravenFetch(connection, path90) {
 }
 
 // src/commands/ravendb/resolveConnection.ts
-import chalk191 from "chalk";
+import chalk193 from "chalk";
 function loadRavendb() {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb;
@@ -27106,7 +27192,7 @@ function resolveConnection(name) {
   const connectionName = name ?? defaultConnection;
   if (!connectionName) {
     console.error(
-      chalk191.red(
+      chalk193.red(
         "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
       )
     );
@@ -27114,7 +27200,7 @@ function resolveConnection(name) {
   }
   const connection = connections.find((c) => c.name === connectionName);
   if (!connection) {
-    console.error(chalk191.red(`Connection "${connectionName}" not found.`));
+    console.error(chalk193.red(`Connection "${connectionName}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -27145,15 +27231,15 @@ async function ravendbCollections(connectionName) {
     return;
   }
   for (const c of collections) {
-    console.log(`${chalk192.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+    console.log(`${chalk194.bold(c.Name)}  ${c.CountOfDocuments} docs`);
   }
 }
 
 // src/commands/ravendb/ravendbQuery.ts
-import chalk194 from "chalk";
+import chalk196 from "chalk";
 
 // src/commands/ravendb/fetchAllPages.ts
-import chalk193 from "chalk";
+import chalk195 from "chalk";
 
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
@@ -27191,7 +27277,7 @@ async function fetchAllPages(connection, opts) {
     allResults.push(...results);
     start3 += results.length;
     process.stderr.write(
-      `\r${chalk193.dim(`Fetched ${allResults.length}/${totalResults}`)}`
+      `\r${chalk195.dim(`Fetched ${allResults.length}/${totalResults}`)}`
     );
     if (start3 >= totalResults) break;
     if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
@@ -27206,7 +27292,7 @@ async function fetchAllPages(connection, opts) {
 async function ravendbQuery(connectionName, collection, options2) {
   const resolved = resolveArgs(connectionName, collection);
   if (!resolved.collection && !options2.query) {
-    console.error(chalk194.red("Provide a collection name or --query filter."));
+    console.error(chalk196.red("Provide a collection name or --query filter."));
     process.exit(1);
   }
   const { collection: col } = resolved;
@@ -27245,7 +27331,7 @@ import { spawn as spawn6 } from "child_process";
 import * as path45 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk195 from "chalk";
+import chalk197 from "chalk";
 var DEFAULT_MAX_LINES2 = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
   if (violations.length === 0) {
@@ -27254,43 +27340,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
     }
     return;
   }
-  console.error(chalk195.red(`
+  console.error(chalk197.red(`
 Refactor check failed:
 `));
-  console.error(chalk195.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk197.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk195.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk197.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk195.yellow(
+    chalk197.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk195.gray(`    assist refactor ignore <file>
+  console.error(chalk197.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk195.cyan(`
+    console.error(chalk197.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk195.cyan(
+      chalk197.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk195.cyan(
+      chalk197.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(
-      chalk195.cyan(
+      chalk197.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -27446,7 +27532,7 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/extract/index.ts
 import path53 from "path";
-import chalk198 from "chalk";
+import chalk200 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
@@ -28045,23 +28131,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 
 // src/commands/refactor/extract/displayPlan.ts
 import path49 from "path";
-import chalk196 from "chalk";
+import chalk198 from "chalk";
 function section2(title) {
   return `
-  ${chalk196.cyan(title)}`;
+  ${chalk198.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 = path49.relative(cwd, imp.file.getFilePath());
-    console.log(`    ${chalk196.dim(rel)}: \u2192 import from "${imp.relPath}"`);
+    console.log(`    ${chalk198.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
 function displayPlan(functionName, relDest, plan2, cwd) {
-  console.log(chalk196.bold(`Extract: ${functionName} \u2192 ${relDest}
+  console.log(chalk198.bold(`Extract: ${functionName} \u2192 ${relDest}
 `));
-  console.log(`  ${chalk196.cyan("Functions to move:")}`);
+  console.log(`  ${chalk198.cyan("Functions to move:")}`);
   for (const name of plan2.extractedNames) {
     console.log(`    ${name}`);
   }
@@ -28095,7 +28181,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import path52 from "path";
-import chalk197 from "chalk";
+import chalk199 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
@@ -28187,7 +28273,7 @@ function loadProjectFile(file) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk197.red(`File not found in project: ${file}`));
+    console.log(chalk199.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   return { project, sourceFile };
@@ -28210,19 +28296,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(chalk198.green("\nExtraction complete"));
+    console.log(chalk200.green("\nExtraction complete"));
   } else {
-    console.log(chalk198.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk200.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/ignore.ts
 import fs33 from "fs";
-import chalk199 from "chalk";
+import chalk201 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore2(file) {
   if (!fs33.existsSync(file)) {
-    console.error(chalk199.red(`Error: File does not exist: ${file}`));
+    console.error(chalk201.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs33.readFileSync(file, "utf8");
@@ -28238,7 +28324,7 @@ function ignore2(file) {
     fs33.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk199.green(
+    chalk201.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -28247,12 +28333,12 @@ function ignore2(file) {
 // src/commands/refactor/rename/index.ts
 import fs36 from "fs";
 import path58 from "path";
-import chalk202 from "chalk";
+import chalk204 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs35 from "fs";
 import path55 from "path";
-import chalk200 from "chalk";
+import chalk202 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
 import path54 from "path";
@@ -28357,13 +28443,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs35.writeFileSync(file, content, "utf8");
-    console.log(chalk200.cyan(`  Updated imports in ${path55.relative(cwd, file)}`));
+    console.log(chalk202.cyan(`  Updated imports in ${path55.relative(cwd, file)}`));
   }
   const destDir = path55.dirname(destPath);
   if (!fs35.existsSync(destDir)) fs35.mkdirSync(destDir, { recursive: true });
   fs35.renameSync(sourcePath, destPath);
   console.log(
-    chalk200.white(
+    chalk202.white(
       `  Moved ${path55.relative(cwd, sourcePath)} \u2192 ${path55.relative(cwd, destPath)}`
     )
   );
@@ -28450,16 +28536,16 @@ function computeRenameRewrites(sourcePath, destPath) {
 
 // src/commands/refactor/rename/printRenamePreview.ts
 import path57 from "path";
-import chalk201 from "chalk";
+import chalk203 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
-      chalk201.dim(
+      chalk203.dim(
         `  ${path57.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
-  console.log(chalk201.dim("Dry run. Use --apply to execute."));
+  console.log(chalk203.dim("Dry run. Use --apply to execute."));
 }
 
 // src/commands/refactor/rename/index.ts
@@ -28470,20 +28556,20 @@ async function rename(source, destination, options2 = {}) {
   const relSource = path58.relative(cwd, sourcePath);
   const relDest = path58.relative(cwd, destPath);
   if (!fs36.existsSync(sourcePath)) {
-    console.log(chalk202.red(`File not found: ${source}`));
+    console.log(chalk204.red(`File not found: ${source}`));
     process.exit(1);
   }
   if (destPath !== sourcePath && fs36.existsSync(destPath)) {
-    console.log(chalk202.red(`Destination already exists: ${destination}`));
+    console.log(chalk204.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
-  console.log(chalk202.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  console.log(chalk202.dim("Loading project..."));
-  console.log(chalk202.dim("Scanning imports across the project..."));
+  console.log(chalk204.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk204.dim("Loading project..."));
+  console.log(chalk204.dim("Scanning imports across the project..."));
   const rewrites = computeRenameRewrites(sourcePath, destPath);
   const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
   console.log(
-    chalk202.dim(
+    chalk204.dim(
       `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
     )
   );
@@ -28492,11 +28578,11 @@ async function rename(source, destination, options2 = {}) {
     return;
   }
   applyRename(rewrites, sourcePath, destPath, cwd);
-  console.log(chalk202.green("Done"));
+  console.log(chalk204.green("Done"));
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import chalk203 from "chalk";
+import chalk205 from "chalk";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
 import { SyntaxKind as SyntaxKind15 } from "ts-morph";
@@ -28542,33 +28628,33 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const { project, sourceFile } = loadProjectFile(file);
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk203.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk205.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(
-    chalk203.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk205.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines2] of grouped) {
     console.log(
-      `  ${chalk203.dim(refFile)}: lines ${chalk203.cyan(lines2.join(", "))}`
+      `  ${chalk205.dim(refFile)}: lines ${chalk205.cyan(lines2.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk203.green(`
+    console.log(chalk205.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk203.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk205.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
 import path66 from "path";
-import chalk206 from "chalk";
+import chalk208 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
 import path60 from "path";
@@ -28647,50 +28733,50 @@ function clusterFiles(graph) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path62 from "path";
-import chalk204 from "chalk";
+import chalk206 from "chalk";
 function relPath(filePath) {
   return path62.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk204.bold("\nFile moves:"));
+  console.log(chalk206.bold("\nFile moves:"));
   for (const move2 of plan2.moves) {
     console.log(
-      `  ${chalk204.red(relPath(move2.from))} \u2192 ${chalk204.green(relPath(move2.to))}`
+      `  ${chalk206.red(relPath(move2.from))} \u2192 ${chalk206.green(relPath(move2.to))}`
     );
-    console.log(chalk204.dim(`    ${move2.reason}`));
+    console.log(chalk206.dim(`    ${move2.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk204.bold(`
+  console.log(chalk206.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk204.cyan(relPath(file))}:`);
+    console.log(`  ${chalk206.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk204.red(`"${oldSpecifier}"`)} \u2192 ${chalk204.green(`"${newSpecifier}"`)}`
+        `    ${chalk206.red(`"${oldSpecifier}"`)} \u2192 ${chalk206.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk204.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk204.yellow(`  ${w}`));
+    console.log(chalk206.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk206.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk204.bold("\nNew directories:"));
+    console.log(chalk206.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk204.green(`  ${dir}/`));
+      console.log(chalk206.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk204.dim(
+    chalk206.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -28700,18 +28786,18 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 // src/commands/refactor/restructure/executePlan.ts
 import fs37 from "fs";
 import path63 from "path";
-import chalk205 from "chalk";
+import chalk207 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs37.writeFileSync(file, content, "utf8");
     console.log(
-      chalk205.cyan(`  Rewrote imports in ${path63.relative(process.cwd(), file)}`)
+      chalk207.cyan(`  Rewrote imports in ${path63.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs37.mkdirSync(dir, { recursive: true });
-    console.log(chalk205.green(`  Created ${path63.relative(process.cwd(), dir)}/`));
+    console.log(chalk207.green(`  Created ${path63.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
     const targetDir = path63.dirname(move2.to);
@@ -28720,7 +28806,7 @@ function executePlan(plan2) {
     }
     fs37.renameSync(move2.from, move2.to);
     console.log(
-      chalk205.white(
+      chalk207.white(
         `  Moved ${path63.relative(process.cwd(), move2.from)} \u2192 ${path63.relative(process.cwd(), move2.to)}`
       )
     );
@@ -28735,7 +28821,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs37.rmdirSync(dir);
       console.log(
-        chalk205.dim(
+        chalk207.dim(
           `  Removed empty directory ${path63.relative(process.cwd(), dir)}`
         )
       );
@@ -28868,22 +28954,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk206.yellow("No files found matching pattern"));
+    console.log(chalk208.yellow("No files found matching pattern"));
     return;
   }
   const tsConfigPath = findTsConfig(path66.resolve(files[0]));
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk206.green("No restructuring needed"));
+    console.log(chalk208.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk206.bold("\nApplying changes..."));
+    console.log(chalk208.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk206.green("\nRestructuring complete"));
+    console.log(chalk208.green("\nRestructuring complete"));
   } else {
-    console.log(chalk206.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk208.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -29541,18 +29627,18 @@ function partitionFindingsByDiff(findings, index3) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk207 from "chalk";
+import chalk209 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk207.yellow(
+    chalk209.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(
-      `  ${chalk207.yellow("\xB7")} ${finding.title} ${chalk207.dim(
+      `  ${chalk209.yellow("\xB7")} ${finding.title} ${chalk209.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -29576,18 +29662,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk208 from "chalk";
+import chalk210 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk208.yellow(
+    chalk210.yellow(
       `Moved ${unlocated.length} finding(s) without a parseable file:line into the review body:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk208.dim("missing");
+    const where = finding.location || chalk210.dim("missing");
     console.warn(
-      `  ${chalk208.yellow("\xB7")} ${finding.title} ${chalk208.dim(`(${where})`)}`
+      `  ${chalk210.yellow("\xB7")} ${finding.title} ${chalk210.dim(`(${where})`)}`
     );
   }
 }
@@ -30844,7 +30930,7 @@ function registerReview(program2) {
 // src/commands/rules/addRule.ts
 import { existsSync as existsSync66, readFileSync as readFileSync50, writeFileSync as writeFileSync41 } from "fs";
 import path71 from "path";
-import chalk209 from "chalk";
+import chalk211 from "chalk";
 
 // src/commands/rules/insertRuleBullet.ts
 function ruleBullet({ code, title, text: text18 }) {
@@ -30980,7 +31066,7 @@ function read2(file) {
 function addRule(text18, options2) {
   const rule = text18.trim();
   if (rule === "") {
-    console.error(chalk209.red("Rule text is required"));
+    console.error(chalk211.red("Rule text is required"));
     process.exitCode = 1;
     return;
   }
@@ -30998,13 +31084,13 @@ function addRule(text18, options2) {
   );
   updateScopedRulesIndex(root);
   console.log(
-    `Added ${chalk209.cyan(code)} to ${path71.relative(process.cwd(), target) || target}`
+    `Added ${chalk211.cyan(code)} to ${path71.relative(process.cwd(), target) || target}`
   );
 }
 
 // src/commands/rules/indexRules.ts
 import path72 from "path";
-import chalk210 from "chalk";
+import chalk212 from "chalk";
 function indexRules() {
   const startDir = scopeDirectory(process.cwd());
   const root = findRepoRoot(startDir) ?? startDir;
@@ -31012,24 +31098,24 @@ function indexRules() {
   const rootFile = path72.relative(process.cwd(), path72.join(root, "CLAUDE.md"));
   if (directories.length === 0) {
     console.log(
-      chalk210.gray(`No directories carry their own \`## Rules\` under ${root}`)
+      chalk212.gray(`No directories carry their own \`## Rules\` under ${root}`)
     );
     return;
   }
   console.log(`Recorded in ${rootFile || "CLAUDE.md"}`);
   for (const directory of directories)
-    console.log(`  ${chalk210.cyan(directory)}`);
+    console.log(`  ${chalk212.cyan(directory)}`);
 }
 
 // src/commands/rules/listRules.ts
 import path73 from "path";
-import chalk211 from "chalk";
+import chalk213 from "chalk";
 function listRules(target, options2 = {}) {
   const resolved = path73.resolve(target ?? process.cwd());
   const rules3 = readScopedRules(resolved);
   if (rules3.length === 0) {
     const label2 = path73.relative(process.cwd(), resolved) || ".";
-    console.log(chalk211.gray(`No rules in scope for ${label2}`));
+    console.log(chalk213.gray(`No rules in scope for ${label2}`));
     return;
   }
   const base = findRepoRoot(scopeDirectory(resolved));
@@ -31039,14 +31125,14 @@ function listRules(target, options2 = {}) {
     if (rule.source !== shown) {
       shown = rule.source;
       console.log(
-        chalk211.dim(base ? path73.relative(base, rule.source) : rule.source)
+        chalk213.dim(base ? path73.relative(base, rule.source) : rule.source)
       );
     }
     console.log(
-      `  ${chalk211.cyan(rule.code.padEnd(width))}  ${rule.title ?? rule.text}`
+      `  ${chalk213.cyan(rule.code.padEnd(width))}  ${rule.title ?? rule.text}`
     );
     if (options2.full && rule.title)
-      console.log(`  ${" ".repeat(width)}  ${chalk211.dim(rule.text)}`);
+      console.log(`  ${" ".repeat(width)}  ${chalk213.dim(rule.text)}`);
   }
 }
 
@@ -31075,7 +31161,7 @@ function registerRules(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk213 from "chalk";
+import chalk215 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -31104,10 +31190,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk212 from "chalk";
+import chalk214 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk212.red(`Connection "${name}" already exists.`));
+    console.error(chalk214.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -31125,16 +31211,16 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk213.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk215.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk217 from "chalk";
+import chalk219 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk214 from "chalk";
+import chalk216 from "chalk";
 async function fetchSeq(conn, path90, params) {
   const url = `${conn.url}${path90}?${params}`;
   const response = await fetch(url, {
@@ -31145,7 +31231,7 @@ async function fetchSeq(conn, path90, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk214.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk216.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -31204,23 +31290,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk215 from "chalk";
+import chalk217 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk215.bgRed.white;
+      return chalk217.bgRed.white;
     case "Error":
-      return chalk215.red;
+      return chalk217.red;
     case "Warning":
-      return chalk215.yellow;
+      return chalk217.yellow;
     case "Information":
-      return chalk215.cyan;
+      return chalk217.cyan;
     case "Debug":
-      return chalk215.gray;
+      return chalk217.gray;
     case "Verbose":
-      return chalk215.dim;
+      return chalk217.dim;
     default:
-      return chalk215.white;
+      return chalk217.white;
   }
 }
 function levelAbbrev(level) {
@@ -31261,12 +31347,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk215.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk217.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(chalk215.red(`  ${line}`));
+      lines2.push(chalk217.red(`  ${line}`));
     }
   }
   return lines2.join("\n");
@@ -31299,11 +31385,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk216 from "chalk";
+import chalk218 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk216.red(
+      chalk218.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -31312,7 +31398,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(chalk216.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk218.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -31341,7 +31427,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count8) })
   );
   if (events.length === 0) {
-    console.log(chalk217.yellow("No events found."));
+    console.log(chalk219.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -31352,11 +31438,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk217.dim(`
+  console.log(chalk219.dim(`
 ${events.length} events`));
   if (events.length >= count8) {
     console.log(
-      chalk217.yellow(
+      chalk219.yellow(
         `Results limited to ${count8}. Use --count to retrieve more.`
       )
     );
@@ -31364,10 +31450,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk218 from "chalk";
+import chalk220 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk218.red(`Connection "${name}" not found.`));
+    console.error(chalk220.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -31516,7 +31602,7 @@ function registerSlack(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk220 from "chalk";
+import chalk222 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -31545,7 +31631,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk219 from "chalk";
+import chalk221 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -31553,7 +31639,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk219.red(`Invalid port "${portStr}".`));
+    console.error(chalk221.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -31566,13 +31652,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk220.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk222.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk221 from "chalk";
+import chalk223 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -31581,7 +31667,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk221.yellow("(no rows)"));
+    console.log(chalk223.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -31589,13 +31675,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(chalk221.dim(header));
-  console.log(chalk221.dim("-".repeat(header.length)));
+  console.log(chalk223.dim(header));
+  console.log(chalk223.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(chalk221.dim(`
+  console.log(chalk223.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -31655,7 +31741,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk222 from "chalk";
+import chalk224 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -31689,7 +31775,7 @@ function isMutation(sql25) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk222.red(
+      chalk224.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -31699,18 +31785,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk222.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk224.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk223 from "chalk";
+import chalk225 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk223.red(
+      chalk225.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -31725,7 +31811,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk223.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk225.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -31870,7 +31956,7 @@ function reportPrune(label2, result, force) {
 // src/commands/sync/syncClaudeMd.ts
 import * as fs41 from "fs";
 import * as path76 from "path";
-import chalk224 from "chalk";
+import chalk226 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path76.join(claudeDir, "CLAUDE.md");
   const target = path76.join(targetBase, "CLAUDE.md");
@@ -31879,14 +31965,14 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
     const targetContent = fs41.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk224.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk226.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       if (!options2?.yes) {
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk224.red("Overwrite existing CLAUDE.md?"),
+          chalk226.red("Overwrite existing CLAUDE.md?"),
           false
         );
         if (!confirm) {
@@ -32119,7 +32205,7 @@ function syncPi(claudeDir, options2) {
 // src/commands/sync/syncSettings.ts
 import * as fs47 from "fs";
 import * as path83 from "path";
-import chalk225 from "chalk";
+import chalk227 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path83.join(claudeDir, "settings.json");
   const target = path83.join(targetBase, "settings.json");
@@ -32138,7 +32224,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk225.yellow(
+          chalk227.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
@@ -32146,7 +32232,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
         printDiff(targetContent, mergedContent);
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk225.red("Overwrite existing settings.json?"),
+          chalk227.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -32755,23 +32841,23 @@ var selectionSchema = z9.strictObject({
   removed: z9.array(z9.string().trim().min(1)).default([])
 });
 
-// src/commands/transcript/stripProfanityFromText.ts
+// src/commands/transcript/widenAudienceInText.ts
 var INTERJECTION = /(?<=^|["',;:.!?—–…])\s*(?:oh,?\s+)?(?:fucking hell|bloody hell|fucking|fuck|shit)(?:\s*[.!?,…]+|\s*$)/gi;
 var WH_EMPHASIS = /\b(whatever|whoever|wherever|whenever|however|what|who|whom|where|when|why|how|which)\s+the\s+(?:fuck|hell|heck)\b/gi;
 var INTENSIFIER = /\b(?:fucking|fuckin'?|(?:god)?damn(?:ed)?)\s+(?=[a-z0-9])(?!(?:it|if|around|about|with|up|off|over|out)\b)/gi;
 function tidy(text18) {
   return text18.replace(/\s+/g, " ").replace(/\s+([,.;:!?])/g, "$1").replace(/,(?=\s*[.!?])/g, "").replace(/^[\s,;:]+/, "").replace(/[\s,;:]+$/, "");
 }
-function stripProfanityFromText(text18) {
+function widenAudienceInText(text18) {
   const stripped = text18.replace(INTERJECTION, " ").replace(WH_EMPHASIS, "$1").replace(INTENSIFIER, "");
   return stripped === text18 ? text18 : tidy(stripped);
 }
 
-// src/commands/transcript/stripProfanity.ts
+// src/commands/transcript/widenAudience.ts
 function strip(cues) {
-  return cues.map((cue) => ({ ...cue, text: stripProfanityFromText(cue.text) })).filter((cue) => /[a-z0-9]/i.test(cue.text));
+  return cues.map((cue) => ({ ...cue, text: widenAudienceInText(cue.text) })).filter((cue) => /[a-z0-9]/i.test(cue.text));
 }
-function stripProfanity(passages) {
+function widenAudience(passages) {
   return passages.map((passage) => ({ ...passage, cues: strip(passage.cues) })).filter((passage) => passage.cues.length > 0).map((passage) => ({ ...passage, sourceStartMs: passage.cues[0].startMs }));
 }
 
@@ -32798,7 +32884,7 @@ async function merge(files, options2 = {}) {
   const selection = await readSelection(options2.select);
   const selected = selection ? selectPassages(sources, selection) : wholePassages(sources);
   const passages = rebasePassages(
-    options2.stripProfanity ? stripProfanity(selected) : selected
+    options2.widenAudience ? widenAudience(selected) : selected
   );
   const provenance = options2.provenance !== false;
   const document = formatVttPassages(
@@ -32826,8 +32912,8 @@ function registerMergeCommand(cmd) {
     "--no-provenance",
     "omit every NOTE: the Collapsed-from header, the per-passage source marks and the removed count"
   ).option(
-    "--strip-profanity",
-    "delete profanity that carries no meaning: intensifiers, the fuck/the hell after a wh-word, standalone interjections and cues that are nothing but an expletive"
+    "--widen-audience",
+    "delete the casual asides that fit the people in the call but not a reader who was not there: intensifiers, emphasis after a wh-word, standalone interjections and cues that are nothing but one"
   ).action(merge);
 }
 
@@ -32851,9 +32937,11 @@ function transcriptWorkflowHelp() {
     "            removal count and each passage's original start survive as NOTE blocks.",
     "            Add --no-provenance when the merged file leaves for somewhere the source",
     "            names and cut points should not follow.",
-    "            Add --strip-profanity to delete the profanity that carries nothing \u2014",
-    "            intensifiers, the fuck/the hell after a wh-word, standalone interjections",
-    "            and whole-expletive cues. Load-bearing uses are left for you to judge."
+    "            Add --widen-audience when the transcript is going to readers who were",
+    "            not in the call: the casual asides pitched at the people who were \u2014",
+    "            intensifiers, emphasis after a wh-word, standalone interjections and",
+    "            cues that are nothing but one \u2014 are deleted. Anything carrying meaning",
+    "            is left for you to judge."
   ].join("\n");
 }
 
@@ -33885,7 +33973,7 @@ function registerWatch(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk226 from "chalk";
+import chalk228 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -34016,13 +34104,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk226.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk228.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk226.white("http://localhost:14523/callback\n"));
-  console.log(chalk226.blue("Opening browser for authorization..."));
-  console.log(chalk226.dim("Waiting for authorization callback..."));
+  console.log(chalk228.white("http://localhost:14523/callback\n"));
+  console.log(chalk228.blue("Opening browser for authorization..."));
+  console.log(chalk228.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk226.dim("Exchanging code for tokens..."));
+  console.log(chalk228.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -34038,7 +34126,7 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk226.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk228.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
@@ -34397,7 +34485,7 @@ import { execSync as execSync61 } from "child_process";
 import { existsSync as existsSync83, mkdirSync as mkdirSync33, unlinkSync as unlinkSync22, writeFileSync as writeFileSync51 } from "fs";
 import { tmpdir as tmpdir9 } from "os";
 import { join as join96, resolve as resolve21 } from "path";
-import chalk227 from "chalk";
+import chalk229 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -34548,13 +34636,13 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve21(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk227.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk229.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk227.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk229.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk227.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk229.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -40514,7 +40602,7 @@ async function renameSession(title) {
 
 // src/commands/sessions/summarise/index.ts
 import * as fs56 from "fs";
-import chalk228 from "chalk";
+import chalk230 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs55 from "fs";
@@ -40573,22 +40661,22 @@ ${firstMessage}`);
 async function summarise2(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk228.yellow("No sessions found."));
+    console.log(chalk230.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk228.green("All sessions already summarised."));
+    console.log(chalk230.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk228.cyan(
+    chalk230.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk228.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk228.yellow(`, ${failed2} skipped`) : "")
+    chalk230.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk230.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -40608,16 +40696,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk228.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk230.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk228.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk230.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk228.yellow("skip")}
+      process.stdout.write(` ${chalk230.yellow("skip")}
 `);
     }
   }
@@ -40644,7 +40732,7 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk230 from "chalk";
+import chalk232 from "chalk";
 
 // src/shared/contextLevel.ts
 function contextLevel(pct) {
@@ -40654,7 +40742,7 @@ function contextLevel(pct) {
 }
 
 // src/commands/buildLimitsSegment.ts
-import chalk229 from "chalk";
+import chalk231 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -40692,9 +40780,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk229.green,
-  warn: chalk229.yellow,
-  over: chalk229.red
+  ok: chalk231.green,
+  warn: chalk231.yellow,
+  over: chalk231.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -40790,7 +40878,7 @@ async function relayUsage(claudeSessionId, transcriptPath2, usedPct) {
 }
 
 // src/commands/statusLine.ts
-chalk230.level = 3;
+chalk232.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
@@ -40798,9 +40886,9 @@ function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
   switch (contextLevel(pct)) {
     case "red":
-      return chalk230.red(label2);
+      return chalk232.red(label2);
     case "yellow":
-      return chalk230.yellow(label2);
+      return chalk232.yellow(label2);
     default:
       return label2;
   }
@@ -40813,7 +40901,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 ${chalk230.cyan(branch2)} | ` : "";
+  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk232.cyan(branch2)} | ` : "";
   console.log(
     `${branchSegment}${model} | Tokens - ${formatNumber(totalIn)} \u2191 : ${formatNumber(totalOut)} \u2193 | Context - ${colorizePercent(usedPct)}${buildLimitsSegment(data.rate_limits)}`
   );
@@ -40883,10 +40971,10 @@ async function update2() {
 }
 
 // src/reportCliError.ts
-import chalk231 from "chalk";
+import chalk233 from "chalk";
 function reportCliError(error) {
   if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError || error instanceof MissingRunCwdError || error instanceof MiroExtractError) {
-    console.error(chalk231.red(error.message));
+    console.error(chalk233.red(error.message));
   } else {
     console.error(error);
   }
@@ -40945,6 +41033,7 @@ registerDotnet(program);
 registerNews(program);
 registerNetcap(program);
 registerCriteriaExtension(program);
+registerLitellm(program);
 registerRavendb(program);
 registerSeq(program);
 registerSlack(program);