@staff0rd/assist 0.294.0 → 0.295.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.294.0",
+  version: "0.295.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -384,6 +384,7 @@ import {
 
 // src/commands/backlog/backlogSchema.ts
 import {
+  boolean,
   foreignKey,
   index,
   integer,
@@ -401,7 +402,8 @@ var items = pgTable(
     description: text(),
     acceptanceCriteria: text("acceptance_criteria").notNull().default("[]"),
     status: text().notNull().default("todo"),
-    currentPhase: integer("current_phase")
+    currentPhase: integer("current_phase"),
+    starred: boolean().notNull().default(false)
   },
   (t) => [index("items_origin_idx").on(t.origin)]
 );
@@ -482,9 +484,13 @@ var SCHEMA = `
 		description TEXT,
 		acceptance_criteria TEXT NOT NULL DEFAULT '[]',
 		status TEXT NOT NULL DEFAULT 'todo',
-		current_phase INTEGER
+		current_phase INTEGER,
+		starred BOOLEAN NOT NULL DEFAULT false
 	);
 
+	-- Backfill the column on databases created before it was introduced.
+	ALTER TABLE items ADD COLUMN IF NOT EXISTS starred BOOLEAN NOT NULL DEFAULT false;
+
 	CREATE INDEX IF NOT EXISTS items_origin_idx ON items (origin);
 
 	CREATE TABLE IF NOT EXISTS comments (
@@ -2988,6 +2994,9 @@ function statusIcon(status2) {
       return chalk27.dim("[-]");
   }
 }
+function starMarker(item) {
+  return item.starred ? `${chalk27.yellow("\u2605")} ` : "";
+}
 function typeLabel(type) {
   switch (type) {
     case "bug":
@@ -3093,8 +3102,8 @@ import chalk31 from "chalk";
 
 // src/commands/backlog/deleteItem.ts
 import { eq } from "drizzle-orm";
-async function deleteItem(orm, id) {
-  const [row] = await orm.delete(items).where(eq(items.id, id)).returning({ name: items.name });
+async function deleteItem(orm, id2) {
+  const [row] = await orm.delete(items).where(eq(items.id, id2)).returning({ name: items.name });
   return row?.name;
 }
 
@@ -3146,7 +3155,8 @@ function itemColumns(item, origin) {
     description: item.description ?? null,
     acceptanceCriteria: JSON.stringify(item.acceptanceCriteria),
     status: item.status,
-    currentPhase: item.currentPhase ?? null
+    currentPhase: item.currentPhase ?? null,
+    starred: item.starred
   };
 }
 
@@ -3321,22 +3331,23 @@ function baseItem(row) {
     name: row.name,
     acceptanceCriteria: JSON.parse(row.acceptanceCriteria),
     status: row.status,
+    starred: row.starred,
     origin: row.origin
   };
   assignOptionalColumns(item, row);
   return item;
 }
-function attachComments(item, rel, id) {
-  const comments3 = (rel.comments.get(id) ?? []).map(rowToComment);
+function attachComments(item, rel, id2) {
+  const comments3 = (rel.comments.get(id2) ?? []).map(rowToComment);
   if (comments3.length > 0) item.comments = comments3;
 }
-function attachLinks(item, rel, id) {
-  const links2 = (rel.links.get(id) ?? []).map(rowToLink);
+function attachLinks(item, rel, id2) {
+  const links2 = (rel.links.get(id2) ?? []).map(rowToLink);
   if (links2.length > 0) item.links = links2;
 }
-function attachPlan(item, rel, id) {
-  const phases = rel.phases.get(id) ?? [];
-  if (phases.length > 0) item.plan = buildPlan(phases, rel.tasks.get(id) ?? []);
+function attachPlan(item, rel, id2) {
+  const phases = rel.phases.get(id2) ?? [];
+  if (phases.length > 0) item.plan = buildPlan(phases, rel.tasks.get(id2) ?? []);
 }
 function rowToItem(row, rel) {
   const item = baseItem(row);
@@ -3394,6 +3405,7 @@ var backlogItemSchema = z3.strictObject({
   acceptanceCriteria: z3.array(z3.string()),
   plan: z3.array(planPhaseSchema).optional(),
   currentPhase: z3.number().optional(),
+  starred: z3.boolean().default(false),
   status: backlogStatusSchema,
   comments: z3.array(backlogCommentSchema).optional(),
   links: z3.array(backlogLinkSchema).optional(),
@@ -3530,10 +3542,10 @@ function getCurrentOrigin(cwd) {
 
 // src/commands/backlog/loadItem.ts
 import { eq as eq3 } from "drizzle-orm";
-async function loadItem(orm, id) {
-  const [row] = await orm.select().from(items).where(eq3(items.id, id));
+async function loadItem(orm, id2) {
+  const [row] = await orm.select().from(items).where(eq3(items.id, id2));
   if (!row) return void 0;
-  const rel = await loadRelations(orm, [id]);
+  const rel = await loadRelations(orm, [id2]);
   return rowToItem(row, rel);
 }
 
@@ -3564,14 +3576,14 @@ async function searchItemIds(orm, query, origin) {
 
 // src/commands/backlog/updateCurrentPhase.ts
 import { eq as eq7 } from "drizzle-orm";
-async function updateCurrentPhase(orm, id, phase) {
-  await orm.update(items).set({ currentPhase: phase }).where(eq7(items.id, id));
+async function updateCurrentPhase(orm, id2, phase) {
+  await orm.update(items).set({ currentPhase: phase }).where(eq7(items.id, id2));
 }
 
 // src/commands/backlog/updateStatus.ts
 import { eq as eq8 } from "drizzle-orm";
-async function updateStatus(orm, id, status2) {
-  const [row] = await orm.update(items).set({ status: status2 }).where(eq8(items.id, id)).returning({ name: items.name });
+async function updateStatus(orm, id2, status2) {
+  const [row] = await orm.update(items).set({ status: status2 }).where(eq8(items.id, id2)).returning({ name: items.name });
   return row?.name;
 }
 
@@ -3603,35 +3615,35 @@ async function searchBacklog(query) {
   const allItems = await loadAllItems(orm, origin);
   return allItems.filter((item) => ids.includes(item.id));
 }
-async function findOneItem(id) {
-  const numId = Number.parseInt(id, 10);
+async function findOneItem(id2) {
+  const numId = Number.parseInt(id2, 10);
   const { orm } = await getReady();
   const item = Number.isNaN(numId) ? void 0 : await loadItem(orm, numId);
   if (!item) {
-    console.log(chalk31.red(`Item #${id} not found.`));
+    console.log(chalk31.red(`Item #${id2} not found.`));
     return void 0;
   }
   return { orm, item };
 }
-async function setStatus(id, status2) {
+async function setStatus(id2, status2) {
   const { orm } = await getReady();
-  const name = await updateStatus(orm, Number.parseInt(id, 10), status2);
-  if (name === void 0) console.log(chalk31.red(`Item #${id} not found.`));
+  const name = await updateStatus(orm, Number.parseInt(id2, 10), status2);
+  if (name === void 0) console.log(chalk31.red(`Item #${id2} not found.`));
   return name;
 }
-async function setCurrentPhase(id, phase) {
+async function setCurrentPhase(id2, phase) {
   const { orm } = await getReady();
-  await updateCurrentPhase(orm, Number.parseInt(id, 10), phase);
+  await updateCurrentPhase(orm, Number.parseInt(id2, 10), phase);
 }
-async function removeItem(id) {
+async function removeItem(id2) {
   const { orm } = await getReady();
-  const name = await deleteItem(orm, Number.parseInt(id, 10));
-  if (name === void 0) console.log(chalk31.red(`Item #${id} not found.`));
+  const name = await deleteItem(orm, Number.parseInt(id2, 10));
+  if (name === void 0) console.log(chalk31.red(`Item #${id2} not found.`));
   return name;
 }
 
 // src/commands/backlog/handleReviewResult.ts
-async function handleReviewResult(id, review2) {
+async function handleReviewResult(id2, review2) {
   if (review2.kind === "fail" || review2.kind === "abort")
     return { kind: "stop", success: false };
   if (review2.kind === "paused") return { kind: "stop", success: true };
@@ -3641,12 +3653,12 @@ async function handleReviewResult(id, review2) {
       startPhase: review2.targetPhase,
       plan: review2.plan
     };
-  await ensureDone(id);
+  await ensureDone(id2);
   return { kind: "stop", success: true };
 }
-async function ensureDone(id) {
+async function ensureDone(id2) {
   try {
-    await setStatus(id, "done");
+    await setStatus(id2, "done");
   } catch {
   }
 }
@@ -3668,20 +3680,20 @@ function resolvePlan(item) {
 }
 
 // src/commands/backlog/prepareRun.ts
-async function prepareRun(id) {
-  const found = await findOneItem(id);
+async function prepareRun(id2) {
+  const found = await findOneItem(id2);
   if (!found) return void 0;
   const { item } = found;
   const plan2 = resolvePlan(item);
   const startPhase = (item.currentPhase ?? 1) - 1;
   if (item.status === "done") {
-    console.log(chalk32.green(`Already done: #${id}: ${item.name}`));
+    console.log(chalk32.green(`Already done: #${id2}: ${item.name}`));
     return void 0;
   }
   if (startPhase > plan2.length) {
-    await setStatus(id, "done");
+    await setStatus(id2, "done");
     console.log(
-      chalk32.green(`All phases already complete for #${id}: ${item.name}`)
+      chalk32.green(`All phases already complete for #${id2}: ${item.name}`)
     );
     return void 0;
   }
@@ -3770,10 +3782,10 @@ function buildCommentLines(comments3) {
   return ["", "Comments:", ...comments3.map(formatPromptComment)];
 }
 function formatPromptComment(entry) {
-  const id = entry.id !== void 0 ? `#${entry.id} ` : "";
+  const id2 = entry.id !== void 0 ? `#${entry.id} ` : "";
   const tag = entry.type === "summary" ? "[summary]" : "[comment]";
   const phase = entry.phase !== void 0 ? ` (phase ${entry.phase})` : "";
-  return `${id}${tag}${phase} ${entry.timestamp}
+  return `${id2}${tag}${phase} ${entry.timestamp}
   ${entry.text}`;
 }
 
@@ -4005,8 +4017,8 @@ async function executePhase(item, phaseIndex, phases, spawnOptions, totalPhases
 }
 
 // src/commands/backlog/reloadPlan.ts
-async function reloadPlan(id) {
-  const found = await findOneItem(String(id));
+async function reloadPlan(id2) {
+  const found = await findOneItem(String(id2));
   if (!found) return void 0;
   return resolvePlan(found.item);
 }
@@ -4073,15 +4085,15 @@ async function runOnce(item, startPhase, plan2, spawnOptions) {
 }
 
 // src/commands/backlog/run.ts
-async function run2(id, spawnOptions) {
+async function run2(id2, spawnOptions) {
   if (blockedByHandover()) return false;
-  const prepared = await prepareRun(id);
+  const prepared = await prepareRun(id2);
   if (!prepared) return false;
-  await setStatus(id, "in-progress");
-  logProgress(id, prepared);
-  return runPrepared(id, prepared, spawnOptions);
+  await setStatus(id2, "in-progress");
+  logProgress(id2, prepared);
+  return runPrepared(id2, prepared, spawnOptions);
 }
-async function runPrepared(id, prepared, spawnOptions) {
+async function runPrepared(id2, prepared, spawnOptions) {
   const { item } = prepared;
   let { plan: plan2, startPhase } = prepared;
   acquireLock(item.id);
@@ -4089,7 +4101,7 @@ async function runPrepared(id, prepared, spawnOptions) {
     while (true) {
       const review2 = await runOnce(item, startPhase, plan2, spawnOptions);
       spawnOptions = withoutResumeSession(spawnOptions);
-      const outcome = await handleReviewResult(id, review2);
+      const outcome = await handleReviewResult(id2, review2);
       if (outcome.kind === "stop") return outcome.success;
       startPhase = outcome.startPhase;
       plan2 = outcome.plan;
@@ -4098,8 +4110,8 @@ async function runPrepared(id, prepared, spawnOptions) {
     releaseLock(item.id);
   }
 }
-function logProgress(id, { plan: plan2, startPhase, item }) {
-  console.log(chalk35.bold(`Running plan for #${id}: ${item.name}`));
+function logProgress(id2, { plan: plan2, startPhase, item }) {
+  console.log(chalk35.bold(`Running plan for #${id2}: ${item.name}`));
   const totalPhases = plan2.length + 1;
   if (startPhase > 0) {
     const phaseNumber = startPhase + 1;
@@ -4157,11 +4169,11 @@ async function next(options2, startId) {
   let pendingId = startId;
   let firstPick = true;
   while (true) {
-    const id = pendingId ?? await pickItem(await loadBacklog(), firstPick);
+    const id2 = pendingId ?? await pickItem(await loadBacklog(), firstPick);
     pendingId = void 0;
     firstPick = false;
-    if (id === void 0) return;
-    const completed = await run2(id, options2);
+    if (id2 === void 0) return;
+    const completed = await run2(id2, options2);
     if (!completed || options2?.once) return;
   }
 }
@@ -4184,16 +4196,16 @@ async function appendComment(orm, itemId, text3, opts = {}) {
 
 // src/commands/backlog/getItemStatus.ts
 import { eq as eq9 } from "drizzle-orm";
-async function getItemStatus(orm, id) {
-  const [row] = await orm.select({ status: items.status }).from(items).where(eq9(items.id, id));
+async function getItemStatus(orm, id2) {
+  const [row] = await orm.select({ status: items.status }).from(items).where(eq9(items.id, id2));
   return row?.status;
 }
 
 // src/commands/backlog/phaseDone.ts
-async function phaseDone(id, phase, summary) {
+async function phaseDone(id2, phase, summary) {
   const phaseNumber = Number.parseInt(phase, 10);
   const phaseIndex = phaseNumber - 1;
-  const itemId = Number.parseInt(id, 10);
+  const itemId = Number.parseInt(id2, 10);
   writeSignal("phase-done", {
     itemId,
     phaseIndex,
@@ -4202,27 +4214,27 @@ async function phaseDone(id, phase, summary) {
   const { orm } = await getReady();
   const status2 = await getItemStatus(orm, itemId);
   if (status2 === void 0) {
-    console.log(chalk37.red(`Item #${id} not found.`));
+    console.log(chalk37.red(`Item #${id2} not found.`));
     return;
   }
   if (status2 === "done") {
-    console.log(chalk37.dim(`Item #${id} already done, skipping phase advance.`));
+    console.log(chalk37.dim(`Item #${id2} already done, skipping phase advance.`));
     return;
   }
   await appendComment(orm, itemId, summary, {
     phase: phaseNumber,
     type: "summary"
   });
-  await setCurrentPhase(id, phaseNumber + 1);
+  await setCurrentPhase(id2, phaseNumber + 1);
   console.log(
-    chalk37.green(`Phase ${phaseNumber} of item #${id} marked as complete.`)
+    chalk37.green(`Phase ${phaseNumber} of item #${id2} marked as complete.`)
   );
 }
 
 // src/commands/backlog/plan.ts
 import chalk38 from "chalk";
-async function plan(id) {
-  const found = await findOneItem(id);
+async function plan(id2) {
+  const found = await findOneItem(id2);
   if (!found) return;
   const { item } = found;
   if (!item.plan || item.plan.length === 0) {
@@ -4246,11 +4258,11 @@ import chalk42 from "chalk";
 // src/commands/backlog/formatComment.ts
 import chalk39 from "chalk";
 function formatComment(entry) {
-  const id = entry.id !== void 0 ? chalk39.dim(`#${entry.id} `) : "";
+  const id2 = entry.id !== void 0 ? chalk39.dim(`#${entry.id} `) : "";
   const tag = entry.type === "summary" ? chalk39.magenta("[summary]") : chalk39.cyan("[comment]");
   const phase = entry.phase !== void 0 ? chalk39.dim(` (phase ${entry.phase})`) : "";
   const time = chalk39.dim(entry.timestamp);
-  return `${id}${tag}${phase} ${time}
+  return `${id2}${tag}${phase} ${time}
   ${entry.text}`;
 }
 
@@ -4343,8 +4355,8 @@ function printAcceptanceCriteria(criteria) {
   }
   console.log();
 }
-async function show(id) {
-  const found = await findOneItem(id);
+async function show(id2) {
+  const found = await findOneItem(id2);
   if (!found) process.exit(1);
   const { orm, item } = found;
   printHeader(item);
@@ -4457,10 +4469,10 @@ function parseRoute(req, port) {
   const url = new URL(req.url ?? "/", `http://localhost:${port}`);
   return { method: req.method ?? "GET", pathname: url.pathname };
 }
-function createRouteHandler(routes2) {
+function createRouteHandler(routes3) {
   return async (req, res, port) => {
     const { method, pathname } = parseRoute(req, port);
-    const handler = routes2[`${method} ${pathname}`];
+    const handler = routes3[`${method} ${pathname}`];
     if (handler) {
       await handler(req, res);
       return;
@@ -4622,12 +4634,12 @@ function createBundleHandler(importMetaUrl, bundlePath) {
 }
 
 // src/shared/createFallbackHandler.ts
-function createFallbackHandler(routes2, htmlHandler2, extra) {
-  const baseHandler = createRouteHandler(routes2);
+function createFallbackHandler(routes3, htmlHandler2, extra) {
+  const baseHandler = createRouteHandler(routes3);
   return async (req, res, port) => {
     const { method, pathname } = parseRoute(req, port);
     if (extra && await extra(req, res, pathname)) return;
-    if (routes2[`${method} ${pathname}`]) {
+    if (routes3[`${method} ${pathname}`]) {
       await baseHandler(req, res, port);
       return;
     }
@@ -4650,14 +4662,16 @@ async function loadItemSummaries(orm, origin) {
     origin: items.origin,
     type: items.type,
     name: items.name,
-    status: items.status
+    status: items.status,
+    starred: items.starred
   }).from(items).where(origin === void 0 ? void 0 : eq10(items.origin, origin)).orderBy(asc5(items.id));
   return rows.map((row) => ({
     id: row.id,
     origin: row.origin,
     type: row.type,
     name: row.name,
-    status: row.status
+    status: row.status,
+    starred: row.starred
   }));
 }
 
@@ -4691,8 +4705,32 @@ async function getBacklogExists(req, res) {
   respondJson(res, 200, { exists: await backlogHasItems() });
 }
 
-// src/commands/backlog/web/rewindItemPhase.ts
+// src/commands/backlog/deleteComment.ts
+import { and as and2, eq as eq12 } from "drizzle-orm";
+async function deleteComment(orm, itemId, commentId) {
+  const [row] = await orm.select({ type: comments.type }).from(comments).where(and2(eq12(comments.id, commentId), eq12(comments.itemId, itemId)));
+  if (!row) return "not-found";
+  if (row.type === "summary") return "is-summary";
+  await orm.delete(comments).where(and2(eq12(comments.id, commentId), eq12(comments.itemId, itemId)));
+  return "deleted";
+}
+
+// src/commands/backlog/updateStarred.ts
 import { eq as eq13 } from "drizzle-orm";
+async function updateStarred(orm, id2, starred) {
+  const [row] = await orm.update(items).set({ starred }).where(eq13(items.id, id2)).returning({ name: items.name });
+  return row?.name;
+}
+
+// src/commands/backlog/web/loadVisibleItems.ts
+var completedStatuses = /* @__PURE__ */ new Set(["done", "wontdo"]);
+async function loadVisibleItems(req) {
+  const params = new URL(req.url ?? "/", "http://localhost").searchParams;
+  const q = params.get("q");
+  const loaded = q ? await searchBacklogSummaries(q) : await loadBacklogSummaries();
+  if (params.get("showCompleted") === "true") return loaded;
+  return loaded.filter((item) => !completedStatuses.has(item.status));
+}
 
 // src/commands/backlog/web/parseItemBody.ts
 function readBody(req) {
@@ -4714,25 +4752,8 @@ async function parseStatusBody(req) {
 async function parseRewindBody(req) {
   return JSON.parse(await readBody(req));
 }
-
-// src/commands/backlog/deleteComment.ts
-import { and as and2, eq as eq12 } from "drizzle-orm";
-async function deleteComment(orm, itemId, commentId) {
-  const [row] = await orm.select({ type: comments.type }).from(comments).where(and2(eq12(comments.id, commentId), eq12(comments.itemId, itemId)));
-  if (!row) return "not-found";
-  if (row.type === "summary") return "is-summary";
-  await orm.delete(comments).where(and2(eq12(comments.id, commentId), eq12(comments.itemId, itemId)));
-  return "deleted";
-}
-
-// src/commands/backlog/web/loadVisibleItems.ts
-var completedStatuses = /* @__PURE__ */ new Set(["done", "wontdo"]);
-async function loadVisibleItems(req) {
-  const params = new URL(req.url ?? "/", "http://localhost").searchParams;
-  const q = params.get("q");
-  const loaded = q ? await searchBacklogSummaries(q) : await loadBacklogSummaries();
-  if (params.get("showCompleted") === "true") return loaded;
-  return loaded.filter((item) => !completedStatuses.has(item.status));
+async function parseStarBody(req) {
+  return JSON.parse(await readBody(req));
 }
 
 // src/commands/backlog/web/shared.ts
@@ -4741,25 +4762,43 @@ async function listItems(req, res) {
   const items2 = await loadVisibleItems(req);
   respondJson(res, 200, items2.slice().reverse());
 }
-async function findItemOr404(res, id) {
+async function findItemOr404(res, id2) {
   const { orm } = await getReady();
-  const item = await loadItem(orm, id);
+  const item = await loadItem(orm, id2);
   if (!item) {
     respondJson(res, 404, { error: "Not found" });
     return void 0;
   }
   return { orm, item };
 }
-async function getItemById(res, id) {
-  const result = await findItemOr404(res, id);
+async function getItemById(res, id2) {
+  const result = await findItemOr404(res, id2);
   if (result) respondJson(res, 200, result.item);
 }
-async function deleteItem2(res, id) {
-  const result = await findItemOr404(res, id);
+async function deleteItem2(res, id2) {
+  const result = await findItemOr404(res, id2);
   if (!result) return;
-  await deleteItem(result.orm, id);
+  await deleteItem(result.orm, id2);
   respondJson(res, 200, result.item);
 }
+async function patchItemStatus(req, res, id2) {
+  const { status: status2 } = await parseStatusBody(req);
+  const result = await findItemOr404(res, id2);
+  if (!result) return;
+  await updateStatus(result.orm, id2, status2);
+  const updated = { ...result.item, status: status2 };
+  respondJson(res, 200, updated);
+}
+async function patchItemStar(req, res, id2) {
+  const { starred } = await parseStarBody(req);
+  const result = await findItemOr404(res, id2);
+  if (!result) return;
+  await updateStarred(result.orm, id2, starred);
+  const updated = { ...result.item, starred };
+  respondJson(res, 200, updated);
+}
+
+// src/commands/backlog/web/deleteItemComment.ts
 async function deleteItemComment(res, itemId, commentId) {
   const result = await findItemOr404(res, itemId);
   if (!result) return;
@@ -4778,19 +4817,12 @@ async function deleteItemComment(res, itemId, commentId) {
   }
   respondJson(res, 200, await loadItem(result.orm, itemId));
 }
-async function patchItemStatus(req, res, id) {
-  const { status: status2 } = await parseStatusBody(req);
-  const result = await findItemOr404(res, id);
-  if (!result) return;
-  await updateStatus(result.orm, id, status2);
-  const updated = { ...result.item, status: status2 };
-  respondJson(res, 200, updated);
-}
 
 // src/commands/backlog/web/rewindItemPhase.ts
-async function rewindItemPhase(req, res, id) {
+import { eq as eq14 } from "drizzle-orm";
+async function rewindItemPhase(req, res, id2) {
   const { phase, reason } = await parseRewindBody(req);
-  const result = await findItemOr404(res, id);
+  const result = await findItemOr404(res, id2);
   if (!result) return;
   const { orm, item } = result;
   const error = validateRewind(item, phase);
@@ -4801,12 +4833,12 @@ async function rewindItemPhase(req, res, id) {
   const phaseName = item.plan?.[phase - 1].name;
   await appendComment(
     orm,
-    id,
+    id2,
     `Rewound to phase ${phase} (${phaseName}): ${reason}`,
     { phase }
   );
-  await orm.update(items).set({ currentPhase: phase, status: "in-progress" }).where(eq13(items.id, id));
-  respondJson(res, 200, await loadItem(orm, id));
+  await orm.update(items).set({ currentPhase: phase, status: "in-progress" }).where(eq14(items.id, id2));
+  respondJson(res, 200, await loadItem(orm, id2));
 }
 function validateRewind(item, phase) {
   if (!item.plan || item.plan.length === 0) {
@@ -4823,10 +4855,10 @@ function validateRewind(item, phase) {
 }
 
 // src/commands/backlog/web/updateItem.ts
-import { eq as eq14 } from "drizzle-orm";
-async function updateItem(req, res, id) {
+import { eq as eq15 } from "drizzle-orm";
+async function updateItem(req, res, id2) {
   const body = await parseItemBody(req);
-  const result = await findItemOr404(res, id);
+  const result = await findItemOr404(res, id2);
   if (!result) return;
   const { orm } = result;
   await orm.update(items).set({
@@ -4834,41 +4866,59 @@ async function updateItem(req, res, id) {
     name: body.name,
     description: body.description ?? null,
     acceptanceCriteria: JSON.stringify(body.acceptanceCriteria ?? [])
-  }).where(eq14(items.id, id));
-  respondJson(res, 200, await loadItem(orm, id));
+  }).where(eq15(items.id, id2));
+  respondJson(res, 200, await loadItem(orm, id2));
 }
 
 // src/commands/backlog/web/handleItemRoute.ts
-var itemRoutes = {
-  GET: (_req, res, id) => getItemById(res, id),
-  PUT: (req, res, id) => updateItem(req, res, id),
-  PATCH: (req, res, id) => patchItemStatus(req, res, id),
-  DELETE: (_req, res, id) => deleteItem2(res, id)
-};
-async function handleItemRoute(req, res, pathname) {
-  const rewindMatch = pathname.match(/^\/api\/items\/(\d+)\/rewind$/);
-  if (rewindMatch && req.method === "POST") {
-    applyCwdFromReq(req);
-    await rewindItemPhase(req, res, Number.parseInt(rewindMatch[1], 10));
-    return true;
+var id = (match, group = 1) => Number.parseInt(match[group], 10);
+var routes = [
+  {
+    pattern: /^\/api\/items\/(\d+)\/rewind$/,
+    method: "POST",
+    run: (req, res, m) => rewindItemPhase(req, res, id(m))
+  },
+  {
+    pattern: /^\/api\/items\/(\d+)\/star$/,
+    method: "POST",
+    run: (req, res, m) => patchItemStar(req, res, id(m))
+  },
+  {
+    pattern: /^\/api\/items\/(\d+)\/comments\/(\d+)$/,
+    method: "DELETE",
+    run: (_req, res, m) => deleteItemComment(res, id(m), id(m, 2))
+  },
+  {
+    pattern: /^\/api\/items\/(\d+)$/,
+    method: "GET",
+    run: (_req, res, m) => getItemById(res, id(m))
+  },
+  {
+    pattern: /^\/api\/items\/(\d+)$/,
+    method: "PUT",
+    run: (req, res, m) => updateItem(req, res, id(m))
+  },
+  {
+    pattern: /^\/api\/items\/(\d+)$/,
+    method: "PATCH",
+    run: (req, res, m) => patchItemStatus(req, res, id(m))
+  },
+  {
+    pattern: /^\/api\/items\/(\d+)$/,
+    method: "DELETE",
+    run: (_req, res, m) => deleteItem2(res, id(m))
   }
-  const commentMatch = pathname.match(/^\/api\/items\/(\d+)\/comments\/(\d+)$/);
-  if (commentMatch && req.method === "DELETE") {
-    applyCwdFromReq(req);
-    await deleteItemComment(
-      res,
-      Number.parseInt(commentMatch[1], 10),
-      Number.parseInt(commentMatch[2], 10)
-    );
-    return true;
+];
+async function handleItemRoute(req, res, pathname) {
+  for (const route of routes) {
+    const match = pathname.match(route.pattern);
+    if (match && req.method === route.method) {
+      applyCwdFromReq(req);
+      await route.run(req, res, match);
+      return true;
+    }
   }
-  const match = pathname.match(/^\/api\/items\/(\d+)$/);
-  if (!match) return false;
-  const handler = itemRoutes[req.method ?? "GET"];
-  if (!handler) return false;
-  applyCwdFromReq(req);
-  await handler(req, res, Number.parseInt(match[1], 10));
-  return true;
+  return false;
 }
 
 // src/commands/backlog/init/index.ts
@@ -5308,7 +5358,7 @@ function createCssHandler(packageEntry) {
   };
 }
 var htmlHandler = createHtmlHandler(getHtml);
-var routes = {
+var routes2 = {
   "GET /": htmlHandler,
   "GET /bundle.js": createBundleHandler(
     import.meta.url,
@@ -5325,7 +5375,7 @@ var routes = {
   "GET /api/news/items": listNewsItems
 };
 var handleRequest = createFallbackHandler(
-  routes,
+  routes2,
   htmlHandler,
   handleItemRoute
 );
@@ -5335,14 +5385,14 @@ import { createInterface as createInterface2 } from "readline";
 
 // src/commands/sessions/daemon/toWindowsSessionId.ts
 var PREFIX = "w-";
-function toWindowsSessionId(id) {
-  return `${PREFIX}${id}`;
+function toWindowsSessionId(id2) {
+  return `${PREFIX}${id2}`;
 }
-function isWindowsSessionId(id) {
-  return id.startsWith(PREFIX);
+function isWindowsSessionId(id2) {
+  return id2.startsWith(PREFIX);
 }
-function stripWindowsSessionId(id) {
-  return id.startsWith(PREFIX) ? id.slice(PREFIX.length) : id;
+function stripWindowsSessionId(id2) {
+  return id2.startsWith(PREFIX) ? id2.slice(PREFIX.length) : id2;
 }
 
 // src/commands/sessions/web/ui/repoLabel.ts
@@ -5378,9 +5428,9 @@ function applySnapshot(known, sessions) {
     if (previous === void 0) logEvent("started", session);
     else if (isDone(session) && !isDone(previous)) logEvent("ended", session);
   }
-  for (const [id, session] of [...known]) {
-    if (present.has(id)) continue;
-    known.delete(id);
+  for (const [id2, session] of [...known]) {
+    if (present.has(id2)) continue;
+    known.delete(id2);
     if (!isDone(session)) logEvent("ended", session);
   }
 }
@@ -5736,25 +5786,25 @@ async function web2(options2) {
 
 // src/commands/backlog/comment/index.ts
 import chalk48 from "chalk";
-async function comment(id, text3) {
-  const found = await findOneItem(id);
+async function comment(id2, text3) {
+  const found = await findOneItem(id2);
   if (!found) process.exit(1);
   await appendComment(found.orm, found.item.id, text3);
-  console.log(chalk48.green(`Comment added to item #${id}.`));
+  console.log(chalk48.green(`Comment added to item #${id2}.`));
 }
 
 // src/commands/backlog/comments/index.ts
 import chalk49 from "chalk";
-async function comments2(id) {
-  const found = await findOneItem(id);
+async function comments2(id2) {
+  const found = await findOneItem(id2);
   if (!found) process.exit(1);
   const { item } = found;
   const entries = item.comments ?? [];
   if (entries.length === 0) {
-    console.log(chalk49.dim(`No comments on item #${id}.`));
+    console.log(chalk49.dim(`No comments on item #${id2}.`));
     return;
   }
-  console.log(chalk49.bold(`Comments for #${id}: ${item.name}
+  console.log(chalk49.bold(`Comments for #${id2}: ${item.name}
 `));
   for (const entry of entries) {
     console.log(`${formatComment(entry)}
@@ -5764,8 +5814,8 @@ async function comments2(id) {
 
 // src/commands/backlog/delete-comment/index.ts
 import chalk50 from "chalk";
-async function deleteCommentCmd(id, commentId) {
-  const found = await findOneItem(id);
+async function deleteCommentCmd(id2, commentId) {
+  const found = await findOneItem(id2);
   if (!found) process.exit(1);
   const outcome = await deleteComment(
     found.orm,
@@ -5775,11 +5825,11 @@ async function deleteCommentCmd(id, commentId) {
   switch (outcome) {
     case "deleted":
       console.log(
-        chalk50.green(`Comment #${commentId} deleted from item #${id}.`)
+        chalk50.green(`Comment #${commentId} deleted from item #${id2}.`)
       );
       break;
     case "not-found":
-      console.log(chalk50.red(`Comment #${commentId} not found on item #${id}.`));
+      console.log(chalk50.red(`Comment #${commentId} not found on item #${id2}.`));
       process.exit(1);
       break;
     case "is-summary":
@@ -6151,40 +6201,41 @@ async function add(options2) {
   const description = options2.desc?.replaceAll("\\n", "\n") ?? await promptDescription();
   const acceptanceCriteria2 = options2.ac ?? await promptAcceptanceCriteria();
   const orm = await getBacklogOrm();
-  const id = await insertItem(
+  const id2 = await insertItem(
     orm,
     {
       type,
       name,
       description: description || void 0,
       acceptanceCriteria: acceptanceCriteria2,
-      status: "todo"
+      status: "todo",
+      starred: false
     },
     getOrigin()
   );
-  console.log(chalk54.green(`Added item #${id}: ${name}`));
+  console.log(chalk54.green(`Added item #${id2}: ${name}`));
 }
 
 // src/commands/backlog/addPhase.ts
 import chalk56 from "chalk";
 
 // src/commands/backlog/insertPhaseAt.ts
-import { count, eq as eq16 } from "drizzle-orm";
+import { count, eq as eq17 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and3, desc, eq as eq15, gte } from "drizzle-orm";
+import { and as and3, desc, eq as eq16, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and3(eq15(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and3(eq16(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc(planPhases.idx));
   for (const p of toShift) {
-    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and3(eq15(planTasks.itemId, itemId), eq15(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and3(eq15(planPhases.itemId, itemId), eq15(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and3(eq16(planTasks.itemId, itemId), eq16(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and3(eq16(planPhases.itemId, itemId), eq16(planPhases.idx, p.idx)));
   }
 }
 
 // src/commands/backlog/insertPhaseAt.ts
 async function insertPhaseAt(orm, itemId, phaseIdx, name, tasks, manualChecks, currentPhase) {
   await orm.transaction(async (tx) => {
-    const [row] = await tx.select({ cnt: count() }).from(planPhases).where(eq16(planPhases.itemId, itemId));
+    const [row] = await tx.select({ cnt: count() }).from(planPhases).where(eq17(planPhases.itemId, itemId));
     const phaseCount = row?.cnt ?? 0;
     await shiftPhasesUp(tx, itemId, phaseIdx);
     await tx.insert(planPhases).values({ itemId, idx: phaseIdx, name, manualChecks });
@@ -6193,16 +6244,16 @@ async function insertPhaseAt(orm, itemId, phaseIdx, name, tasks, manualChecks, c
     }
     if (currentPhase !== void 0 && currentPhase - 1 >= phaseIdx) {
       const atReviewSlot = currentPhase - 1 >= phaseCount;
-      await tx.update(items).set({ currentPhase: atReviewSlot ? phaseIdx + 1 : currentPhase + 1 }).where(eq16(items.id, itemId));
+      await tx.update(items).set({ currentPhase: atReviewSlot ? phaseIdx + 1 : currentPhase + 1 }).where(eq17(items.id, itemId));
     }
   });
 }
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk55 from "chalk";
-import { count as count2, eq as eq17 } from "drizzle-orm";
+import { count as count2, eq as eq18 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId, position) {
-  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(eq17(planPhases.itemId, itemId));
+  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(eq18(planPhases.itemId, itemId));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -6224,8 +6275,8 @@ function serializeManualChecks(manualCheck) {
 }
 
 // src/commands/backlog/addPhase.ts
-async function addPhase(id, name, options2) {
-  const found = await findOneItem(id);
+async function addPhase(id2, name, options2) {
+  const found = await findOneItem(id2);
   if (!found) return;
   const tasks = options2.task ?? [];
   if (tasks.length === 0) {
@@ -6318,7 +6369,7 @@ async function list2(options2) {
   for (const item of items2) {
     const repoPrefix = options2.allRepos ? `${chalk57.dim(repoNameOf(item).padEnd(prefixWidth))} ` : "";
     console.log(
-      `${repoPrefix}${statusIcon(item.status)} ${typeLabel(item.type)} ${chalk57.dim(`#${item.id}`)} ${item.name}${phaseLabel(item)}${dependencyLabel(item, allItems)}`
+      `${repoPrefix}${statusIcon(item.status)} ${typeLabel(item.type)} ${chalk57.dim(`#${item.id}`)} ${starMarker(item)}${item.name}${phaseLabel(item)}${dependencyLabel(item, allItems)}`
     );
     if (options2.verbose) {
       printVerboseDetails(item);
@@ -6363,9 +6414,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq18 } from "drizzle-orm";
+import { eq as eq19 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq18(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq19(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId, targetId } of rows) {
     const bucket = graph.get(itemId);
@@ -6428,7 +6479,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk60 from "chalk";
-import { and as and4, eq as eq19 } from "drizzle-orm";
+import { and as and4, eq as eq20 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = Number.parseInt(fromId, 10);
   const toNum = Number.parseInt(toId, 10);
@@ -6446,7 +6497,7 @@ async function unlink(fromId, toId) {
     console.log(chalk60.yellow(`No link from #${fromId} to #${toId} found.`));
     return;
   }
-  await orm.delete(links).where(and4(eq19(links.itemId, fromNum), eq19(links.targetId, toNum)));
+  await orm.delete(links).where(and4(eq20(links.itemId, fromNum), eq20(links.targetId, toNum)));
   console.log(chalk60.green(`Removed link from #${fromId} to #${toId}.`));
 }
 
@@ -6462,7 +6513,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/move-repo/index.ts
 import chalk62 from "chalk";
-import { eq as eq21 } from "drizzle-orm";
+import { eq as eq22 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk61 from "chalk";
@@ -6477,9 +6528,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count3, eq as eq20 } from "drizzle-orm";
+import { count as count3, eq as eq21 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count3() }).from(items).where(eq20(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count3() }).from(items).where(eq21(items.origin, origin));
   return cnt;
 }
 
@@ -6522,7 +6573,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk62.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq21(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq22(items.origin, oldOrigin));
   console.log(
     chalk62.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -6542,7 +6593,7 @@ function registerMoveRepoCommand(cmd) {
 // src/commands/backlog/registerNextCommand.ts
 function registerNextCommand(cmd) {
   cmd.command("next").argument("[id]", "Backlog item ID to run first").description("Pick and run the next backlog item, or open /draft if none").option("-w, --write", "Run Claude with auto permission mode (default)").option("--no-write", "Run Claude without auto permission mode").option("--once", "Exit after the first completed item run").action(
-    (id, opts) => next({ allowEdits: opts.write !== false, once: opts.once }, id)
+    (id2, opts) => next({ allowEdits: opts.write !== false, once: opts.once }, id2)
   );
 }
 
@@ -6560,8 +6611,8 @@ import enquirer7 from "enquirer";
 import chalk64 from "chalk";
 
 // src/commands/backlog/surfaceCreatedItem.ts
-async function surfaceCreatedItem(slashCommand, id) {
-  const numericId = Number.parseInt(id, 10);
+async function surfaceCreatedItem(slashCommand, id2) {
+  const numericId = Number.parseInt(id2, 10);
   if (Number.isNaN(numericId)) return;
   const { orm } = await getReady();
   const item = await loadItem(orm, numericId);
@@ -6576,33 +6627,33 @@ async function surfaceCreatedItem(slashCommand, id) {
 
 // src/commands/backlog/tryRunById.ts
 import chalk63 from "chalk";
-async function tryRunById(id, options2) {
-  const numericId = Number.parseInt(id, 10);
+async function tryRunById(id2, options2) {
+  const numericId = Number.parseInt(id2, 10);
   const { orm } = await getReady();
   const item = Number.isNaN(numericId) ? void 0 : await loadItem(orm, numericId);
   if (!item) {
-    console.log(chalk63.red(`Item #${id} not found.`));
+    console.log(chalk63.red(`Item #${id2} not found.`));
     return false;
   }
   if (item.status === "done") {
-    console.log(chalk63.red(`Item #${id} is already done.`));
+    console.log(chalk63.red(`Item #${id2} is already done.`));
     return false;
   }
   if (item.status === "wontdo") {
-    console.log(chalk63.red(`Item #${id} is marked won't do.`));
+    console.log(chalk63.red(`Item #${id2} is marked won't do.`));
     return false;
   }
   const hasDeps = (item.links ?? []).some((l) => l.type === "depends-on");
   if (hasDeps && isBlocked(item, await loadItemSummaries(orm, getOrigin()))) {
     console.log(
-      chalk63.red(`Item #${id} is blocked by unresolved dependencies.`)
+      chalk63.red(`Item #${id2} is blocked by unresolved dependencies.`)
     );
     return false;
   }
   console.log(chalk63.bold(`
-Running backlog item #${id}...
+Running backlog item #${id2}...
 `));
-  await run2(id, options2);
+  await run2(id2, options2);
   return true;
 }
 
@@ -6668,8 +6719,8 @@ async function pickItemForRefine() {
   );
   return selected.match(/#(\d+)/)?.[1] ?? "";
 }
-async function refine(id, options2) {
-  const itemId = id ?? await pickItemForRefine();
+async function refine(id2, options2) {
+  const itemId = id2 ?? await pickItemForRefine();
   if (!itemId) return;
   const numericId = Number.parseInt(itemId, 10);
   const item = Number.isNaN(numericId) ? void 0 : await loadItem((await getReady()).orm, numericId);
@@ -6683,7 +6734,7 @@ async function refine(id, options2) {
 // src/commands/backlog/registerRefineCommand.ts
 function registerRefineCommand(cmd) {
   cmd.command("refine").argument("[id]", "Backlog item ID").description("Alias for refine").option("--once", "Exit when the initial task completes").action(
-    (id, opts) => refine(id, { once: opts.once })
+    (id2, opts) => refine(id2, { once: opts.once })
   );
 }
 
@@ -6702,13 +6753,13 @@ function validateRewind2(item, phaseNumber) {
   }
   return void 0;
 }
-async function rewindPhase(id, phase, opts) {
+async function rewindPhase(id2, phase, opts) {
   const phaseNumber = Number.parseInt(phase, 10);
   const phaseIndex = phaseNumber - 1;
   const { orm } = await getReady();
-  const item = await loadItem(orm, Number.parseInt(id, 10));
+  const item = await loadItem(orm, Number.parseInt(id2, 10));
   if (!item) {
-    console.log(chalk66.red(`Item #${id} not found.`));
+    console.log(chalk66.red(`Item #${id2} not found.`));
     return;
   }
   const error = validateRewind2(item, phaseNumber);
@@ -6724,14 +6775,14 @@ async function rewindPhase(id, phase, opts) {
     `Rewound to phase ${phaseNumber} (${phaseName}): ${opts.reason}`,
     { phase: phaseNumber }
   );
-  await setCurrentPhase(id, phaseNumber);
-  await setStatus(id, "in-progress");
+  await setCurrentPhase(id2, phaseNumber);
+  await setStatus(id2, "in-progress");
   writeSignal("rewind", {
-    itemId: Number.parseInt(id, 10),
+    itemId: Number.parseInt(id2, 10),
     targetPhase: phaseIndex
   });
   console.log(
-    chalk66.green(`Rewound item #${id} to phase ${phaseNumber} (${phaseName}).`)
+    chalk66.green(`Rewound item #${id2} to phase ${phaseNumber} (${phaseName}).`)
   );
 }
 
@@ -6746,9 +6797,9 @@ function registerRunCommand(cmd) {
     "--resume-session <id>",
     "Resume an interrupted Claude session for the current phase (used by the sessions daemon on restart)"
   ).action(
-    async (id, opts) => {
+    async (id2, opts) => {
       if (!opts.resumeSession) pullIfConfigured();
-      await run2(id, {
+      await run2(id2, {
         allowEdits: opts.write !== false,
         resumeSessionId: opts.resumeSession
       });
@@ -6784,17 +6835,17 @@ function registerSearchCommand(cmd) {
 
 // src/commands/backlog/delete/index.ts
 import chalk68 from "chalk";
-async function del(id) {
-  const name = await removeItem(id);
+async function del(id2) {
+  const name = await removeItem(id2);
   if (name) {
-    console.log(chalk68.green(`Deleted item #${id}: ${name}`));
+    console.log(chalk68.green(`Deleted item #${id2}: ${name}`));
   }
 }
 
 // src/commands/backlog/done/index.ts
 import chalk69 from "chalk";
-async function done(id, summary) {
-  const found = await findOneItem(id);
+async function done(id2, summary) {
+  const found = await findOneItem(id2);
   if (!found) return;
   const { orm, item } = found;
   if (item.plan && item.plan.length > 0) {
@@ -6803,7 +6854,7 @@ async function done(id, summary) {
     if (pending.length > 0) {
       console.log(
         chalk69.red(
-          `Cannot complete item #${id}: ${pending.length} pending phase(s):`
+          `Cannot complete item #${id2}: ${pending.length} pending phase(s):`
         )
       );
       for (const phase of pending) {
@@ -6818,37 +6869,66 @@ async function done(id, summary) {
     const phase = item.currentPhase ?? 1;
     await appendComment(orm, item.id, summary, { phase, type: "summary" });
   }
-  console.log(chalk69.green(`Completed item #${id}: ${item.name}`));
+  console.log(chalk69.green(`Completed item #${id2}: ${item.name}`));
 }
 
-// src/commands/backlog/start/index.ts
+// src/commands/backlog/star/index.ts
+import chalk71 from "chalk";
+
+// src/commands/backlog/setStarred.ts
 import chalk70 from "chalk";
-async function start(id) {
-  const name = await setStatus(id, "in-progress");
+async function setStarred(id2, starred) {
+  const { orm } = await getReady();
+  const name = await updateStarred(orm, Number.parseInt(id2, 10), starred);
+  if (name === void 0) console.log(chalk70.red(`Item #${id2} not found.`));
+  return name;
+}
+
+// src/commands/backlog/star/index.ts
+async function star(id2) {
+  const name = await setStarred(id2, true);
   if (name) {
-    console.log(chalk70.green(`Started item #${id}: ${name}`));
+    console.log(chalk71.green(`Starred item #${id2}: ${name}`));
+  }
+}
+
+// src/commands/backlog/start/index.ts
+import chalk72 from "chalk";
+async function start(id2) {
+  const name = await setStatus(id2, "in-progress");
+  if (name) {
+    console.log(chalk72.green(`Started item #${id2}: ${name}`));
   }
 }
 
 // src/commands/backlog/stop/index.ts
-import chalk71 from "chalk";
-import { and as and5, eq as eq22 } from "drizzle-orm";
+import chalk73 from "chalk";
+import { and as and5, eq as eq23 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
-  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and5(eq22(items.status, "in-progress"), eq22(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and5(eq23(items.status, "in-progress"), eq23(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
-    console.log(chalk71.yellow("No in-progress items to stop."));
+    console.log(chalk73.yellow("No in-progress items to stop."));
     return;
   }
   for (const item of stopped) {
-    console.log(chalk71.yellow(`Stopped item #${item.id}: ${item.name}`));
+    console.log(chalk73.yellow(`Stopped item #${item.id}: ${item.name}`));
+  }
+}
+
+// src/commands/backlog/unstar/index.ts
+import chalk74 from "chalk";
+async function unstar(id2) {
+  const name = await setStarred(id2, false);
+  if (name) {
+    console.log(chalk74.green(`Unstarred item #${id2}: ${name}`));
   }
 }
 
 // src/commands/backlog/wontdo/index.ts
-import chalk72 from "chalk";
-async function wontdo(id, reason) {
-  const found = await findOneItem(id);
+import chalk75 from "chalk";
+async function wontdo(id2, reason) {
+  const found = await findOneItem(id2);
   if (!found) return;
   const { orm, item } = found;
   await updateStatus(orm, item.id, "wontdo");
@@ -6856,7 +6936,7 @@ async function wontdo(id, reason) {
     const phase = item.currentPhase ?? 1;
     await appendComment(orm, item.id, reason, { phase, type: "summary" });
   }
-  console.log(chalk72.red(`Won't do item #${id}: ${item.name}`));
+  console.log(chalk75.red(`Won't do item #${id2}: ${item.name}`));
 }
 
 // src/commands/backlog/registerStatusCommands.ts
@@ -6865,26 +6945,28 @@ function registerStatusCommands(cmd) {
   cmd.command("stop").description("Revert all in-progress backlog items to todo").action(stop);
   cmd.command("done <id> [summary]").description("Set a backlog item to done").action(done);
   cmd.command("wontdo <id> [reason]").description("Set a backlog item to won't do").action(wontdo);
+  cmd.command("star <id>").description("Star a backlog item to pin it in the web view").action(star);
+  cmd.command("unstar <id>").description("Remove the star from a backlog item").action(unstar);
   cmd.command("delete <id>").alias("remove").description("Delete a backlog item").action(del);
 }
 
 // src/commands/backlog/removePhase.ts
-import chalk74 from "chalk";
-import { and as and8, eq as eq25 } from "drizzle-orm";
+import chalk77 from "chalk";
+import { and as and8, eq as eq26 } from "drizzle-orm";
 
 // src/commands/backlog/findPhase.ts
-import chalk73 from "chalk";
-import { and as and6, count as count4, eq as eq23 } from "drizzle-orm";
-async function findPhase(id, phase) {
-  const found = await findOneItem(id);
+import chalk76 from "chalk";
+import { and as and6, count as count4, eq as eq24 } from "drizzle-orm";
+async function findPhase(id2, phase) {
+  const found = await findOneItem(id2);
   if (!found) return void 0;
   const { orm, item } = found;
   const itemId = item.id;
   const phaseIdx = Number.parseInt(phase, 10) - 1;
-  const [row] = await orm.select({ cnt: count4() }).from(planPhases).where(and6(eq23(planPhases.itemId, itemId), eq23(planPhases.idx, phaseIdx)));
+  const [row] = await orm.select({ cnt: count4() }).from(planPhases).where(and6(eq24(planPhases.itemId, itemId), eq24(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
-      chalk73.red(`Phase ${phaseIdx + 1} not found on item #${itemId}.`)
+      chalk76.red(`Phase ${phaseIdx + 1} not found on item #${itemId}.`)
     );
     process.exitCode = 1;
     return void 0;
@@ -6893,14 +6975,14 @@ async function findPhase(id, phase) {
 }
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and7, asc as asc6, count as count5, eq as eq24 } from "drizzle-orm";
+import { and as and7, asc as asc6, count as count5, eq as eq25 } from "drizzle-orm";
 async function reindexPhases(db, itemId) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq24(planPhases.itemId, itemId)).orderBy(asc6(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq25(planPhases.itemId, itemId)).orderBy(asc6(planPhases.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
-    await db.update(planTasks).set({ phaseIdx: i }).where(and7(eq24(planTasks.itemId, itemId), eq24(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and7(eq24(planPhases.itemId, itemId), eq24(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and7(eq25(planTasks.itemId, itemId), eq25(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and7(eq25(planPhases.itemId, itemId), eq25(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -6908,36 +6990,36 @@ async function adjustCurrentPhase(db, item, removedIdx) {
   if (currentPhase === void 0) return;
   const currentIdx = currentPhase - 1;
   if (removedIdx < currentIdx) {
-    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq24(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq25(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq24(planPhases.itemId, item.id));
+  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq25(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq24(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq25(items.id, item.id));
 }
 
 // src/commands/backlog/removePhase.ts
-async function removePhase(id, phase) {
-  const found = await findPhase(id, phase);
+async function removePhase(id2, phase) {
+  const found = await findPhase(id2, phase);
   if (!found) return;
   const { item, orm, itemId, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and8(eq25(planTasks.itemId, itemId), eq25(planTasks.phaseIdx, phaseIdx))
+      and8(eq26(planTasks.itemId, itemId), eq26(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and8(eq25(planPhases.itemId, itemId), eq25(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and8(eq26(planPhases.itemId, itemId), eq26(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
   console.log(
-    chalk74.green(`Removed phase ${phaseIdx + 1} from item #${itemId}.`)
+    chalk77.green(`Removed phase ${phaseIdx + 1} from item #${itemId}.`)
   );
 }
 
 // src/commands/backlog/update/index.ts
-import chalk76 from "chalk";
-import { eq as eq26 } from "drizzle-orm";
+import chalk79 from "chalk";
+import { eq as eq27 } from "drizzle-orm";
 
 // src/commands/backlog/update/parseListIndex.ts
 function parseListIndex(raw, length, label2) {
@@ -7012,16 +7094,16 @@ function applyAcMutations(current, options2) {
 }
 
 // src/commands/backlog/update/buildUpdateValues.ts
-import chalk75 from "chalk";
+import chalk78 from "chalk";
 function buildUpdateValues(options2) {
   const { name, desc: desc2, type, ac } = options2;
   if (!name && !desc2 && !type && !ac) {
-    console.log(chalk75.red("Nothing to update. Provide at least one flag."));
+    console.log(chalk78.red("Nothing to update. Provide at least one flag."));
     process.exitCode = 1;
     return void 0;
   }
   if (type && type !== "story" && type !== "bug") {
-    console.log(chalk75.red('Invalid type. Must be "story" or "bug".'));
+    console.log(chalk78.red('Invalid type. Must be "story" or "bug".'));
     process.exitCode = 1;
     return void 0;
   }
@@ -7047,21 +7129,21 @@ function buildUpdateValues(options2) {
 }
 
 // src/commands/backlog/update/index.ts
-async function update(id, options2) {
-  const found = await findOneItem(id);
+async function update(id2, options2) {
+  const found = await findOneItem(id2);
   if (!found) return;
   let ac = options2.ac;
   if (hasAcMutations(options2)) {
     if (options2.ac) {
       console.log(
-        chalk76.red("Cannot combine --ac with --add-ac/--edit-ac/--remove-ac.")
+        chalk79.red("Cannot combine --ac with --add-ac/--edit-ac/--remove-ac.")
       );
       process.exitCode = 1;
       return;
     }
     const mutation = applyAcMutations(found.item.acceptanceCriteria, options2);
     if (!mutation.ok) {
-      console.log(chalk76.red(mutation.error));
+      console.log(chalk79.red(mutation.error));
       process.exitCode = 1;
       return;
     }
@@ -7071,30 +7153,30 @@ async function update(id, options2) {
   if (!built) return;
   const { orm } = found;
   const itemId = found.item.id;
-  await orm.update(items).set(built.set).where(eq26(items.id, itemId));
-  console.log(chalk76.green(`Updated ${built.fields} on item #${itemId}.`));
+  await orm.update(items).set(built.set).where(eq27(items.id, itemId));
+  console.log(chalk79.green(`Updated ${built.fields} on item #${itemId}.`));
 }
 
 // src/commands/backlog/updatePhase.ts
-import chalk77 from "chalk";
+import chalk80 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and9, eq as eq27 } from "drizzle-orm";
+import { and as and9, eq as eq28 } from "drizzle-orm";
 async function applyPhaseUpdate(orm, itemId, phaseIdx, fields) {
   await orm.transaction(async (tx) => {
     if (fields.name) {
       await tx.update(planPhases).set({ name: fields.name }).where(
-        and9(eq27(planPhases.itemId, itemId), eq27(planPhases.idx, phaseIdx))
+        and9(eq28(planPhases.itemId, itemId), eq28(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and9(eq27(planPhases.itemId, itemId), eq27(planPhases.idx, phaseIdx))
+        and9(eq28(planPhases.itemId, itemId), eq28(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and9(eq27(planTasks.itemId, itemId), eq27(planTasks.phaseIdx, phaseIdx))
+        and9(eq28(planTasks.itemId, itemId), eq28(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -7174,13 +7256,13 @@ function resolvePhaseFields(options2, current) {
 }
 
 // src/commands/backlog/updatePhase.ts
-async function updatePhase(id, phase, options2) {
-  const found = await findPhase(id, phase);
+async function updatePhase(id2, phase, options2) {
+  const found = await findPhase(id2, phase);
   if (!found) return;
   const { item, orm, itemId, phaseIdx } = found;
   const resolved = resolvePhaseFields(options2, item.plan?.[phaseIdx]);
   if (!resolved.ok) {
-    console.log(chalk77.red(resolved.error));
+    console.log(chalk80.red(resolved.error));
     process.exitCode = 1;
     return;
   }
@@ -7192,7 +7274,7 @@ async function updatePhase(id, phase, options2) {
     manualCheck && "manual checks"
   ].filter(Boolean).join(", ");
   console.log(
-    chalk77.green(
+    chalk80.green(
       `Updated ${fields} on phase ${phaseIdx + 1} of item #${itemId}.`
     )
   );
@@ -7925,11 +8007,11 @@ function assertCliExists(cli) {
 }
 
 // src/commands/permitCliReads/colorize.ts
-import chalk78 from "chalk";
+import chalk81 from "chalk";
 function colorize(plainOutput) {
   return plainOutput.split("\n").map((line) => {
-    if (line.startsWith(" R  ")) return chalk78.green(line);
-    if (line.startsWith(" W  ")) return chalk78.red(line);
+    if (line.startsWith(" R  ")) return chalk81.green(line);
+    if (line.startsWith(" W  ")) return chalk81.red(line);
     return line;
   }).join("\n");
 }
@@ -8227,7 +8309,7 @@ async function permitCliReads(cli, options2 = { noCache: false }) {
 }
 
 // src/commands/deny/denyAdd.ts
-import chalk79 from "chalk";
+import chalk82 from "chalk";
 
 // src/commands/deny/loadDenyConfig.ts
 function loadDenyConfig(global) {
@@ -8247,16 +8329,16 @@ function loadDenyConfig(global) {
 function denyAdd(pattern2, message, options2) {
   const { deny, saveDeny } = loadDenyConfig(options2.global);
   if (deny.some((r) => r.pattern === pattern2)) {
-    console.log(chalk79.yellow(`Deny rule already exists for: ${pattern2}`));
+    console.log(chalk82.yellow(`Deny rule already exists for: ${pattern2}`));
     return;
   }
   deny.push({ pattern: pattern2, message });
   saveDeny(deny);
-  console.log(chalk79.green(`Added deny rule: ${pattern2} \u2192 ${message}`));
+  console.log(chalk82.green(`Added deny rule: ${pattern2} \u2192 ${message}`));
 }
 
 // src/commands/deny/denyList.ts
-import chalk80 from "chalk";
+import chalk83 from "chalk";
 function denyList() {
   const globalRaw = loadGlobalConfigRaw();
   const projectRaw = loadProjectConfig();
@@ -8267,7 +8349,7 @@ function denyList() {
     projectDeny.length > 0 ? projectDeny : void 0
   );
   if (!merged || merged.length === 0) {
-    console.log(chalk80.dim("No deny rules configured."));
+    console.log(chalk83.dim("No deny rules configured."));
     return;
   }
   const projectPatterns = new Set(projectDeny.map((r) => r.pattern));
@@ -8275,23 +8357,23 @@ function denyList() {
   for (const rule of merged) {
     const inProject = projectPatterns.has(rule.pattern);
     const inGlobal = globalPatterns.has(rule.pattern);
-    const label2 = inProject && inGlobal ? chalk80.dim(" (project, overrides global)") : inGlobal ? chalk80.dim(" (global)") : "";
-    console.log(`${chalk80.red(rule.pattern)} \u2192 ${rule.message}${label2}`);
+    const label2 = inProject && inGlobal ? chalk83.dim(" (project, overrides global)") : inGlobal ? chalk83.dim(" (global)") : "";
+    console.log(`${chalk83.red(rule.pattern)} \u2192 ${rule.message}${label2}`);
   }
 }
 
 // src/commands/deny/denyRemove.ts
-import chalk81 from "chalk";
+import chalk84 from "chalk";
 function denyRemove(pattern2, options2) {
   const { deny, saveDeny } = loadDenyConfig(options2.global);
   const index2 = deny.findIndex((r) => r.pattern === pattern2);
   if (index2 === -1) {
-    console.log(chalk81.yellow(`No deny rule found for: ${pattern2}`));
+    console.log(chalk84.yellow(`No deny rule found for: ${pattern2}`));
     return;
   }
   deny.splice(index2, 1);
   saveDeny(deny.length > 0 ? deny : void 0);
-  console.log(chalk81.green(`Removed deny rule: ${pattern2}`));
+  console.log(chalk84.green(`Removed deny rule: ${pattern2}`));
 }
 
 // src/commands/registerDeny.ts
@@ -8320,15 +8402,15 @@ function registerCliHook(program2) {
 }
 
 // src/commands/complexity/analyze.ts
-import chalk88 from "chalk";
+import chalk91 from "chalk";
 
 // src/commands/complexity/cyclomatic.ts
-import chalk83 from "chalk";
+import chalk86 from "chalk";
 
 // src/commands/complexity/shared/index.ts
 import fs13 from "fs";
 import path19 from "path";
-import chalk82 from "chalk";
+import chalk85 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
@@ -8579,7 +8661,7 @@ function createSourceFromFile(filePath) {
 function withSourceFiles(pattern2, callback, extraIgnore = []) {
   const files = findSourceFiles2(pattern2, ".", extraIgnore);
   if (files.length === 0) {
-    console.log(chalk82.yellow("No files found matching pattern"));
+    console.log(chalk85.yellow("No files found matching pattern"));
     return void 0;
   }
   return callback(files);
@@ -8612,11 +8694,11 @@ async function cyclomatic(pattern2 = "**/*.ts", options2 = {}) {
     results.sort((a, b) => b.complexity - a.complexity);
     for (const { file, name, complexity } of results) {
       const exceedsThreshold = options2.threshold !== void 0 && complexity > options2.threshold;
-      const color = exceedsThreshold ? chalk83.red : chalk83.white;
-      console.log(`${color(`${file}:${name}`)} \u2192 ${chalk83.cyan(complexity)}`);
+      const color = exceedsThreshold ? chalk86.red : chalk86.white;
+      console.log(`${color(`${file}:${name}`)} \u2192 ${chalk86.cyan(complexity)}`);
     }
     console.log(
-      chalk83.dim(
+      chalk86.dim(
         `
 Analyzed ${results.length} functions across ${files.length} files`
       )
@@ -8628,7 +8710,7 @@ Analyzed ${results.length} functions across ${files.length} files`
 }
 
 // src/commands/complexity/halstead.ts
-import chalk84 from "chalk";
+import chalk87 from "chalk";
 async function halstead(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
@@ -8643,13 +8725,13 @@ async function halstead(pattern2 = "**/*.ts", options2 = {}) {
     results.sort((a, b) => b.metrics.effort - a.metrics.effort);
     for (const { file, name, metrics } of results) {
       const exceedsThreshold = options2.threshold !== void 0 && metrics.volume > options2.threshold;
-      const color = exceedsThreshold ? chalk84.red : chalk84.white;
+      const color = exceedsThreshold ? chalk87.red : chalk87.white;
       console.log(
-        `${color(`${file}:${name}`)} \u2192 volume: ${chalk84.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk84.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk84.magenta(metrics.effort.toFixed(1))}`
+        `${color(`${file}:${name}`)} \u2192 volume: ${chalk87.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk87.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk87.magenta(metrics.effort.toFixed(1))}`
       );
     }
     console.log(
-      chalk84.dim(
+      chalk87.dim(
         `
 Analyzed ${results.length} functions across ${files.length} files`
       )
@@ -8673,28 +8755,28 @@ function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, slo
 }
 
 // src/commands/complexity/maintainability/displayMaintainabilityResults.ts
-import chalk85 from "chalk";
+import chalk88 from "chalk";
 function displayMaintainabilityResults(results, threshold) {
   const filtered = threshold !== void 0 ? results.filter((r) => r.minMaintainability < threshold) : results;
   if (threshold !== void 0 && filtered.length === 0) {
-    console.log(chalk85.green("All files pass maintainability threshold"));
+    console.log(chalk88.green("All files pass maintainability threshold"));
   } else {
     for (const { file, avgMaintainability, minMaintainability } of filtered) {
-      const color = threshold !== void 0 ? chalk85.red : chalk85.white;
+      const color = threshold !== void 0 ? chalk88.red : chalk88.white;
       console.log(
-        `${color(file)} \u2192 avg: ${chalk85.cyan(avgMaintainability.toFixed(1))}, min: ${chalk85.yellow(minMaintainability.toFixed(1))}`
+        `${color(file)} \u2192 avg: ${chalk88.cyan(avgMaintainability.toFixed(1))}, min: ${chalk88.yellow(minMaintainability.toFixed(1))}`
       );
     }
   }
-  console.log(chalk85.dim(`
+  console.log(chalk88.dim(`
 Analyzed ${results.length} files`));
   if (filtered.length > 0 && threshold !== void 0) {
     console.error(
-      chalk85.red(
+      chalk88.red(
         `
 Fail: ${filtered.length} file(s) below threshold ${threshold}. Maintainability index (0\u2013100) is derived from Halstead volume, cyclomatic complexity, and lines of code.
 
-\u26A0\uFE0F  ${chalk85.bold("Diagnose and fix one file at a time")} \u2014 do not investigate or fix multiple files in parallel. Run 'assist complexity <file>' to see all metrics. For larger files, start by extracting responsibilities into smaller files.`
+\u26A0\uFE0F  ${chalk88.bold("Diagnose and fix one file at a time")} \u2014 do not investigate or fix multiple files in parallel. Run 'assist complexity <file>' to see all metrics. For larger files, start by extracting responsibilities into smaller files.`
       )
     );
     process.exit(1);
@@ -8702,10 +8784,10 @@ Fail: ${filtered.length} file(s) below threshold ${threshold}. Maintainability i
 }
 
 // src/commands/complexity/maintainability/printMaintainabilityFormula.ts
-import chalk86 from "chalk";
+import chalk89 from "chalk";
 var MI_FORMULA = "171 - 5.2*ln(HalsteadVolume) - 0.23*CyclomaticComplexity - 16.2*ln(SLOC), clamped 0-100";
 function printMaintainabilityFormula() {
-  console.log(chalk86.dim(MI_FORMULA));
+  console.log(chalk89.dim(MI_FORMULA));
 }
 
 // src/commands/complexity/maintainability/index.ts
@@ -8756,7 +8838,7 @@ async function maintainability(pattern2 = "**/*.ts", options2 = {}) {
 
 // src/commands/complexity/sloc.ts
 import fs15 from "fs";
-import chalk87 from "chalk";
+import chalk90 from "chalk";
 async function sloc(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
@@ -8772,12 +8854,12 @@ async function sloc(pattern2 = "**/*.ts", options2 = {}) {
     results.sort((a, b) => b.lines - a.lines);
     for (const { file, lines } of results) {
       const exceedsThreshold = options2.threshold !== void 0 && lines > options2.threshold;
-      const color = exceedsThreshold ? chalk87.red : chalk87.white;
-      console.log(`${color(file)} \u2192 ${chalk87.cyan(lines)} lines`);
+      const color = exceedsThreshold ? chalk90.red : chalk90.white;
+      console.log(`${color(file)} \u2192 ${chalk90.cyan(lines)} lines`);
     }
     const total = results.reduce((sum, r) => sum + r.lines, 0);
     console.log(
-      chalk87.dim(`
+      chalk90.dim(`
 Total: ${total} lines across ${files.length} files`)
     );
     if (hasViolation) {
@@ -8791,21 +8873,21 @@ async function analyze(pattern2) {
   const searchPattern = pattern2.includes("*") || pattern2.includes("/") ? pattern2 : `**/${pattern2}`;
   const files = findSourceFiles2(searchPattern);
   if (files.length === 0) {
-    console.log(chalk88.yellow("No files found matching pattern"));
+    console.log(chalk91.yellow("No files found matching pattern"));
     return;
   }
   if (files.length === 1) {
     const file = files[0];
-    console.log(chalk88.bold.underline("SLOC"));
+    console.log(chalk91.bold.underline("SLOC"));
     await sloc(file);
     console.log();
-    console.log(chalk88.bold.underline("Cyclomatic Complexity"));
+    console.log(chalk91.bold.underline("Cyclomatic Complexity"));
     await cyclomatic(file);
     console.log();
-    console.log(chalk88.bold.underline("Halstead Metrics"));
+    console.log(chalk91.bold.underline("Halstead Metrics"));
     await halstead(file);
     console.log();
-    console.log(chalk88.bold.underline("Maintainability Index"));
+    console.log(chalk91.bold.underline("Maintainability Index"));
     await maintainability(file);
     return;
   }
@@ -8837,7 +8919,7 @@ function registerComplexity(program2) {
 }
 
 // src/commands/config/index.ts
-import chalk89 from "chalk";
+import chalk92 from "chalk";
 import { stringify as stringifyYaml2 } from "yaml";
 
 // src/commands/config/setNestedValue.ts
@@ -8900,7 +8982,7 @@ function formatIssuePath(issue, key) {
 function printValidationErrors(issues, key) {
   for (const issue of issues) {
     console.error(
-      chalk89.red(`${formatIssuePath(issue, key)}: ${issue.message}`)
+      chalk92.red(`${formatIssuePath(issue, key)}: ${issue.message}`)
     );
   }
 }
@@ -8917,7 +8999,7 @@ var GLOBAL_ONLY_KEYS = ["sync.autoConfirm"];
 function assertNotGlobalOnly(key, global) {
   if (!global && GLOBAL_ONLY_KEYS.some((k) => key.startsWith(k))) {
     console.error(
-      chalk89.red(
+      chalk92.red(
         `"${key}" is a global-only key. Use --global to set it in ~/.assist.yml`
       )
     );
@@ -8940,7 +9022,7 @@ function configSet(key, value, options2 = {}) {
   applyConfigSet(key, coerced, options2.global ?? false);
   const target = options2.global ? "global" : "project";
   console.log(
-    chalk89.green(`Set ${key} = ${JSON.stringify(coerced)} (${target})`)
+    chalk92.green(`Set ${key} = ${JSON.stringify(coerced)} (${target})`)
   );
 }
 function configList() {
@@ -8949,7 +9031,7 @@ function configList() {
 }
 
 // src/commands/config/configGet.ts
-import chalk90 from "chalk";
+import chalk93 from "chalk";
 
 // src/commands/config/getNestedValue.ts
 function isTraversable(value) {
@@ -8981,7 +9063,7 @@ function requireNestedValue(config, key) {
   return value;
 }
 function exitKeyNotSet(key) {
-  console.error(chalk90.red(`Key "${key}" is not set`));
+  console.error(chalk93.red(`Key "${key}" is not set`));
   process.exit(1);
 }
 
@@ -8995,7 +9077,7 @@ function registerConfig(program2) {
 
 // src/commands/deploy/redirect.ts
 import { existsSync as existsSync25, readFileSync as readFileSync19, writeFileSync as writeFileSync18 } from "fs";
-import chalk91 from "chalk";
+import chalk94 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
         window.location.href = \`\${window.location.pathname}/\${window.location.search}\${window.location.hash}\`;
@@ -9004,22 +9086,22 @@ var TRAILING_SLASH_SCRIPT = `    <script>
 function redirect() {
   const indexPath = "index.html";
   if (!existsSync25(indexPath)) {
-    console.log(chalk91.yellow("No index.html found"));
+    console.log(chalk94.yellow("No index.html found"));
     return;
   }
   const content = readFileSync19(indexPath, "utf-8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
-    console.log(chalk91.dim("Trailing slash script already present"));
+    console.log(chalk94.dim("Trailing slash script already present"));
     return;
   }
   const headCloseIndex = content.indexOf("</head>");
   if (headCloseIndex === -1) {
-    console.log(chalk91.red("Could not find </head> tag in index.html"));
+    console.log(chalk94.red("Could not find </head> tag in index.html"));
     return;
   }
   const newContent = content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT + "\n  " + content.slice(headCloseIndex);
   writeFileSync18(indexPath, newContent);
-  console.log(chalk91.green("Added trailing slash redirect to index.html"));
+  console.log(chalk94.green("Added trailing slash redirect to index.html"));
 }
 
 // src/commands/registerDeploy.ts
@@ -9046,7 +9128,7 @@ function loadBlogSkipDays(repoName) {
 
 // src/commands/devlog/shared.ts
 import { execSync as execSync22 } from "child_process";
-import chalk92 from "chalk";
+import chalk95 from "chalk";
 
 // src/shared/getRepoName.ts
 import { existsSync as existsSync26, readFileSync as readFileSync20 } from "fs";
@@ -9155,13 +9237,13 @@ function shouldIgnoreCommit(files, ignorePaths) {
 }
 function printCommitsWithFiles(commits2, ignore2, verbose) {
   for (const commit2 of commits2) {
-    console.log(`  ${chalk92.yellow(commit2.hash)} ${commit2.message}`);
+    console.log(`  ${chalk95.yellow(commit2.hash)} ${commit2.message}`);
     if (verbose) {
       const visibleFiles = commit2.files.filter(
         (file) => !ignore2.some((p) => file.startsWith(p))
       );
       for (const file of visibleFiles) {
-        console.log(`    ${chalk92.dim(file)}`);
+        console.log(`    ${chalk95.dim(file)}`);
       }
     }
   }
@@ -9186,15 +9268,15 @@ function parseGitLogCommits(output, ignore2, afterDate) {
 }
 
 // src/commands/devlog/list/printDateHeader.ts
-import chalk93 from "chalk";
+import chalk96 from "chalk";
 function printDateHeader(date, isSkipped, entries) {
   if (isSkipped) {
-    console.log(`${chalk93.bold.blue(date)} ${chalk93.dim("skipped")}`);
+    console.log(`${chalk96.bold.blue(date)} ${chalk96.dim("skipped")}`);
   } else if (entries && entries.length > 0) {
-    const entryInfo = entries.map((e) => `${chalk93.green(e.version)} ${e.title}`).join(" | ");
-    console.log(`${chalk93.bold.blue(date)} ${entryInfo}`);
+    const entryInfo = entries.map((e) => `${chalk96.green(e.version)} ${e.title}`).join(" | ");
+    console.log(`${chalk96.bold.blue(date)} ${entryInfo}`);
   } else {
-    console.log(`${chalk93.bold.blue(date)} ${chalk93.red("\u26A0 devlog missing")}`);
+    console.log(`${chalk96.bold.blue(date)} ${chalk96.red("\u26A0 devlog missing")}`);
   }
 }
 
@@ -9298,24 +9380,24 @@ function bumpVersion(version2, type) {
 
 // src/commands/devlog/next/displayNextEntry/index.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import chalk95 from "chalk";
+import chalk98 from "chalk";
 
 // src/commands/devlog/next/displayNextEntry/displayVersion.ts
-import chalk94 from "chalk";
+import chalk97 from "chalk";
 function displayVersion(conventional, firstHash, patchVersion, minorVersion) {
   if (conventional && firstHash) {
     const version2 = getVersionAtCommit(firstHash);
     if (version2) {
-      console.log(`${chalk94.bold("version:")} ${stripToMinor(version2)}`);
+      console.log(`${chalk97.bold("version:")} ${stripToMinor(version2)}`);
     } else {
-      console.log(`${chalk94.bold("version:")} ${chalk94.red("unknown")}`);
+      console.log(`${chalk97.bold("version:")} ${chalk97.red("unknown")}`);
     }
   } else if (patchVersion && minorVersion) {
     console.log(
-      `${chalk94.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
+      `${chalk97.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
     );
   } else {
-    console.log(`${chalk94.bold("version:")} v0.1 (initial)`);
+    console.log(`${chalk97.bold("version:")} v0.1 (initial)`);
   }
 }
 
@@ -9363,16 +9445,16 @@ function noCommitsMessage(hasLastInfo) {
   return hasLastInfo ? "No commits after last versioned entry" : "No commits found";
 }
 function logName(repoName) {
-  console.log(`${chalk95.bold("name:")} ${repoName}`);
+  console.log(`${chalk98.bold("name:")} ${repoName}`);
 }
 function displayNextEntry(ctx, targetDate, commits2) {
   logName(ctx.repoName);
   printVersionInfo(ctx.config, ctx.lastInfo, commits2[0]?.hash);
-  console.log(chalk95.bold.blue(targetDate));
+  console.log(chalk98.bold.blue(targetDate));
   printCommitsWithFiles(commits2, ctx.ignore, ctx.verbose);
 }
 function logNoCommits(lastInfo) {
-  console.log(chalk95.dim(noCommitsMessage(!!lastInfo)));
+  console.log(chalk98.dim(noCommitsMessage(!!lastInfo)));
 }
 
 // src/commands/devlog/next/index.ts
@@ -9413,11 +9495,11 @@ function next2(options2) {
 import { execSync as execSync24 } from "child_process";
 
 // src/commands/devlog/repos/printReposTable.ts
-import chalk96 from "chalk";
+import chalk99 from "chalk";
 function colorStatus(status2) {
-  if (status2 === "missing") return chalk96.red(status2);
-  if (status2 === "outdated") return chalk96.yellow(status2);
-  return chalk96.green(status2);
+  if (status2 === "missing") return chalk99.red(status2);
+  if (status2 === "outdated") return chalk99.yellow(status2);
+  return chalk99.green(status2);
 }
 function formatRow(row, nameWidth) {
   const devlog = (row.lastDevlog ?? "-").padEnd(11);
@@ -9431,8 +9513,8 @@ function printReposTable(rows) {
     "Last Devlog".padEnd(11),
     "Status"
   ].join("  ");
-  console.log(chalk96.dim(header));
-  console.log(chalk96.dim("-".repeat(header.length)));
+  console.log(chalk99.dim(header));
+  console.log(chalk99.dim("-".repeat(header.length)));
   for (const row of rows) {
     console.log(formatRow(row, nameWidth));
   }
@@ -9490,14 +9572,14 @@ function repos(options2) {
 // src/commands/devlog/skip.ts
 import { writeFileSync as writeFileSync19 } from "fs";
 import { join as join26 } from "path";
-import chalk97 from "chalk";
+import chalk100 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
   return join26(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
-    console.log(chalk97.red("Invalid date format. Use YYYY-MM-DD"));
+    console.log(chalk100.red("Invalid date format. Use YYYY-MM-DD"));
     process.exit(1);
   }
   const repoName = getRepoName();
@@ -9508,7 +9590,7 @@ function skip(date) {
   const skipDays = skip2[repoName] ?? [];
   if (skipDays.includes(date)) {
     console.log(
-      chalk97.yellow(`${date} is already in skip list for ${repoName}`)
+      chalk100.yellow(`${date} is already in skip list for ${repoName}`)
     );
     return;
   }
@@ -9518,20 +9600,20 @@ function skip(date) {
   devlog.skip = skip2;
   config.devlog = devlog;
   writeFileSync19(configPath, stringifyYaml3(config, { lineWidth: 0 }));
-  console.log(chalk97.green(`Added ${date} to skip list for ${repoName}`));
+  console.log(chalk100.green(`Added ${date} to skip list for ${repoName}`));
 }
 
 // src/commands/devlog/version.ts
-import chalk98 from "chalk";
+import chalk101 from "chalk";
 function version() {
   const config = loadConfig();
   const name = getRepoName();
   const lastInfo = getLastVersionInfo(name, config);
   const lastVersion = lastInfo?.version ?? null;
   const nextVersion = lastVersion ? bumpVersion(lastVersion, "patch") : null;
-  console.log(`${chalk98.bold("name:")} ${name}`);
-  console.log(`${chalk98.bold("last:")} ${lastVersion ?? chalk98.dim("none")}`);
-  console.log(`${chalk98.bold("next:")} ${nextVersion ?? chalk98.dim("none")}`);
+  console.log(`${chalk101.bold("name:")} ${name}`);
+  console.log(`${chalk101.bold("last:")} ${lastVersion ?? chalk101.dim("none")}`);
+  console.log(`${chalk101.bold("next:")} ${nextVersion ?? chalk101.dim("none")}`);
 }
 
 // src/commands/registerDevlog.ts
@@ -9555,7 +9637,7 @@ function registerDevlog(program2) {
 // src/commands/dotnet/checkBuildLocks.ts
 import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync2 } from "fs";
 import { join as join27 } from "path";
-import chalk99 from "chalk";
+import chalk102 from "chalk";
 
 // src/shared/findRepoRoot.ts
 import { existsSync as existsSync27 } from "fs";
@@ -9618,14 +9700,14 @@ function checkBuildLocks(startDir) {
   const locked = findFirstLockedDll(startDir ?? getSearchRoot());
   if (locked) {
     console.error(
-      chalk99.red("Build output locked (is VS debugging?): ") + locked
+      chalk102.red("Build output locked (is VS debugging?): ") + locked
     );
     process.exit(1);
   }
 }
 async function checkBuildLocksCommand() {
   checkBuildLocks();
-  console.log(chalk99.green("No build locks detected"));
+  console.log(chalk102.green("No build locks detected"));
 }
 
 // src/commands/dotnet/buildTree.ts
@@ -9724,30 +9806,30 @@ function escapeRegex(s) {
 }
 
 // src/commands/dotnet/printTree.ts
-import chalk100 from "chalk";
+import chalk103 from "chalk";
 function printNodes(nodes, prefix2) {
   for (let i = 0; i < nodes.length; i++) {
     const isLast = i === nodes.length - 1;
     const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
     const childPrefix = isLast ? "    " : "\u2502   ";
     const isMissing = nodes[i].relativePath.startsWith("[MISSING]");
-    const label2 = isMissing ? chalk100.red(nodes[i].relativePath) : nodes[i].relativePath;
+    const label2 = isMissing ? chalk103.red(nodes[i].relativePath) : nodes[i].relativePath;
     console.log(`${prefix2}${connector}${label2}`);
     printNodes(nodes[i].children, prefix2 + childPrefix);
   }
 }
 function printTree(tree, totalCount, solutions) {
-  console.log(chalk100.bold("\nProject Dependency Tree"));
-  console.log(chalk100.cyan(tree.relativePath));
+  console.log(chalk103.bold("\nProject Dependency Tree"));
+  console.log(chalk103.cyan(tree.relativePath));
   printNodes(tree.children, "");
-  console.log(chalk100.dim(`
+  console.log(chalk103.dim(`
 ${totalCount} projects total (including root)`));
-  console.log(chalk100.bold("\nSolution Membership"));
+  console.log(chalk103.bold("\nSolution Membership"));
   if (solutions.length === 0) {
-    console.log(chalk100.yellow("  Not found in any .sln"));
+    console.log(chalk103.yellow("  Not found in any .sln"));
   } else {
     for (const sln of solutions) {
-      console.log(`  ${chalk100.green(sln)}`);
+      console.log(`  ${chalk103.green(sln)}`);
     }
   }
   console.log();
@@ -9776,16 +9858,16 @@ function printJson(tree, totalCount, solutions) {
 // src/commands/dotnet/resolveCsproj.ts
 import { existsSync as existsSync28 } from "fs";
 import path23 from "path";
-import chalk101 from "chalk";
+import chalk104 from "chalk";
 function resolveCsproj(csprojPath) {
   const resolved = path23.resolve(csprojPath);
   if (!existsSync28(resolved)) {
-    console.error(chalk101.red(`File not found: ${resolved}`));
+    console.error(chalk104.red(`File not found: ${resolved}`));
     process.exit(1);
   }
   const repoRoot = findRepoRoot(path23.dirname(resolved));
   if (!repoRoot) {
-    console.error(chalk101.red("Could not find git repository root"));
+    console.error(chalk104.red("Could not find git repository root"));
     process.exit(1);
   }
   return { resolved, repoRoot };
@@ -9835,12 +9917,12 @@ function getChangedCsFiles(scope) {
 }
 
 // src/commands/dotnet/inSln.ts
-import chalk102 from "chalk";
+import chalk105 from "chalk";
 async function inSln(csprojPath) {
   const { resolved, repoRoot } = resolveCsproj(csprojPath);
   const solutions = findContainingSolutions(resolved, repoRoot);
   if (solutions.length === 0) {
-    console.log(chalk102.yellow("Not found in any .sln file"));
+    console.log(chalk105.yellow("Not found in any .sln file"));
     process.exit(1);
   }
   for (const sln of solutions) {
@@ -9849,7 +9931,7 @@ async function inSln(csprojPath) {
 }
 
 // src/commands/dotnet/inspect.ts
-import chalk108 from "chalk";
+import chalk111 from "chalk";
 
 // src/shared/formatElapsed.ts
 function formatElapsed(ms) {
@@ -9861,12 +9943,12 @@ function formatElapsed(ms) {
 }
 
 // src/commands/dotnet/displayIssues.ts
-import chalk103 from "chalk";
+import chalk106 from "chalk";
 var SEVERITY_COLOR = {
-  ERROR: chalk103.red,
-  WARNING: chalk103.yellow,
-  SUGGESTION: chalk103.cyan,
-  HINT: chalk103.dim
+  ERROR: chalk106.red,
+  WARNING: chalk106.yellow,
+  SUGGESTION: chalk106.cyan,
+  HINT: chalk106.dim
 };
 function groupByFile(issues) {
   const byFile = /* @__PURE__ */ new Map();
@@ -9882,15 +9964,15 @@ function groupByFile(issues) {
 }
 function displayIssues(issues) {
   for (const [file, fileIssues] of groupByFile(issues)) {
-    console.log(chalk103.bold(file));
+    console.log(chalk106.bold(file));
     for (const issue of fileIssues.sort((a, b) => a.line - b.line)) {
-      const color = SEVERITY_COLOR[issue.severity] ?? chalk103.white;
+      const color = SEVERITY_COLOR[issue.severity] ?? chalk106.white;
       console.log(
-        `  ${chalk103.dim(`${issue.line}:`)} ${color(issue.severity)} [${issue.typeId}] ${issue.message}`
+        `  ${chalk106.dim(`${issue.line}:`)} ${color(issue.severity)} [${issue.typeId}] ${issue.message}`
       );
     }
   }
-  console.log(chalk103.dim(`
+  console.log(chalk106.dim(`
 ${issues.length} issue(s) found`));
 }
 
@@ -9949,12 +10031,12 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 // src/commands/dotnet/resolveSolution.ts
 import { existsSync as existsSync29 } from "fs";
 import path24 from "path";
-import chalk105 from "chalk";
+import chalk108 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
 import { readdirSync as readdirSync4 } from "fs";
 import { dirname as dirname18, join as join28 } from "path";
-import chalk104 from "chalk";
+import chalk107 from "chalk";
 function findSlnInDir(dir) {
   try {
     return readdirSync4(dir).filter((f) => f.endsWith(".sln")).map((f) => join28(dir, f));
@@ -9970,17 +10052,17 @@ function findSolution() {
     const slnFiles = findSlnInDir(current);
     if (slnFiles.length === 1) return slnFiles[0];
     if (slnFiles.length > 1) {
-      console.error(chalk104.red(`Multiple .sln files found in ${current}:`));
+      console.error(chalk107.red(`Multiple .sln files found in ${current}:`));
       for (const f of slnFiles) console.error(`  ${f}`);
       console.error(
-        chalk104.yellow("Specify which one: assist dotnet inspect <sln>")
+        chalk107.yellow("Specify which one: assist dotnet inspect <sln>")
       );
       process.exit(1);
     }
     if (current === ceiling) break;
     current = dirname18(current);
   }
-  console.error(chalk104.red("No .sln file found between cwd and repo root"));
+  console.error(chalk107.red("No .sln file found between cwd and repo root"));
   process.exit(1);
 }
 
@@ -9989,7 +10071,7 @@ function resolveSolution(sln) {
   if (sln) {
     const resolved = path24.resolve(sln);
     if (!existsSync29(resolved)) {
-      console.error(chalk105.red(`Solution file not found: ${resolved}`));
+      console.error(chalk108.red(`Solution file not found: ${resolved}`));
       process.exit(1);
     }
     return resolved;
@@ -10031,14 +10113,14 @@ import { execSync as execSync26 } from "child_process";
 import { existsSync as existsSync30, readFileSync as readFileSync24, unlinkSync as unlinkSync7 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import path25 from "path";
-import chalk106 from "chalk";
+import chalk109 from "chalk";
 function assertJbInstalled() {
   try {
     execSync26("jb inspectcode --version", { stdio: "pipe" });
   } catch {
-    console.error(chalk106.red("jb is not installed. Install with:"));
+    console.error(chalk109.red("jb is not installed. Install with:"));
     console.error(
-      chalk106.yellow("  dotnet tool install -g JetBrains.ReSharper.GlobalTools")
+      chalk109.yellow("  dotnet tool install -g JetBrains.ReSharper.GlobalTools")
     );
     process.exit(1);
   }
@@ -10056,11 +10138,11 @@ function runInspectCode(slnPath, include, swea) {
     if (err && typeof err === "object" && "stderr" in err) {
       process.stderr.write(err.stderr);
     }
-    console.error(chalk106.red("jb inspectcode failed"));
+    console.error(chalk109.red("jb inspectcode failed"));
     process.exit(1);
   }
   if (!existsSync30(reportPath)) {
-    console.error(chalk106.red("Report file not generated"));
+    console.error(chalk109.red("Report file not generated"));
     process.exit(1);
   }
   const xml = readFileSync24(reportPath, "utf-8");
@@ -10070,7 +10152,7 @@ function runInspectCode(slnPath, include, swea) {
 
 // src/commands/dotnet/runRoslynInspect.ts
 import { execSync as execSync27 } from "child_process";
-import chalk107 from "chalk";
+import chalk110 from "chalk";
 function resolveMsbuildPath() {
   const { run: run4 } = loadConfig();
   const configs = resolveRunConfigs(run4, getConfigDir());
@@ -10082,9 +10164,9 @@ function assertMsbuildInstalled() {
   try {
     execSync27(`"${msbuild}" -version`, { stdio: "pipe" });
   } catch {
-    console.error(chalk107.red(`msbuild not found at: ${msbuild}`));
+    console.error(chalk110.red(`msbuild not found at: ${msbuild}`));
     console.error(
-      chalk107.yellow(
+      chalk110.yellow(
         "Configure it via a 'build' run entry in .claude/assist.yml or add msbuild to PATH."
       )
     );
@@ -10131,17 +10213,17 @@ function runEngine(resolved, changedFiles, options2) {
 // src/commands/dotnet/inspect.ts
 function logScope(changedFiles) {
   if (changedFiles === null) {
-    console.log(chalk108.dim("Inspecting full solution..."));
+    console.log(chalk111.dim("Inspecting full solution..."));
   } else {
     console.log(
-      chalk108.dim(`Inspecting ${changedFiles.length} changed file(s)...`)
+      chalk111.dim(`Inspecting ${changedFiles.length} changed file(s)...`)
     );
   }
 }
 function reportResults(issues, elapsed) {
   if (issues.length > 0) displayIssues(issues);
-  else console.log(chalk108.green("No issues found"));
-  console.log(chalk108.dim(`Completed in ${formatElapsed(elapsed)}`));
+  else console.log(chalk111.green("No issues found"));
+  console.log(chalk111.dim(`Completed in ${formatElapsed(elapsed)}`));
   if (issues.length > 0) process.exit(1);
 }
 async function inspect(sln, options2) {
@@ -10152,7 +10234,7 @@ async function inspect(sln, options2) {
   const scope = parseScope(options2.scope);
   const changedFiles = getChangedCsFiles(scope);
   if (changedFiles !== null && changedFiles.length === 0) {
-    console.log(chalk108.green("No changed .cs files found"));
+    console.log(chalk111.green("No changed .cs files found"));
     return;
   }
   logScope(changedFiles);
@@ -10281,25 +10363,25 @@ function fetchRepoCommitAuthors(org, repo, since) {
 }
 
 // src/commands/github/printCountTable.ts
-import chalk109 from "chalk";
+import chalk112 from "chalk";
 function printCountTable(labelHeader, rows) {
   const labelWidth = Math.max(
     labelHeader.length,
     ...rows.map((row) => row.label.length)
   );
   const header = `${labelHeader.padEnd(labelWidth)}  Commits`;
-  console.log(chalk109.dim(header));
-  console.log(chalk109.dim("-".repeat(header.length)));
+  console.log(chalk112.dim(header));
+  console.log(chalk112.dim("-".repeat(header.length)));
   for (const row of rows) {
     console.log(`${row.label.padEnd(labelWidth)}  ${row.count}`);
   }
 }
 
 // src/commands/github/printRepoAuthorBreakdown.ts
-import chalk110 from "chalk";
+import chalk113 from "chalk";
 function printRepoAuthorBreakdown(repos2) {
   for (const repo of repos2) {
-    console.log(chalk110.bold(repo.name));
+    console.log(chalk113.bold(repo.name));
     const authorWidth = Math.max(
       0,
       ...repo.authors.map((a) => a.author.length)
@@ -10624,7 +10706,7 @@ function registerHandover(program2) {
 }
 
 // src/commands/jira/acceptanceCriteria.ts
-import chalk112 from "chalk";
+import chalk115 from "chalk";
 
 // src/commands/jira/adfToText.ts
 function renderInline(node) {
@@ -10685,7 +10767,7 @@ function adfToText(doc) {
 
 // src/commands/jira/fetchIssue.ts
 import { execSync as execSync28 } from "child_process";
-import chalk111 from "chalk";
+import chalk114 from "chalk";
 function fetchIssue(issueKey, fields) {
   let result;
   try {
@@ -10698,15 +10780,15 @@ function fetchIssue(issueKey, fields) {
       const stderr = error.stderr;
       if (stderr.includes("unauthorized")) {
         console.error(
-          chalk111.red("Jira authentication expired."),
+          chalk114.red("Jira authentication expired."),
           "Run",
-          chalk111.cyan("assist jira auth"),
+          chalk114.cyan("assist jira auth"),
           "to re-authenticate."
         );
         process.exit(1);
       }
     }
-    console.error(chalk111.red(`Failed to fetch ${issueKey}.`));
+    console.error(chalk114.red(`Failed to fetch ${issueKey}.`));
     process.exit(1);
   }
   return JSON.parse(result);
@@ -10720,7 +10802,7 @@ function acceptanceCriteria(issueKey) {
   const parsed = fetchIssue(issueKey, field);
   const acValue = parsed?.fields?.[field];
   if (!acValue) {
-    console.log(chalk112.yellow(`No acceptance criteria found on ${issueKey}.`));
+    console.log(chalk115.yellow(`No acceptance criteria found on ${issueKey}.`));
     return;
   }
   if (typeof acValue === "string") {
@@ -10815,14 +10897,14 @@ async function jiraAuth() {
 }
 
 // src/commands/jira/viewIssue.ts
-import chalk113 from "chalk";
+import chalk116 from "chalk";
 function viewIssue(issueKey) {
   const parsed = fetchIssue(issueKey, "summary,description");
   const fields = parsed?.fields;
   const summary = fields?.summary;
   const description = fields?.description;
   if (summary) {
-    console.log(chalk113.bold(summary));
+    console.log(chalk116.bold(summary));
   }
   if (description) {
     if (summary) console.log();
@@ -10836,7 +10918,7 @@ function viewIssue(issueKey) {
   }
   if (!summary && !description) {
     console.log(
-      chalk113.yellow(`No summary or description found on ${issueKey}.`)
+      chalk116.yellow(`No summary or description found on ${issueKey}.`)
     );
   }
 }
@@ -10851,13 +10933,13 @@ function registerJira(program2) {
 
 // src/commands/reviewComments.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import chalk114 from "chalk";
+import chalk117 from "chalk";
 async function reviewComments(number) {
   if (number) {
     try {
       execFileSync6("gh", ["pr", "checkout", number], { stdio: "inherit" });
     } catch {
-      console.error(chalk114.red(`gh pr checkout ${number} failed; aborting.`));
+      console.error(chalk117.red(`gh pr checkout ${number} failed; aborting.`));
       process.exit(1);
     }
   }
@@ -10870,7 +10952,7 @@ async function reviewComments(number) {
 // src/commands/registerLaunch.ts
 function registerLaunch(program2) {
   program2.command("next").argument("[id]", "Backlog item ID to run first").description("Alias for backlog next").option("--once", "Exit after the first completed item run").action(
-    (id, opts) => next({ allowEdits: true, once: opts.once }, id)
+    (id2, opts) => next({ allowEdits: true, once: opts.once }, id2)
   );
   program2.command("draft").alias("feat").argument("[description]", "Text to forward to the /draft slash command").description(
     "Launch Claude in /draft mode, chain into next on /next signal"
@@ -10882,7 +10964,7 @@ function registerLaunch(program2) {
   );
   program2.command("review-comments").argument("[number]", "PR number to check out first").description("Launch Claude in /review-comments mode (single session)").action((number) => reviewComments(number));
   program2.command("refine").argument("[id]", "Backlog item ID").description("Launch Claude in /refine mode to refine a backlog item").option("--once", "Exit when the initial task completes").action(
-    (id, opts) => refine(id, { once: opts.once })
+    (id2, opts) => refine(id2, { once: opts.once })
   );
 }
 
@@ -10900,15 +10982,15 @@ function registerList(program2) {
 // src/commands/mermaid/index.ts
 import { mkdirSync as mkdirSync12, readdirSync as readdirSync5 } from "fs";
 import { resolve as resolve10 } from "path";
-import chalk117 from "chalk";
+import chalk120 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
 import { readFileSync as readFileSync28, writeFileSync as writeFileSync22 } from "fs";
 import { basename as basename5, extname, resolve as resolve9 } from "path";
-import chalk116 from "chalk";
+import chalk119 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
-import chalk115 from "chalk";
+import chalk118 from "chalk";
 async function renderBlock(krokiUrl, source) {
   const response = await fetch(`${krokiUrl}/mermaid/svg`, {
     method: "POST",
@@ -10917,7 +10999,7 @@ async function renderBlock(krokiUrl, source) {
   });
   if (!response.ok) {
     console.error(
-      chalk115.red(
+      chalk118.red(
         `Kroki request failed: ${response.status} ${response.statusText}`
       )
     );
@@ -10935,19 +11017,19 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
-        chalk116.red(
+        chalk119.red(
           `${file}: --index ${onlyIndex} out of range (file has ${blocks.length} diagram(s))`
         )
       );
       process.exit(1);
     }
     console.log(
-      chalk116.gray(
+      chalk119.gray(
         `${file} \u2014 rendering diagram ${onlyIndex} of ${blocks.length}`
       )
     );
   } else {
-    console.log(chalk116.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
+    console.log(chalk119.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
   }
   for (const [i, source] of blocks.entries()) {
     const idx = i + 1;
@@ -10955,7 +11037,7 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
     const outPath = resolve9(outDir, `${stem}-${idx}.svg`);
     const svg = await renderBlock(krokiUrl, source);
     writeFileSync22(outPath, svg, "utf8");
-    console.log(chalk116.green(`  \u2192 ${outPath}`));
+    console.log(chalk119.green(`  \u2192 ${outPath}`));
   }
 }
 function extractMermaidBlocks(markdown) {
@@ -10971,18 +11053,18 @@ async function mermaidExport(file, options2 = {}) {
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
       console.error(
-        chalk117.red(`--index must be a positive integer (got ${options2.index})`)
+        chalk120.red(`--index must be a positive integer (got ${options2.index})`)
       );
       process.exit(1);
     }
     if (!file) {
-      console.error(chalk117.red("--index requires a file argument"));
+      console.error(chalk120.red("--index requires a file argument"));
       process.exit(1);
     }
   }
   const files = file ? [file] : readdirSync5(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
   if (files.length === 0) {
-    console.log(chalk117.gray("No markdown files found in current directory."));
+    console.log(chalk120.gray("No markdown files found in current directory."));
     return;
   }
   for (const f of files) {
@@ -11005,7 +11087,7 @@ function registerMermaid(program2) {
 }
 
 // src/commands/news/add/index.ts
-import chalk118 from "chalk";
+import chalk121 from "chalk";
 import enquirer8 from "enquirer";
 async function add2(url) {
   if (!url) {
@@ -11027,10 +11109,10 @@ async function add2(url) {
   const { orm } = await getReady();
   const added = await addFeed(orm, url);
   if (!added) {
-    console.log(chalk118.yellow("Feed already exists"));
+    console.log(chalk121.yellow("Feed already exists"));
     return;
   }
-  console.log(chalk118.green(`Added feed: ${url}`));
+  console.log(chalk121.green(`Added feed: ${url}`));
 }
 
 // src/commands/registerNews.ts
@@ -11040,7 +11122,7 @@ function registerNews(program2) {
 }
 
 // src/commands/prompts/printPromptsTable.ts
-import chalk119 from "chalk";
+import chalk122 from "chalk";
 function truncate(str, max) {
   if (str.length <= max) return str;
   return `${str.slice(0, max - 1)}\u2026`;
@@ -11058,14 +11140,14 @@ function printPromptsTable(rows) {
     "Command".padEnd(commandWidth),
     "Repos"
   ].join("  ");
-  console.log(chalk119.dim(header));
-  console.log(chalk119.dim("-".repeat(header.length)));
+  console.log(chalk122.dim(header));
+  console.log(chalk122.dim("-".repeat(header.length)));
   for (const row of rows) {
     const count6 = String(row.count).padStart(countWidth);
     const tool = row.tool.padEnd(toolWidth);
     const command = truncate(row.command, 60).padEnd(commandWidth);
     console.log(
-      `${chalk119.yellow(count6)}  ${tool}  ${command}  ${chalk119.dim(row.repos)}`
+      `${chalk122.yellow(count6)}  ${tool}  ${command}  ${chalk122.dim(row.repos)}`
     );
   }
 }
@@ -11197,8 +11279,8 @@ function assertThreadCreated(stdout) {
   } catch {
     throw new Error(`GitHub returned an unparseable response: ${stdout}`);
   }
-  const id = parsed.data?.addPullRequestReviewThread?.thread?.id;
-  if (typeof id !== "string" || id.length === 0) {
+  const id2 = parsed.data?.addPullRequestReviewThread?.thread?.id;
+  if (typeof id2 !== "string" || id2.length === 0) {
     throw new Error(
       "GitHub did not create a review thread (no thread id returned); the line is likely outside the PR diff."
     );
@@ -11611,20 +11693,20 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 }
 
 // src/commands/prs/listComments/printComments.ts
-import chalk120 from "chalk";
+import chalk123 from "chalk";
 function formatForHuman(comment3) {
   if (comment3.type === "review") {
-    const stateColor = comment3.state === "APPROVED" ? chalk120.green : comment3.state === "CHANGES_REQUESTED" ? chalk120.red : chalk120.yellow;
+    const stateColor = comment3.state === "APPROVED" ? chalk123.green : comment3.state === "CHANGES_REQUESTED" ? chalk123.red : chalk123.yellow;
     return [
-      `${chalk120.cyan("Review")} by ${chalk120.bold(comment3.user)} ${stateColor(`[${comment3.state}]`)}`,
+      `${chalk123.cyan("Review")} by ${chalk123.bold(comment3.user)} ${stateColor(`[${comment3.state}]`)}`,
       comment3.body,
       ""
     ].join("\n");
   }
   const location = comment3.line ? `:${comment3.line}` : "";
   return [
-    `${chalk120.cyan("Line comment")} by ${chalk120.bold(comment3.user)} on ${chalk120.dim(`${comment3.path}${location}`)}`,
-    chalk120.dim(comment3.diff_hunk.split("\n").slice(-3).join("\n")),
+    `${chalk123.cyan("Line comment")} by ${chalk123.bold(comment3.user)} on ${chalk123.dim(`${comment3.path}${location}`)}`,
+    chalk123.dim(comment3.diff_hunk.split("\n").slice(-3).join("\n")),
     comment3.body,
     ""
   ].join("\n");
@@ -11714,13 +11796,13 @@ import { execSync as execSync36 } from "child_process";
 import enquirer9 from "enquirer";
 
 // src/commands/prs/prs/displayPaginated/printPr.ts
-import chalk121 from "chalk";
+import chalk124 from "chalk";
 var STATUS_MAP = {
-  MERGED: (pr) => pr.mergedAt ? { label: chalk121.magenta("merged"), date: pr.mergedAt } : null,
-  CLOSED: (pr) => pr.closedAt ? { label: chalk121.red("closed"), date: pr.closedAt } : null
+  MERGED: (pr) => pr.mergedAt ? { label: chalk124.magenta("merged"), date: pr.mergedAt } : null,
+  CLOSED: (pr) => pr.closedAt ? { label: chalk124.red("closed"), date: pr.closedAt } : null
 };
 function defaultStatus(pr) {
-  return { label: chalk121.green("opened"), date: pr.createdAt };
+  return { label: chalk124.green("opened"), date: pr.createdAt };
 }
 function getStatus2(pr) {
   return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -11729,11 +11811,11 @@ function formatDate(dateStr) {
   return new Date(dateStr).toISOString().split("T")[0];
 }
 function formatPrHeader(pr, status2) {
-  return `${chalk121.cyan(`#${pr.number}`)} ${pr.title} ${chalk121.dim(`(${pr.author.login},`)} ${status2.label} ${chalk121.dim(`${formatDate(status2.date)})`)}`;
+  return `${chalk124.cyan(`#${pr.number}`)} ${pr.title} ${chalk124.dim(`(${pr.author.login},`)} ${status2.label} ${chalk124.dim(`${formatDate(status2.date)})`)}`;
 }
 function logPrDetails(pr) {
   console.log(
-    chalk121.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
+    chalk124.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
   console.log();
 }
@@ -12012,10 +12094,10 @@ function registerPrs(program2) {
 }
 
 // src/commands/ravendb/ravendbAuth.ts
-import chalk127 from "chalk";
+import chalk130 from "chalk";
 
 // src/shared/createConnectionAuth.ts
-import chalk122 from "chalk";
+import chalk125 from "chalk";
 function listConnections(connections, format2) {
   if (connections.length === 0) {
     console.log("No connections configured.");
@@ -12028,7 +12110,7 @@ function listConnections(connections, format2) {
 function removeConnection(connections, name, save) {
   const filtered = connections.filter((c) => c.name !== name);
   if (filtered.length === connections.length) {
-    console.error(chalk122.red(`Connection "${name}" not found.`));
+    console.error(chalk125.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   save(filtered);
@@ -12074,15 +12156,15 @@ function saveConnections(connections) {
 }
 
 // src/commands/ravendb/promptConnection.ts
-import chalk125 from "chalk";
+import chalk128 from "chalk";
 
 // src/commands/ravendb/selectOpSecret.ts
-import chalk124 from "chalk";
+import chalk127 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
 import { execSync as execSync39 } from "child_process";
-import chalk123 from "chalk";
+import chalk126 from "chalk";
 function opExec(args) {
   return execSync39(`op ${args}`, {
     encoding: "utf-8",
@@ -12095,7 +12177,7 @@ function searchItems(search2) {
     items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
-      chalk123.red(
+      chalk126.red(
         "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
       )
     );
@@ -12109,7 +12191,7 @@ function getItemFields(itemId) {
     const item = JSON.parse(opExec(`item get "${itemId}" --format=json`));
     return item.fields.filter((f) => f.reference && f.label);
   } catch {
-    console.error(chalk123.red("Failed to get item details from 1Password."));
+    console.error(chalk126.red("Failed to get item details from 1Password."));
     process.exit(1);
   }
 }
@@ -12128,7 +12210,7 @@ async function selectOpSecret(searchTerm) {
   }).run();
   const items2 = searchItems(search2);
   if (items2.length === 0) {
-    console.error(chalk124.red(`No items found matching "${search2}".`));
+    console.error(chalk127.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId = await selectOne(
@@ -12137,7 +12219,7 @@ async function selectOpSecret(searchTerm) {
   );
   const fields = getItemFields(itemId);
   if (fields.length === 0) {
-    console.error(chalk124.red("No fields with references found on this item."));
+    console.error(chalk127.red("No fields with references found on this item."));
     process.exit(1);
   }
   const ref = await selectOne(
@@ -12151,7 +12233,7 @@ async function selectOpSecret(searchTerm) {
 async function promptConnection(existingNames) {
   const name = await promptInput("name", "Connection name:");
   if (existingNames.includes(name)) {
-    console.error(chalk125.red(`Connection "${name}" already exists.`));
+    console.error(chalk128.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput(
@@ -12160,22 +12242,22 @@ async function promptConnection(existingNames) {
   );
   const database = await promptInput("database", "Database name:");
   if (!name || !url || !database) {
-    console.error(chalk125.red("All fields are required."));
+    console.error(chalk128.red("All fields are required."));
     process.exit(1);
   }
   const apiKeyRef = await selectOpSecret();
-  console.log(chalk125.dim(`Using: ${apiKeyRef}`));
+  console.log(chalk128.dim(`Using: ${apiKeyRef}`));
   return { name, url, database, apiKeyRef };
 }
 
 // src/commands/ravendb/ravendbSetConnection.ts
-import chalk126 from "chalk";
+import chalk129 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(chalk126.red(`Connection "${name}" not found.`));
+    console.error(chalk129.red(`Connection "${name}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -12191,16 +12273,16 @@ function ravendbSetConnection(name) {
 var ravendbAuth = createConnectionAuth({
   load: loadConnections,
   save: saveConnections,
-  format: (c) => `${chalk127.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
+  format: (c) => `${chalk130.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
   promptNew: promptConnection,
   onFirst: (c) => ravendbSetConnection(c.name)
 });
 
 // src/commands/ravendb/ravendbCollections.ts
-import chalk131 from "chalk";
+import chalk134 from "chalk";
 
 // src/commands/ravendb/ravenFetch.ts
-import chalk129 from "chalk";
+import chalk132 from "chalk";
 
 // src/commands/ravendb/getAccessToken.ts
 var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -12237,10 +12319,10 @@ ${errorText}`
 
 // src/commands/ravendb/resolveOpSecret.ts
 import { execSync as execSync40 } from "child_process";
-import chalk128 from "chalk";
+import chalk131 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
-    console.error(chalk128.red(`Invalid secret reference: must start with op://`));
+    console.error(chalk131.red(`Invalid secret reference: must start with op://`));
     process.exit(1);
   }
   try {
@@ -12250,7 +12332,7 @@ function resolveOpSecret(reference) {
     }).trim();
   } catch {
     console.error(
-      chalk128.red(
+      chalk131.red(
         "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
       )
     );
@@ -12277,7 +12359,7 @@ async function ravenFetch(connection, path56) {
   if (!response.ok) {
     const body = await response.text();
     console.error(
-      chalk129.red(`RavenDB error: ${response.status} ${response.statusText}`)
+      chalk132.red(`RavenDB error: ${response.status} ${response.statusText}`)
     );
     console.error(body.substring(0, 500));
     process.exit(1);
@@ -12286,7 +12368,7 @@ async function ravenFetch(connection, path56) {
 }
 
 // src/commands/ravendb/resolveConnection.ts
-import chalk130 from "chalk";
+import chalk133 from "chalk";
 function loadRavendb() {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb;
@@ -12300,7 +12382,7 @@ function resolveConnection(name) {
   const connectionName = name ?? defaultConnection;
   if (!connectionName) {
     console.error(
-      chalk130.red(
+      chalk133.red(
         "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
       )
     );
@@ -12308,7 +12390,7 @@ function resolveConnection(name) {
   }
   const connection = connections.find((c) => c.name === connectionName);
   if (!connection) {
-    console.error(chalk130.red(`Connection "${connectionName}" not found.`));
+    console.error(chalk133.red(`Connection "${connectionName}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -12339,15 +12421,15 @@ async function ravendbCollections(connectionName) {
     return;
   }
   for (const c of collections) {
-    console.log(`${chalk131.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+    console.log(`${chalk134.bold(c.Name)}  ${c.CountOfDocuments} docs`);
   }
 }
 
 // src/commands/ravendb/ravendbQuery.ts
-import chalk133 from "chalk";
+import chalk136 from "chalk";
 
 // src/commands/ravendb/fetchAllPages.ts
-import chalk132 from "chalk";
+import chalk135 from "chalk";
 
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
@@ -12385,7 +12467,7 @@ async function fetchAllPages(connection, opts) {
     allResults.push(...results);
     start3 += results.length;
     process.stderr.write(
-      `\r${chalk132.dim(`Fetched ${allResults.length}/${totalResults}`)}`
+      `\r${chalk135.dim(`Fetched ${allResults.length}/${totalResults}`)}`
     );
     if (start3 >= totalResults) break;
     if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
@@ -12400,7 +12482,7 @@ async function fetchAllPages(connection, opts) {
 async function ravendbQuery(connectionName, collection, options2) {
   const resolved = resolveArgs(connectionName, collection);
   if (!resolved.collection && !options2.query) {
-    console.error(chalk133.red("Provide a collection name or --query filter."));
+    console.error(chalk136.red("Provide a collection name or --query filter."));
     process.exit(1);
   }
   const { collection: col } = resolved;
@@ -12438,7 +12520,7 @@ import { spawn as spawn5 } from "child_process";
 import * as path26 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk134 from "chalk";
+import chalk137 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -12447,43 +12529,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk134.red(`
+  console.error(chalk137.red(`
 Refactor check failed:
 `));
-  console.error(chalk134.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk137.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk134.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk137.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk134.yellow(
+    chalk137.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk134.gray(`    assist refactor ignore <file>
+  console.error(chalk137.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk134.cyan(`
+    console.error(chalk137.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk134.cyan(
+      chalk137.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk134.cyan(
+      chalk137.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(
-      chalk134.cyan(
+      chalk137.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -12639,7 +12721,7 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/extract/index.ts
 import path33 from "path";
-import chalk137 from "chalk";
+import chalk140 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
@@ -12676,9 +12758,9 @@ function addImportPreservingSuppressions(sourceFile, structure) {
 import { SyntaxKind as SyntaxKind3 } from "ts-morph";
 function collectReferencedNames(sourceFile) {
   const names = /* @__PURE__ */ new Set();
-  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind3.Identifier)) {
-    if (id.getFirstAncestorByKind(SyntaxKind3.ImportDeclaration)) continue;
-    names.add(id.getText());
+  for (const id2 of sourceFile.getDescendantsOfKind(SyntaxKind3.Identifier)) {
+    if (id2.getFirstAncestorByKind(SyntaxKind3.ImportDeclaration)) continue;
+    names.add(id2.getText());
   }
   return names;
 }
@@ -12729,7 +12811,7 @@ function updateImporters(functionName, sourceFile, importers) {
 
 // src/commands/refactor/extract/applyExtraction.ts
 function isNameReferencedInSource(sourceFile, name) {
-  return sourceFile.getDescendantsOfKind(SyntaxKind4.Identifier).some((id) => id.getText() === name);
+  return sourceFile.getDescendantsOfKind(SyntaxKind4.Identifier).some((id2) => id2.getText() === name);
 }
 async function applyExtraction(functionName, sourceFile, destPath, plan2, project) {
   project.createSourceFile(destPath, plan2.destContent, { overwrite: false });
@@ -12813,8 +12895,8 @@ function collectPrivateFunctions(target, fnMap) {
 import { SyntaxKind as SyntaxKind6 } from "ts-morph";
 function getReferencedIdentifiers(fn) {
   const names = /* @__PURE__ */ new Set();
-  for (const id of fn.getDescendantsOfKind(SyntaxKind6.Identifier)) {
-    names.add(id.getText());
+  for (const id2 of fn.getDescendantsOfKind(SyntaxKind6.Identifier)) {
+    names.add(id2.getText());
   }
   return names;
 }
@@ -12982,8 +13064,8 @@ function matchImport(importDecl, neededNames) {
 function getReferencedNames(nodes) {
   const names = /* @__PURE__ */ new Set();
   for (const node of nodes) {
-    for (const id of node.getDescendantsOfKind(SyntaxKind12.Identifier)) {
-      names.add(id.getText());
+    for (const id2 of node.getDescendantsOfKind(SyntaxKind12.Identifier)) {
+      names.add(id2.getText());
     }
   }
   return names;
@@ -13173,9 +13255,9 @@ function isInsideExtractedFunction(node, extracted) {
 }
 function sourceReferencesName(sourceFile, functionName, extractedNames) {
   const extracted = new Set(extractedNames);
-  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind13.Identifier)) {
-    if (id.getText() !== functionName) continue;
-    const parent = id.getParent();
+  for (const id2 of sourceFile.getDescendantsOfKind(SyntaxKind13.Identifier)) {
+    if (id2.getText() !== functionName) continue;
+    const parent = id2.getParent();
     if (!parent || DECLARATION_KINDS.has(parent.getKind())) continue;
     if (!isInsideExtractedFunction(parent, extracted)) return true;
   }
@@ -13214,23 +13296,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 
 // src/commands/refactor/extract/displayPlan.ts
 import path30 from "path";
-import chalk135 from "chalk";
+import chalk138 from "chalk";
 function section(title) {
   return `
-  ${chalk135.cyan(title)}`;
+  ${chalk138.cyan(title)}`;
 }
 function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
     const rel = path30.relative(cwd, imp.file.getFilePath());
-    console.log(`    ${chalk135.dim(rel)}: \u2192 import from "${imp.relPath}"`);
+    console.log(`    ${chalk138.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
 function displayPlan(functionName, relDest, plan2, cwd) {
-  console.log(chalk135.bold(`Extract: ${functionName} \u2192 ${relDest}
+  console.log(chalk138.bold(`Extract: ${functionName} \u2192 ${relDest}
 `));
-  console.log(`  ${chalk135.cyan("Functions to move:")}`);
+  console.log(`  ${chalk138.cyan("Functions to move:")}`);
   for (const name of plan2.extractedNames) {
     console.log(`    ${name}`);
   }
@@ -13264,7 +13346,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import path32 from "path";
-import chalk136 from "chalk";
+import chalk139 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
@@ -13324,7 +13406,7 @@ function loadProjectFile(file) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk136.red(`File not found in project: ${file}`));
+    console.log(chalk139.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   return { project, sourceFile };
@@ -13347,19 +13429,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(chalk137.green("\nExtraction complete"));
+    console.log(chalk140.green("\nExtraction complete"));
   } else {
-    console.log(chalk137.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk140.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/ignore.ts
 import fs20 from "fs";
-import chalk138 from "chalk";
+import chalk141 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
   if (!fs20.existsSync(file)) {
-    console.error(chalk138.red(`Error: File does not exist: ${file}`));
+    console.error(chalk141.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs20.readFileSync(file, "utf-8");
@@ -13375,7 +13457,7 @@ function ignore(file) {
     fs20.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk138.green(
+    chalk141.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -13384,12 +13466,12 @@ function ignore(file) {
 // src/commands/refactor/rename/index.ts
 import fs23 from "fs";
 import path38 from "path";
-import chalk141 from "chalk";
+import chalk144 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs22 from "fs";
 import path35 from "path";
-import chalk139 from "chalk";
+import chalk142 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
 import path34 from "path";
@@ -13494,13 +13576,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs22.writeFileSync(file, content, "utf-8");
-    console.log(chalk139.cyan(`  Updated imports in ${path35.relative(cwd, file)}`));
+    console.log(chalk142.cyan(`  Updated imports in ${path35.relative(cwd, file)}`));
   }
   const destDir = path35.dirname(destPath);
   if (!fs22.existsSync(destDir)) fs22.mkdirSync(destDir, { recursive: true });
   fs22.renameSync(sourcePath, destPath);
   console.log(
-    chalk139.white(
+    chalk142.white(
       `  Moved ${path35.relative(cwd, sourcePath)} \u2192 ${path35.relative(cwd, destPath)}`
     )
   );
@@ -13587,16 +13669,16 @@ function computeRenameRewrites(sourcePath, destPath) {
 
 // src/commands/refactor/rename/printRenamePreview.ts
 import path37 from "path";
-import chalk140 from "chalk";
+import chalk143 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
-      chalk140.dim(
+      chalk143.dim(
         `  ${path37.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
-  console.log(chalk140.dim("Dry run. Use --apply to execute."));
+  console.log(chalk143.dim("Dry run. Use --apply to execute."));
 }
 
 // src/commands/refactor/rename/index.ts
@@ -13607,20 +13689,20 @@ async function rename(source, destination, options2 = {}) {
   const relSource = path38.relative(cwd, sourcePath);
   const relDest = path38.relative(cwd, destPath);
   if (!fs23.existsSync(sourcePath)) {
-    console.log(chalk141.red(`File not found: ${source}`));
+    console.log(chalk144.red(`File not found: ${source}`));
     process.exit(1);
   }
   if (destPath !== sourcePath && fs23.existsSync(destPath)) {
-    console.log(chalk141.red(`Destination already exists: ${destination}`));
+    console.log(chalk144.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
-  console.log(chalk141.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  console.log(chalk141.dim("Loading project..."));
-  console.log(chalk141.dim("Scanning imports across the project..."));
+  console.log(chalk144.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk144.dim("Loading project..."));
+  console.log(chalk144.dim("Scanning imports across the project..."));
   const rewrites = computeRenameRewrites(sourcePath, destPath);
   const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
   console.log(
-    chalk141.dim(
+    chalk144.dim(
       `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
     )
   );
@@ -13629,11 +13711,11 @@ async function rename(source, destination, options2 = {}) {
     return;
   }
   applyRename(rewrites, sourcePath, destPath, cwd);
-  console.log(chalk141.green("Done"));
+  console.log(chalk144.green("Done"));
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import chalk142 from "chalk";
+import chalk145 from "chalk";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
 import { SyntaxKind as SyntaxKind14 } from "ts-morph";
@@ -13653,8 +13735,8 @@ function isDeclaration(identifier) {
   return parent !== void 0 && declarationKinds.includes(parent.getKind());
 }
 function findSymbol(sourceFile, symbolName) {
-  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind14.Identifier)) {
-    if (id.getText() === symbolName && isDeclaration(id)) return id;
+  for (const id2 of sourceFile.getDescendantsOfKind(SyntaxKind14.Identifier)) {
+    if (id2.getText() === symbolName && isDeclaration(id2)) return id2;
   }
   return void 0;
 }
@@ -13679,33 +13761,33 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const { project, sourceFile } = loadProjectFile(file);
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk142.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk145.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(
-    chalk142.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk145.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines] of grouped) {
     console.log(
-      `  ${chalk142.dim(refFile)}: lines ${chalk142.cyan(lines.join(", "))}`
+      `  ${chalk145.dim(refFile)}: lines ${chalk145.cyan(lines.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk142.green(`
+    console.log(chalk145.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk142.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk145.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
 import path46 from "path";
-import chalk145 from "chalk";
+import chalk148 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
 import path40 from "path";
@@ -13784,50 +13866,50 @@ function clusterFiles(graph) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path42 from "path";
-import chalk143 from "chalk";
+import chalk146 from "chalk";
 function relPath(filePath) {
   return path42.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk143.bold("\nFile moves:"));
+  console.log(chalk146.bold("\nFile moves:"));
   for (const move of plan2.moves) {
     console.log(
-      `  ${chalk143.red(relPath(move.from))} \u2192 ${chalk143.green(relPath(move.to))}`
+      `  ${chalk146.red(relPath(move.from))} \u2192 ${chalk146.green(relPath(move.to))}`
     );
-    console.log(chalk143.dim(`    ${move.reason}`));
+    console.log(chalk146.dim(`    ${move.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk143.bold(`
+  console.log(chalk146.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk143.cyan(relPath(file))}:`);
+    console.log(`  ${chalk146.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk143.red(`"${oldSpecifier}"`)} \u2192 ${chalk143.green(`"${newSpecifier}"`)}`
+        `    ${chalk146.red(`"${oldSpecifier}"`)} \u2192 ${chalk146.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk143.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk143.yellow(`  ${w}`));
+    console.log(chalk146.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk146.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk143.bold("\nNew directories:"));
+    console.log(chalk146.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk143.green(`  ${dir}/`));
+      console.log(chalk146.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk143.dim(
+    chalk146.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -13837,18 +13919,18 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 // src/commands/refactor/restructure/executePlan.ts
 import fs24 from "fs";
 import path43 from "path";
-import chalk144 from "chalk";
+import chalk147 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs24.writeFileSync(file, content, "utf-8");
     console.log(
-      chalk144.cyan(`  Rewrote imports in ${path43.relative(process.cwd(), file)}`)
+      chalk147.cyan(`  Rewrote imports in ${path43.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs24.mkdirSync(dir, { recursive: true });
-    console.log(chalk144.green(`  Created ${path43.relative(process.cwd(), dir)}/`));
+    console.log(chalk147.green(`  Created ${path43.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan2.moves) {
     const targetDir = path43.dirname(move.to);
@@ -13857,7 +13939,7 @@ function executePlan(plan2) {
     }
     fs24.renameSync(move.from, move.to);
     console.log(
-      chalk144.white(
+      chalk147.white(
         `  Moved ${path43.relative(process.cwd(), move.from)} \u2192 ${path43.relative(process.cwd(), move.to)}`
       )
     );
@@ -13872,7 +13954,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs24.rmdirSync(dir);
       console.log(
-        chalk144.dim(
+        chalk147.dim(
           `  Removed empty directory ${path43.relative(process.cwd(), dir)}`
         )
       );
@@ -14005,22 +14087,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk145.yellow("No files found matching pattern"));
+    console.log(chalk148.yellow("No files found matching pattern"));
     return;
   }
   const tsConfigPath = path46.resolve("tsconfig.json");
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk145.green("No restructuring needed"));
+    console.log(chalk148.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk145.bold("\nApplying changes..."));
+    console.log(chalk148.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk145.green("\nRestructuring complete"));
+    console.log(chalk148.green("\nRestructuring complete"));
   } else {
-    console.log(chalk145.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk148.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -14589,18 +14671,18 @@ function partitionFindingsByDiff(findings, index2) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk146 from "chalk";
+import chalk149 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk146.yellow(
+    chalk149.yellow(
       `Skipped ${outOfDiff.length} finding(s) whose lines fall outside the PR diff (GitHub would silently drop these):`
     )
   );
   for (const finding of outOfDiff) {
     const range = finding.startLine !== void 0 ? `${finding.startLine}-${finding.line}` : `${finding.line}`;
     console.warn(
-      `  ${chalk146.yellow("\xB7")} ${finding.title} ${chalk146.dim(
+      `  ${chalk149.yellow("\xB7")} ${finding.title} ${chalk149.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -14619,18 +14701,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk147 from "chalk";
+import chalk150 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk147.yellow(
+    chalk150.yellow(
       `Skipped ${unlocated.length} finding(s) without a parseable file:line:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk147.dim("missing");
+    const where = finding.location || chalk150.dim("missing");
     console.warn(
-      `  ${chalk147.yellow("\xB7")} ${finding.title} ${chalk147.dim(`(${where})`)}`
+      `  ${chalk150.yellow("\xB7")} ${finding.title} ${chalk150.dim(`(${where})`)}`
     );
   }
 }
@@ -15016,9 +15098,11 @@ function printReviewerFailures(results) {
 import { existsSync as existsSync38, unlinkSync as unlinkSync14 } from "fs";
 
 // src/commands/review/buildReviewerStdin.ts
-var REVIEW_PROMPT = `You are acting as a reviewer for a proposed code change made by another engineer. The full review request \u2014 branch, base, changed files, and unified diff \u2014 is in request.md in the current working directory.
+var REVIEW_PROMPT = `You are acting as a reviewer for a proposed code change made by another engineer. The full review request \u2014 branch, base, changed files, and unified diff \u2014 is in the request file whose absolute path is given below.
+
+Your working directory is the repository under review, so you can read any file in it for context beyond the diff.
 
-Read request.md, then produce a thorough code review in Markdown.
+Read the request file, then produce a thorough code review in Markdown.
 
 ## When to flag a finding
 
@@ -15054,7 +15138,7 @@ List every finding that the original author would want to know about and fix. Do
 
 For each finding include:
 - Severity (blocker, major, minor, nit) \u2014 see rubric below
-- File and line (e.g. \`src/foo.ts:42\`) when the finding is tied to a specific location. Take the line number from the diff's left gutter (its line in the new file); never count lines in request.md.
+- File and line (e.g. \`src/foo.ts:42\`) when the finding is tied to a specific location. Take the line number from the diff's left gutter (its line in the new file); never count lines in the request file.
 - Impact: what could go wrong, including the conditions under which it manifests
 - Recommendation: a concrete change
 
@@ -15458,11 +15542,9 @@ function parseCodexEvent(line) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-function codexArgs(reviewDir, outputPath) {
+function codexArgs(outputPath) {
   return [
     "exec",
-    "--cd",
-    reviewDir,
     "--sandbox",
     "read-only",
     "--json",
@@ -15476,7 +15558,7 @@ async function runCodexReviewer(spec) {
   const result = await runStreamingChild({
     name: spec.name,
     command,
-    args: codexArgs(spec.reviewDir, spec.outputPath),
+    args: codexArgs(spec.outputPath),
     stdin: spec.stdin,
     quiet: Boolean(spinner),
     onLine: (line) => {
@@ -15500,7 +15582,6 @@ function resolveCodex(args) {
   const spinner = args.multi?.create("codex \u2014 starting");
   return runCodexReviewer({
     name: "codex",
-    reviewDir: args.reviewDir,
     stdin: args.stdin,
     outputPath: args.codexPath,
     spinner
@@ -15517,7 +15598,6 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
     multi: options2.multi
   });
   const codexPromise = resolveCodex({
-    reviewDir,
     codexPath,
     stdin: stdinPrompt,
     plan: options2.codexPlan,
@@ -15803,7 +15883,7 @@ function registerReview(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk149 from "chalk";
+import chalk152 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -15832,10 +15912,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk148 from "chalk";
+import chalk151 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk148.red(`Connection "${name}" already exists.`));
+    console.error(chalk151.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -15853,16 +15933,16 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk149.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk152.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk153 from "chalk";
+import chalk156 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk150 from "chalk";
+import chalk153 from "chalk";
 async function fetchSeq(conn, path56, params) {
   const url = `${conn.url}${path56}?${params}`;
   const response = await fetch(url, {
@@ -15873,7 +15953,7 @@ async function fetchSeq(conn, path56, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk150.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk153.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -15932,23 +16012,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk151 from "chalk";
+import chalk154 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk151.bgRed.white;
+      return chalk154.bgRed.white;
     case "Error":
-      return chalk151.red;
+      return chalk154.red;
     case "Warning":
-      return chalk151.yellow;
+      return chalk154.yellow;
     case "Information":
-      return chalk151.cyan;
+      return chalk154.cyan;
     case "Debug":
-      return chalk151.gray;
+      return chalk154.gray;
     case "Verbose":
-      return chalk151.dim;
+      return chalk154.dim;
     default:
-      return chalk151.white;
+      return chalk154.white;
   }
 }
 function levelAbbrev(level) {
@@ -15989,12 +16069,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk151.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk154.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines.push(chalk151.red(`  ${line}`));
+      lines.push(chalk154.red(`  ${line}`));
     }
   }
   return lines.join("\n");
@@ -16027,11 +16107,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk152 from "chalk";
+import chalk155 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk152.red(
+      chalk155.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -16040,7 +16120,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(chalk152.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk155.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -16069,7 +16149,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count6) })
   );
   if (events.length === 0) {
-    console.log(chalk153.yellow("No events found."));
+    console.log(chalk156.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -16080,11 +16160,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk153.dim(`
+  console.log(chalk156.dim(`
 ${events.length} events`));
   if (events.length >= count6) {
     console.log(
-      chalk153.yellow(
+      chalk156.yellow(
         `Results limited to ${count6}. Use --count to retrieve more.`
       )
     );
@@ -16092,10 +16172,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk154 from "chalk";
+import chalk157 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk154.red(`Connection "${name}" not found.`));
+    console.error(chalk157.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -16132,18 +16212,18 @@ function registerSeq(program2) {
 // src/commands/registerSignal.ts
 function registerSignal(program2) {
   const signalCommand = program2.command("signal").description("Write an assist signal file");
-  signalCommand.command("next").argument("[id]", "Backlog item ID to run directly").description("Write a next signal to chain into assist next").action((id) => {
-    writeSignal("next", id ? { id } : void 0);
+  signalCommand.command("next").argument("[id]", "Backlog item ID to run directly").description("Write a next signal to chain into assist next").action((id2) => {
+    writeSignal("next", id2 ? { id: id2 } : void 0);
     console.log("Signal written.");
   });
-  signalCommand.command("done").argument("[id]", "Backlog item ID created by the session").description("Write a done signal to end a --once launch session").action((id) => {
-    writeSignal("done", id ? { id } : void 0);
+  signalCommand.command("done").argument("[id]", "Backlog item ID created by the session").description("Write a done signal to end a --once launch session").action((id2) => {
+    writeSignal("done", id2 ? { id: id2 } : void 0);
     console.log("Signal written.");
   });
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk156 from "chalk";
+import chalk159 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -16172,7 +16252,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk155 from "chalk";
+import chalk158 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -16180,7 +16260,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk155.red(`Invalid port "${portStr}".`));
+    console.error(chalk158.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -16193,13 +16273,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk156.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk159.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk157 from "chalk";
+import chalk160 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -16208,7 +16288,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk157.yellow("(no rows)"));
+    console.log(chalk160.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -16216,13 +16296,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(chalk157.dim(header));
-  console.log(chalk157.dim("-".repeat(header.length)));
+  console.log(chalk160.dim(header));
+  console.log(chalk160.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(chalk157.dim(`
+  console.log(chalk160.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -16282,7 +16362,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk158 from "chalk";
+import chalk161 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -16316,7 +16396,7 @@ function isMutation(sql4) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk158.red(
+      chalk161.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -16326,18 +16406,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk158.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk161.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk159 from "chalk";
+import chalk162 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk159.red(
+      chalk162.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -16352,7 +16432,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk159.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk162.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -16932,14 +17012,14 @@ import {
 import { dirname as dirname22, join as join42 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk160 from "chalk";
+import chalk163 from "chalk";
 var FULL_TRANSCRIPT_REGEX = /^\[Full Transcript\]\(([^)]+)\)/;
 function validateStagedContent(filename, content) {
   const firstLine = content.split("\n")[0];
   const match = firstLine.match(FULL_TRANSCRIPT_REGEX);
   if (!match) {
     console.error(
-      chalk160.red(
+      chalk163.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -16948,7 +17028,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk160.red(
+      chalk163.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -17345,7 +17425,7 @@ function registerVoice(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk161 from "chalk";
+import chalk164 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer2 } from "http";
@@ -17476,13 +17556,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk161.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk164.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk161.white("http://localhost:14523/callback\n"));
-  console.log(chalk161.blue("Opening browser for authorization..."));
-  console.log(chalk161.dim("Waiting for authorization callback..."));
+  console.log(chalk164.white("http://localhost:14523/callback\n"));
+  console.log(chalk164.blue("Opening browser for authorization..."));
+  console.log(chalk164.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk161.dim("Exchanging code for tokens..."));
+  console.log(chalk164.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -17498,7 +17578,7 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk161.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk164.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
@@ -17737,13 +17817,13 @@ function execRunConfig(config, args) {
     config.quiet
   );
 }
-function parseBacklogRunOptions(id, args) {
+function parseBacklogRunOptions(id2, args) {
   let allowEdits = true;
   for (const arg of args) {
     if (arg === "--write" || arg === "-w") allowEdits = true;
     else if (arg === "--no-write") allowEdits = false;
     else {
-      console.error(`error: unexpected argument '${arg}' for 'run ${id}'`);
+      console.error(`error: unexpected argument '${arg}' for 'run ${id2}'`);
       process.exit(1);
     }
   }
@@ -17950,7 +18030,7 @@ import { execSync as execSync48 } from "child_process";
 import { existsSync as existsSync50, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync32 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
 import { join as join53, resolve as resolve13 } from "path";
-import chalk162 from "chalk";
+import chalk165 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -18101,13 +18181,13 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve13(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk162.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk165.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk162.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk165.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk162.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk165.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -18294,7 +18374,7 @@ function toPersistedSession(session) {
 
 // src/commands/sessions/daemon/toSessionInfo.ts
 function toSessionInfo({
-  id,
+  id: id2,
   name,
   commandType,
   status: status2,
@@ -18309,7 +18389,7 @@ function toSessionInfo({
   autoAdvance
 }) {
   return {
-    id,
+    id: id2,
     name,
     commandType,
     status: status2,
@@ -18396,14 +18476,14 @@ function shellEscape(s) {
 }
 
 // src/commands/sessions/daemon/createAssistSession.ts
-function createAssistSession(id, assistArgs, cwd) {
+function createAssistSession(id2, assistArgs, cwd) {
   return {
-    id,
+    id: id2,
     name: `assist ${assistArgs.join(" ")}`,
     commandType: "assist",
     status: "running",
     startedAt: Date.now(),
-    pty: spawnPty(["assist", ...assistArgs], cwd, id),
+    pty: spawnPty(["assist", ...assistArgs], cwd, id2),
     scrollback: "",
     idleTimer: null,
     lastResizeAt: 0,
@@ -18428,10 +18508,10 @@ function spawnRun(opts) {
 }
 
 // src/commands/sessions/daemon/createSession.ts
-function createSession(id, prompt, cwd) {
+function createSession(id2, prompt, cwd) {
   return {
-    id,
-    name: prompt?.slice(0, 40) || `Session ${id}`,
+    id: id2,
+    name: prompt?.slice(0, 40) || `Session ${id2}`,
     commandType: "claude",
     status: "running",
     startedAt: Date.now(),
@@ -18442,9 +18522,9 @@ function createSession(id, prompt, cwd) {
     cwd
   };
 }
-function createRunSession(id, runName, runArgs, cwd) {
+function createRunSession(id2, runName, runArgs, cwd) {
   return {
-    id,
+    id: id2,
     name: `run: ${runName}`,
     commandType: "run",
     status: "running",
@@ -18515,9 +18595,9 @@ function backlogRunArgs(persisted) {
 }
 
 // src/commands/sessions/daemon/restoreBase.ts
-function restoreBase(id, persisted) {
+function restoreBase(id2, persisted) {
   return {
-    id,
+    id: id2,
     name: persisted.name,
     commandType: persisted.commandType,
     scrollback: "",
@@ -18542,10 +18622,10 @@ function runningSession(base, persisted, pty2) {
 }
 
 // src/commands/sessions/daemon/restoreSession.ts
-function restoreSession(id, persisted) {
-  const base = restoreBase(id, persisted);
+function restoreSession(id2, persisted) {
+  const base = restoreBase(id2, persisted);
   if (isBacklogRun(persisted)) {
-    const pty2 = spawnPty(backlogRunArgs(persisted), persisted.cwd, id);
+    const pty2 = spawnPty(backlogRunArgs(persisted), persisted.cwd, id2);
     return runningSession(base, persisted, pty2);
   }
   if (persisted.commandType !== "run" && persisted.claudeSessionId) {
@@ -18570,9 +18650,9 @@ function isBacklogRun(persisted) {
 }
 
 // src/commands/sessions/daemon/resumeSession.ts
-function resumeSession(id, sessionId, cwd, name) {
+function resumeSession(id2, sessionId, cwd, name) {
   return {
-    id,
+    id: id2,
     name: name ? `${name.slice(0, 36)} (R)` : `Resume ${sessionId.slice(0, 8)}`,
     commandType: "claude",
     status: "running",
@@ -18941,8 +19021,8 @@ function handleSessions(state, msg) {
     id: toWindowsSessionId(s.id)
   }));
   const live = new Set(state.windowsSessions.map((s) => s.id));
-  for (const id of state.scrollback.keys())
-    if (!live.has(id)) state.scrollback.delete(id);
+  for (const id2 of state.scrollback.keys())
+    if (!live.has(id2)) state.scrollback.delete(id2);
   state.onSessionsChanged();
 }
 function handleOutput(state, msg) {
@@ -19404,25 +19484,25 @@ function isBacklogRun2(session) {
 }
 
 // src/commands/sessions/daemon/writeToSession.ts
-function writeToSession(sessions, id, data) {
-  const s = sessions.get(id);
+function writeToSession(sessions, id2, data) {
+  const s = sessions.get(id2);
   if (s && s.status !== "done") s.pty?.write(data);
 }
-function resizeSession(sessions, id, cols, rows) {
-  const s = sessions.get(id);
+function resizeSession(sessions, id2, cols, rows) {
+  const s = sessions.get(id2);
   if (s && s.status !== "done") {
     s.lastResizeAt = Date.now();
     s.pty?.resize(cols, rows);
   }
 }
-function setAutoRun(sessions, id, enabled) {
-  const s = sessions.get(id);
+function setAutoRun(sessions, id2, enabled) {
+  const s = sessions.get(id2);
   if (!s) return false;
   s.autoRun = enabled;
   return true;
 }
-function setAutoAdvance(sessions, id, enabled) {
-  const s = sessions.get(id);
+function setAutoAdvance(sessions, id2, enabled) {
+  const s = sessions.get(id2);
   if (!s) return false;
   s.autoAdvance = enabled;
   const itemId = s.activity?.itemId;
@@ -19432,15 +19512,15 @@ function setAutoAdvance(sessions, id, enabled) {
   }
   return true;
 }
-function dismissSession(sessions, id) {
-  const s = sessions.get(id);
+function dismissSession(sessions, id2) {
+  const s = sessions.get(id2);
   if (!s) return false;
   if (s.status !== "done") s.pty?.kill();
   clearIdle(s);
   s.activityWatcher?.close();
   removeActivity(s.id);
   if (s.activity?.itemId != null) releaseLock(s.activity.itemId);
-  sessions.delete(id);
+  sessions.delete(id2);
   return true;
 }
 
@@ -19473,7 +19553,7 @@ var SessionManager = class {
   }
   restore() {
     return loadPersistedSessions().map((persisted) => {
-      this.spawnWith((id) => restoreSession(id, persisted));
+      this.spawnWith((id2) => restoreSession(id2, persisted));
       return persisted.name;
     });
   }
@@ -19487,19 +19567,19 @@ var SessionManager = class {
     return this.add(create(String(this.nextId++)));
   }
   spawn(prompt, cwd) {
-    return this.spawnWith((id) => createSession(id, prompt, cwd));
+    return this.spawnWith((id2) => createSession(id2, prompt, cwd));
   }
   spawnRun(runName, runArgs, cwd) {
-    return this.spawnWith((id) => createRunSession(id, runName, runArgs, cwd));
+    return this.spawnWith((id2) => createRunSession(id2, runName, runArgs, cwd));
   }
   spawnAssist(assistArgs, cwd) {
-    return this.spawnWith((id) => createAssistSession(id, assistArgs, cwd));
+    return this.spawnWith((id2) => createAssistSession(id2, assistArgs, cwd));
   }
   resume(sessionId, cwd, name) {
-    return this.spawnWith((id) => resumeSession(id, sessionId, cwd, name));
+    return this.spawnWith((id2) => resumeSession(id2, sessionId, cwd, name));
   }
   onStatusChange = makeStatusChangeHandler(
-    (id) => this.dismissSession(id),
+    (id2) => this.dismissSession(id2),
     () => this.notify(),
     (session, itemId) => reuseSessionForRun(session, itemId, this.clients, this.onStatusChange)
   );
@@ -19508,24 +19588,24 @@ var SessionManager = class {
     wirePtyEvents(session, this.clients, this.onStatusChange);
     this.notify();
   }
-  writeToSession(id, data) {
-    writeToSession(this.sessions, id, data);
+  writeToSession(id2, data) {
+    writeToSession(this.sessions, id2, data);
   }
-  resizeSession(id, cols, rows) {
-    resizeSession(this.sessions, id, cols, rows);
+  resizeSession(id2, cols, rows) {
+    resizeSession(this.sessions, id2, cols, rows);
   }
-  retrySession(id) {
-    const s = this.sessions.get(id);
+  retrySession(id2) {
+    const s = this.sessions.get(id2);
     if (s && retrySession(s, this.clients, this.onStatusChange)) this.notify();
   }
-  dismissSession = (id) => {
-    if (dismissSession(this.sessions, id)) this.notify();
+  dismissSession = (id2) => {
+    if (dismissSession(this.sessions, id2)) this.notify();
   };
-  setAutoRun(id, enabled) {
-    if (setAutoRun(this.sessions, id, enabled)) this.notify();
+  setAutoRun(id2, enabled) {
+    if (setAutoRun(this.sessions, id2, enabled)) this.notify();
   }
-  setAutoAdvance(id, enabled) {
-    if (setAutoAdvance(this.sessions, id, enabled)) this.notify();
+  setAutoAdvance(id2, enabled) {
+    if (setAutoAdvance(this.sessions, id2, enabled)) this.notify();
   }
   listSessions = () => {
     const local = [...this.sessions.values()].map(toSessionInfo);
@@ -19883,7 +19963,7 @@ function registerDaemon(program2) {
 
 // src/commands/sessions/summarise/index.ts
 import * as fs33 from "fs";
-import chalk163 from "chalk";
+import chalk166 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs31 from "fs";
@@ -19941,8 +20021,8 @@ function truncate3(text3, maxChars = 500) {
 function scanSessionBacklogRefs(filePath) {
   const ids = /* @__PURE__ */ new Set();
   for (const text3 of iterateUserMessages(filePath, Number.MAX_SAFE_INTEGER)) {
-    for (const id of extractBacklogIds(text3)) {
-      ids.add(id);
+    for (const id2 of extractBacklogIds(text3)) {
+      ids.add(id2);
     }
   }
   return [...ids].sort((a, b) => a - b);
@@ -19994,7 +20074,7 @@ function buildPrompt2(firstMessage, backlogIds) {
     "Return ONLY the summary, no quotes or explanation."
   ];
   if (backlogIds.length > 0) {
-    const refs = backlogIds.map((id) => `#${id}`).join(", ");
+    const refs = backlogIds.map((id2) => `#${id2}`).join(", ");
     parts.push(
       `The session references backlog item(s) ${refs}. Start the summary with "Backlog ${refs} \u2014" if relevant.`
     );
@@ -20010,22 +20090,22 @@ ${firstMessage}`);
 async function summarise4(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk163.yellow("No sessions found."));
+    console.log(chalk166.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk163.green("All sessions already summarised."));
+    console.log(chalk166.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk163.cyan(
+    chalk166.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk163.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk163.yellow(`, ${failed2} skipped`) : "")
+    chalk166.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk166.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -20045,16 +20125,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk163.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk166.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk163.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk166.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk163.yellow("skip")}
+      process.stdout.write(` ${chalk166.yellow("skip")}
 `);
     }
   }
@@ -20069,10 +20149,10 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk165 from "chalk";
+import chalk168 from "chalk";
 
 // src/commands/buildLimitsSegment.ts
-import chalk164 from "chalk";
+import chalk167 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -20103,9 +20183,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk164.green,
-  warn: chalk164.yellow,
-  over: chalk164.red
+  ok: chalk167.green,
+  warn: chalk167.yellow,
+  over: chalk167.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -20153,14 +20233,14 @@ async function relayRateLimits(rateLimits) {
 }
 
 // src/commands/statusLine.ts
-chalk165.level = 3;
+chalk168.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
 function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
-  if (pct > 80) return chalk165.red(label2);
-  if (pct > 40) return chalk165.yellow(label2);
+  if (pct > 80) return chalk168.red(label2);
+  if (pct > 40) return chalk168.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -20184,7 +20264,7 @@ import { fileURLToPath as fileURLToPath7 } from "url";
 // src/commands/sync/syncClaudeMd.ts
 import * as fs34 from "fs";
 import * as path52 from "path";
-import chalk166 from "chalk";
+import chalk169 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path52.join(claudeDir, "CLAUDE.md");
   const target = path52.join(targetBase, "CLAUDE.md");
@@ -20193,12 +20273,12 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
     const targetContent = fs34.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk166.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk169.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = options2?.yes || await promptConfirm(
-        chalk166.red("Overwrite existing CLAUDE.md?"),
+        chalk169.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -20214,7 +20294,7 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 // src/commands/sync/syncSettings.ts
 import * as fs35 from "fs";
 import * as path53 from "path";
-import chalk167 from "chalk";
+import chalk170 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path53.join(claudeDir, "settings.json");
   const target = path53.join(targetBase, "settings.json");
@@ -20230,14 +20310,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk167.yellow(
+          chalk170.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk167.red("Overwrite existing settings.json?"),
+          chalk170.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {