@staff0rd/assist 0.253.0 → 0.254.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.253.0",
+  version: "0.254.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -73,6 +73,8 @@ var package_default = {
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
     "@types/better-sqlite3": "^7.6.13",
     "@types/blessed": "^0.1.27",
     "@types/mssql": "^12.3.0",
@@ -90,6 +92,7 @@ var package_default = {
     "@xterm/xterm": "^6.0.0",
     esbuild: "^0.27.3",
     jscpd: "^4.0.5",
+    jsdom: "^29.1.1",
     knip: "^5.71.0",
     marked: "^15.0.12",
     react: "^19.2.4",
@@ -115,10 +118,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path54) {
-  if (!existsSync(path54)) return {};
+function loadRawYaml(path53) {
+  if (!existsSync(path53)) return {};
   try {
-    const content = readFileSync(path54, "utf-8");
+    const content = readFileSync(path53, "utf-8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -2743,9 +2746,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path54 = join10(dir, ".assist", name);
-    if (existsSync14(path54)) {
-      renameSync(path54, `${path54}.bak`);
+    const path53 = join10(dir, ".assist", name);
+    if (existsSync14(path53)) {
+      renameSync(path53, `${path53}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -2893,12 +2896,12 @@ var selectTasks = (orm, ids) => orm.select().from(planTasks).where(inArray(planT
   asc(planTasks.phaseIdx),
   asc(planTasks.idx)
 );
-async function loadRelations(orm, ids) {
+async function loadRelations(orm, ids, { includeComments = true, includeTasks = true } = {}) {
   const [commentRows, linkRows, phaseRows, taskRows] = await Promise.all([
-    selectComments(orm, ids),
+    includeComments ? selectComments(orm, ids) : [],
     selectLinks(orm, ids),
     selectPhases(orm, ids),
-    selectTasks(orm, ids)
+    includeTasks ? selectTasks(orm, ids) : []
   ]);
   return {
     comments: groupByItem(commentRows),
@@ -2985,7 +2988,8 @@ async function loadAllItems(orm, origin) {
   if (rows.length === 0) return [];
   const rel = await loadRelations(
     orm,
-    rows.map((r) => r.id)
+    rows.map((r) => r.id),
+    { includeComments: false, includeTasks: false }
   );
   return rows.map((row) => rowToItem(row, rel));
 }
@@ -3034,8 +3038,8 @@ var backlogItemSchema = z3.strictObject({
 var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path54) {
-  const content = readFileSync9(path54, "utf-8").trim();
+function parseBacklogJsonl(path53) {
+  const content = readFileSync9(path53, "utf-8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -3110,8 +3114,8 @@ function findBacklogUp(startDir) {
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execSync as execSync17 } from "child_process";
-function stripLeadingSlashes(path54) {
-  return path54.replace(/^\/+/, "");
+function stripLeadingSlashes(path53) {
+  return path53.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -3423,6 +3427,33 @@ async function reloadPlan(id) {
 // src/commands/backlog/executePhase.ts
 import chalk34 from "chalk";
 
+// src/shared/emitActivity.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync11, rmSync, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname14, join as join14 } from "path";
+function activityPath(cwd, sessionId) {
+  return join14(cwd, ".assist", `activity-${sessionId}.json`);
+}
+function emitActivity(activity2) {
+  const sessionId = process.env.ASSIST_ACTIVITY_ID;
+  if (!sessionId) return;
+  const path53 = activityPath(process.cwd(), sessionId);
+  mkdirSync4(dirname14(path53), { recursive: true });
+  writeFileSync12(path53, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+}
+function readActivity(path53) {
+  try {
+    return JSON.parse(readFileSync11(path53, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function removeActivity(cwd, sessionId) {
+  try {
+    rmSync(activityPath(cwd, sessionId));
+  } catch {
+  }
+}
+
 // src/shared/spawnClaude.ts
 import { spawn as spawn3 } from "child_process";
 function spawnClaude(prompt, options2 = {}) {
@@ -3430,8 +3461,10 @@ function spawnClaude(prompt, options2 = {}) {
   if (options2.allowEdits) {
     args.push("--permission-mode", "auto");
   }
+  const { ASSIST_ACTIVITY_ID: _activityId, ...env } = process.env;
   const child = spawn3("claude", args, {
-    stdio: "inherit"
+    stdio: "inherit",
+    env
   });
   const done2 = new Promise((resolve16, reject) => {
     child.on("close", (code) => resolve16(code ?? 0));
@@ -3565,28 +3598,28 @@ async function handleIncompletePhase() {
 }
 
 // src/commands/backlog/readSignal.ts
-import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
 
 // src/commands/backlog/writeSignal.ts
-import { writeFileSync as writeFileSync12 } from "fs";
-import { join as join14 } from "path";
+import { writeFileSync as writeFileSync13 } from "fs";
+import { join as join15 } from "path";
 function getSignalPath() {
   const sessionId = process.env.ASSIST_SESSION_ID;
   const filename = sessionId ? `.assist-signal-${sessionId}.json` : ".assist-signal.json";
-  return join14(getBacklogDir(), filename);
+  return join15(getBacklogDir(), filename);
 }
 function writeSignal(event, data) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   const signal = { event, ...sessionId && { sessionId }, ...data };
-  writeFileSync12(getSignalPath(), JSON.stringify(signal));
+  writeFileSync13(getSignalPath(), JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path54 = getSignalPath();
-  if (!existsSync18(path54)) return void 0;
+  const path53 = getSignalPath();
+  if (!existsSync18(path53)) return void 0;
   try {
-    return JSON.parse(readFileSync11(path54, "utf-8"));
+    return JSON.parse(readFileSync12(path53, "utf-8"));
   } catch {
     return void 0;
   }
@@ -3600,8 +3633,8 @@ function cleanupSignal() {
   }
 }
 async function isTerminalStatus(itemId) {
-  const items2 = await loadBacklog();
-  const item = items2.find((i) => i.id === itemId);
+  const { orm } = await getReady();
+  const item = await loadItem(orm, itemId);
   return item?.status === "done" || item?.status === "wontdo";
 }
 async function resolvePhaseResult(phaseIndex, itemId) {
@@ -3644,17 +3677,24 @@ function stopWatching() {
 }
 
 // src/commands/backlog/executePhase.ts
-async function executePhase(item, phaseIndex, phases, spawnOptions) {
+async function executePhase(item, phaseIndex, phases, spawnOptions, totalPhases = phases.length) {
   const phase = phases[phaseIndex];
   const phaseNumber = phaseIndex + 1;
   console.log(
     chalk34.bold(
       `
---- Phase ${phaseNumber}/${phases.length}: ${phase.name} ---
+--- Phase ${phaseNumber}/${totalPhases}: ${phase.name} ---
 `
     )
   );
-  process.env.ASSIST_SESSION_ID = String(process.pid);
+  process.env.ASSIST_SESSION_ID ??= String(process.pid);
+  emitActivity({
+    kind: "backlog",
+    itemId: item.id,
+    itemName: item.name,
+    phase: phaseNumber,
+    totalPhases
+  });
   const { child, done: done2 } = spawnClaude(
     buildPhasePrompt(item, phaseNumber, phase),
     spawnOptions
@@ -3674,7 +3714,9 @@ async function runPhases(item, startPhase, plan2, spawnOptions) {
       item,
       phaseIndex,
       currentPlan,
-      spawnOptions
+      spawnOptions,
+      // +1 for the review phase appended after the authored phases complete
+      currentPlan.length + 1
     );
     if (phaseIndex < 0) return false;
     currentPlan = await reloadPlan(item.id) ?? currentPlan;
@@ -4023,10 +4065,10 @@ import { WebSocketServer } from "ws";
 
 // src/shared/getInstallDir.ts
 import { execSync as execSync18 } from "child_process";
-import { dirname as dirname14, resolve as resolve6 } from "path";
+import { dirname as dirname15, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname4 = dirname14(__filename2);
+var __dirname4 = dirname15(__filename2);
 function getInstallDir() {
   return resolve6(__dirname4, "..");
 }
@@ -4103,7 +4145,7 @@ function startWebServer(label2, port, handler, initialPath) {
 import { spawn as spawn4 } from "child_process";
 import {
   closeSync,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   openSync,
   statSync,
   unlinkSync as unlinkSync4,
@@ -4115,14 +4157,14 @@ import * as net from "net";
 
 // src/commands/sessions/daemon/daemonPaths.ts
 import { homedir as homedir3 } from "os";
-import { join as join15 } from "path";
-var DAEMON_DIR = join15(homedir3(), ".assist", "daemon");
+import { join as join16 } from "path";
+var DAEMON_DIR = join16(homedir3(), ".assist", "daemon");
 var daemonPaths = {
   dir: DAEMON_DIR,
-  socket: process.platform === "win32" ? "\\\\.\\pipe\\assist-sessions-daemon" : join15(DAEMON_DIR, "daemon.sock"),
-  log: join15(DAEMON_DIR, "daemon.log"),
-  pid: join15(DAEMON_DIR, "daemon.pid"),
-  spawnLock: join15(DAEMON_DIR, "spawn.lock")
+  socket: process.platform === "win32" ? "\\\\.\\pipe\\assist-sessions-daemon" : join16(DAEMON_DIR, "daemon.sock"),
+  log: join16(DAEMON_DIR, "daemon.log"),
+  pid: join16(DAEMON_DIR, "daemon.pid"),
+  spawnLock: join16(DAEMON_DIR, "spawn.lock")
 };
 
 // src/commands/sessions/daemon/connectToDaemon.ts
@@ -4148,7 +4190,7 @@ var RETRY_DELAY_MS = 200;
 var STALE_LOCK_MS = SPAWN_TIMEOUT_MS + 5e3;
 async function ensureDaemonRunning(reason = "unspecified") {
   if (await isDaemonRunning()) return;
-  mkdirSync4(daemonPaths.dir, { recursive: true });
+  mkdirSync5(daemonPaths.dir, { recursive: true });
   const holdsLock = acquireSpawnLock();
   if (holdsLock) spawnDaemon(reason);
   try {
@@ -4213,19 +4255,19 @@ function delay(ms) {
 }
 
 // src/commands/sessions/web/handleRequest.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { createRequire as createRequire2 } from "module";
 
 // src/shared/createBundleHandler.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { dirname as dirname15, join as join16 } from "path";
+import { readFileSync as readFileSync13 } from "fs";
+import { dirname as dirname16, join as join17 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function createBundleHandler(importMetaUrl, bundlePath) {
-  const dir = dirname15(fileURLToPath4(importMetaUrl));
+  const dir = dirname16(fileURLToPath4(importMetaUrl));
   let cache;
   return (_req, res) => {
     if (!cache) {
-      cache = readFileSync12(join16(dir, bundlePath), "utf-8");
+      cache = readFileSync13(join17(dir, bundlePath), "utf-8");
     }
     res.writeHead(200, { "Content-Type": "application/javascript" });
     res.end(cache);
@@ -4293,31 +4335,79 @@ async function createItem(req, res) {
   respondJson(res, 201, { id, ...newItem });
 }
 
+// src/commands/backlog/loadBacklogSummaries.ts
+import { eq as eq11 } from "drizzle-orm";
+
+// src/commands/backlog/loadItemSummaries.ts
+import { asc as asc4, eq as eq10 } from "drizzle-orm";
+async function loadItemSummaries(orm, origin) {
+  const rows = await orm.select({
+    id: items.id,
+    origin: items.origin,
+    type: items.type,
+    name: items.name,
+    status: items.status
+  }).from(items).where(origin === void 0 ? void 0 : eq10(items.origin, origin)).orderBy(asc4(items.id));
+  return rows.map((row) => ({
+    id: row.id,
+    origin: row.origin,
+    type: row.type,
+    name: row.name,
+    status: row.status
+  }));
+}
+
+// src/commands/backlog/loadBacklogSummaries.ts
+async function loadBacklogSummaries(allRepos = false) {
+  const { orm } = await getReady();
+  return loadItemSummaries(orm, allRepos ? void 0 : getOrigin());
+}
+async function searchBacklogSummaries(query) {
+  const { orm } = await getReady();
+  const origin = getOrigin();
+  const ids = await searchItemIds(orm, query, origin);
+  const summaries = await loadItemSummaries(orm, origin);
+  return summaries.filter((item) => ids.includes(item.id));
+}
+async function backlogHasItems() {
+  const { orm } = await getReady();
+  const [row] = await orm.select({ id: items.id }).from(items).where(eq11(items.origin, getOrigin())).limit(1);
+  return row !== void 0;
+}
+
 // src/commands/backlog/web/getBacklogExists.ts
 async function getBacklogExists(req, res) {
   applyCwdFromReq(req);
-  const items2 = await loadBacklog();
-  respondJson(res, 200, { exists: items2.length > 0 });
+  respondJson(res, 200, { exists: await backlogHasItems() });
 }
 
 // src/commands/backlog/web/rewindItemPhase.ts
-import { eq as eq11 } from "drizzle-orm";
+import { eq as eq13 } from "drizzle-orm";
 
 // src/commands/backlog/deleteComment.ts
-import { and as and2, eq as eq10 } from "drizzle-orm";
+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(eq10(comments.id, commentId), eq10(comments.itemId, itemId)));
+  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(eq10(comments.id, commentId), eq10(comments.itemId, itemId)));
+  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));
+}
+
 // src/commands/backlog/web/shared.ts
 async function listItems(req, res) {
   applyCwdFromReq(req);
-  const q = new URL(req.url ?? "/", "http://localhost").searchParams.get("q");
-  const items2 = q ? await searchBacklog(q) : await loadBacklog();
+  const items2 = await loadVisibleItems(req);
   respondJson(res, 200, items2.slice().reverse());
 }
 async function findItemOr404(res, id) {
@@ -4384,7 +4474,7 @@ async function rewindItemPhase(req, res, id) {
     `Rewound to phase ${phase} (${phaseName}): ${reason}`,
     { phase }
   );
-  await orm.update(items).set({ currentPhase: phase, status: "in-progress" }).where(eq11(items.id, id));
+  await orm.update(items).set({ currentPhase: phase, status: "in-progress" }).where(eq13(items.id, id));
   respondJson(res, 200, await loadItem(orm, id));
 }
 function validateRewind(item, phase) {
@@ -4402,7 +4492,7 @@ function validateRewind(item, phase) {
 }
 
 // src/commands/backlog/web/updateItem.ts
-import { eq as eq12 } from "drizzle-orm";
+import { eq as eq14 } from "drizzle-orm";
 async function updateItem(req, res, id) {
   const body = await parseItemBody(req);
   const result = await findItemOr404(res, id);
@@ -4413,7 +4503,7 @@ async function updateItem(req, res, id) {
     name: body.name,
     description: body.description ?? null,
     acceptanceCriteria: JSON.stringify(body.acceptanceCriteria ?? [])
-  }).where(eq12(items.id, id));
+  }).where(eq14(items.id, id));
   respondJson(res, 200, await loadItem(orm, id));
 }
 
@@ -4525,7 +4615,7 @@ function createCssHandler(packageEntry) {
   return (_req, res) => {
     if (!cache) {
       const resolved = require3.resolve(packageEntry);
-      cache = readFileSync13(resolved, "utf-8");
+      cache = readFileSync14(resolved, "utf-8");
     }
     res.writeHead(200, { "Content-Type": "text/css" });
     res.end(cache);
@@ -4996,9 +5086,9 @@ import chalk51 from "chalk";
 
 // src/commands/backlog/add/shared.ts
 import { spawnSync } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync14, unlinkSync as unlinkSync5, writeFileSync as writeFileSync13 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync15, unlinkSync as unlinkSync5, writeFileSync as writeFileSync14 } from "fs";
 import { tmpdir } from "os";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import enquirer6 from "enquirer";
 async function promptType() {
   const { type } = await enquirer6.prompt({
@@ -5038,15 +5128,15 @@ async function promptDescription() {
 }
 function openEditor() {
   const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-  const dir = mkdtempSync(join17(tmpdir(), "assist-"));
-  const filePath = join17(dir, "description.md");
-  writeFileSync13(filePath, "");
+  const dir = mkdtempSync(join18(tmpdir(), "assist-"));
+  const filePath = join18(dir, "description.md");
+  writeFileSync14(filePath, "");
   const result = spawnSync(editor, [filePath], { stdio: "inherit" });
   if (result.status !== 0) {
     unlinkSync5(filePath);
     return void 0;
   }
-  const content = readFileSync14(filePath, "utf-8").trim();
+  const content = readFileSync15(filePath, "utf-8").trim();
   unlinkSync5(filePath);
   return content || void 0;
 }
@@ -5089,22 +5179,22 @@ async function add(options2) {
 import chalk53 from "chalk";
 
 // src/commands/backlog/insertPhaseAt.ts
-import { count, eq as eq14 } from "drizzle-orm";
+import { count, eq as eq16 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and3, desc, eq as eq13, gte } from "drizzle-orm";
+import { and as and3, desc, eq as eq15, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and3(eq13(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and3(eq15(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(eq13(planTasks.itemId, itemId), eq13(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and3(eq13(planPhases.itemId, itemId), eq13(planPhases.idx, p.idx)));
+    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)));
   }
 }
 
 // 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(eq14(planPhases.itemId, itemId));
+    const [row] = await tx.select({ cnt: count() }).from(planPhases).where(eq16(planPhases.itemId, itemId));
     const phaseCount = row?.cnt ?? 0;
     await shiftPhasesUp(tx, itemId, phaseIdx);
     await tx.insert(planPhases).values({ itemId, idx: phaseIdx, name, manualChecks });
@@ -5113,16 +5203,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(eq14(items.id, itemId));
+      await tx.update(items).set({ currentPhase: atReviewSlot ? phaseIdx + 1 : currentPhase + 1 }).where(eq16(items.id, itemId));
     }
   });
 }
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk52 from "chalk";
-import { count as count2, eq as eq15 } from "drizzle-orm";
+import { count as count2, eq as eq17 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId, position) {
-  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(eq15(planPhases.itemId, itemId));
+  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(eq17(planPhases.itemId, itemId));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -5180,8 +5270,8 @@ import chalk54 from "chalk";
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path54 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path54.split("/").filter(Boolean);
+    const path53 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path53.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -5236,9 +5326,9 @@ async function list2(options2) {
   const repoNameOf = (item) => item.origin ? labels.get(item.origin) ?? "" : "";
   const prefixWidth = options2.allRepos ? Math.max(0, ...items2.map((i) => repoNameOf(i).length)) : 0;
   for (const item of items2) {
-    const repoPrefix2 = options2.allRepos ? `${chalk54.dim(repoNameOf(item).padEnd(prefixWidth))} ` : "";
+    const repoPrefix = options2.allRepos ? `${chalk54.dim(repoNameOf(item).padEnd(prefixWidth))} ` : "";
     console.log(
-      `${repoPrefix2}${statusIcon(item.status)} ${typeLabel(item.type)} ${chalk54.dim(`#${item.id}`)} ${item.name}${phaseLabel(item)}${dependencyLabel(item, allItems)}`
+      `${repoPrefix}${statusIcon(item.status)} ${typeLabel(item.type)} ${chalk54.dim(`#${item.id}`)} ${item.name}${phaseLabel(item)}${dependencyLabel(item, allItems)}`
     );
     if (options2.verbose) {
       printVerboseDetails(item);
@@ -5283,9 +5373,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq16 } from "drizzle-orm";
+import { eq as eq18 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq16(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq18(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId, targetId } of rows) {
     const bucket = graph.get(itemId);
@@ -5348,7 +5438,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk57 from "chalk";
-import { and as and4, eq as eq17 } from "drizzle-orm";
+import { and as and4, eq as eq19 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = Number.parseInt(fromId, 10);
   const toNum = Number.parseInt(toId, 10);
@@ -5366,7 +5456,7 @@ async function unlink(fromId, toId) {
     console.log(chalk57.yellow(`No link from #${fromId} to #${toId} found.`));
     return;
   }
-  await orm.delete(links).where(and4(eq17(links.itemId, fromNum), eq17(links.targetId, toNum)));
+  await orm.delete(links).where(and4(eq19(links.itemId, fromNum), eq19(links.targetId, toNum)));
   console.log(chalk57.green(`Removed link from #${fromId} to #${toId}.`));
 }
 
@@ -5382,7 +5472,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/move-repo/index.ts
 import chalk59 from "chalk";
-import { eq as eq19 } from "drizzle-orm";
+import { eq as eq21 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk58 from "chalk";
@@ -5397,9 +5487,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count3, eq as eq18 } from "drizzle-orm";
+import { count as count3, eq as eq20 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count3() }).from(items).where(eq18(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count3() }).from(items).where(eq20(items.origin, origin));
   return cnt;
 }
 
@@ -5442,7 +5532,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk59.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq19(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq21(items.origin, oldOrigin));
   console.log(
     chalk59.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -5482,9 +5572,9 @@ import chalk61 from "chalk";
 // src/commands/backlog/tryRunById.ts
 import chalk60 from "chalk";
 async function tryRunById(id, options2) {
-  const items2 = await loadBacklog();
   const numericId = Number.parseInt(id, 10);
-  const item = Number.isNaN(numericId) ? void 0 : items2.find((i) => i.id === numericId);
+  const { orm } = await getReady();
+  const item = Number.isNaN(numericId) ? void 0 : await loadItem(orm, numericId);
   if (!item) {
     console.log(chalk60.red(`Item #${id} not found.`));
     return false;
@@ -5497,7 +5587,8 @@ async function tryRunById(id, options2) {
     console.log(chalk60.red(`Item #${id} is marked won't do.`));
     return false;
   }
-  if (isBlocked(item, items2)) {
+  const hasDeps = (item.links ?? []).some((l) => l.type === "depends-on");
+  if (hasDeps && isBlocked(item, await loadItemSummaries(orm, getOrigin()))) {
     console.log(
       chalk60.red(`Item #${id} is blocked by unresolved dependencies.`)
     );
@@ -5517,7 +5608,8 @@ function buildSlashCommand(slashCommand, description) {
 }
 async function launchMode(slashCommand, options2) {
   pullIfConfigured();
-  process.env.ASSIST_SESSION_ID = String(process.pid);
+  process.env.ASSIST_SESSION_ID ??= String(process.pid);
+  emitActivity({ kind: "command", name: slashCommand });
   const { child, done: done2 } = spawnClaude(
     buildSlashCommand(slashCommand, options2?.description),
     { allowEdits: true }
@@ -5538,7 +5630,7 @@ async function launchMode(slashCommand, options2) {
 
 // src/commands/backlog/refine.ts
 async function pickItemForRefine() {
-  const items2 = await loadBacklog();
+  const items2 = await loadBacklogSummaries();
   const active = items2.filter(
     (i) => i.status === "todo" || i.status === "in-progress"
   );
@@ -5713,10 +5805,10 @@ async function start(id) {
 
 // src/commands/backlog/stop/index.ts
 import chalk68 from "chalk";
-import { and as and5, eq as eq20 } from "drizzle-orm";
+import { and as and5, eq as eq22 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
-  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and5(eq20(items.status, "in-progress"), eq20(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  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 });
   if (stopped.length === 0) {
     console.log(chalk68.yellow("No in-progress items to stop."));
     return;
@@ -5751,18 +5843,18 @@ function registerStatusCommands(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk71 from "chalk";
-import { and as and8, eq as eq23 } from "drizzle-orm";
+import { and as and8, eq as eq25 } from "drizzle-orm";
 
 // src/commands/backlog/findPhase.ts
 import chalk70 from "chalk";
-import { and as and6, count as count4, eq as eq21 } from "drizzle-orm";
+import { and as and6, count as count4, eq as eq23 } from "drizzle-orm";
 async function findPhase(id, phase) {
   const found = await findOneItem(id);
   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(eq21(planPhases.itemId, itemId), eq21(planPhases.idx, phaseIdx)));
+  const [row] = await orm.select({ cnt: count4() }).from(planPhases).where(and6(eq23(planPhases.itemId, itemId), eq23(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
       chalk70.red(`Phase ${phaseIdx + 1} not found on item #${itemId}.`)
@@ -5774,14 +5866,14 @@ async function findPhase(id, phase) {
 }
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and7, asc as asc4, count as count5, eq as eq22 } from "drizzle-orm";
+import { and as and7, asc as asc5, count as count5, eq as eq24 } from "drizzle-orm";
 async function reindexPhases(db, itemId) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq22(planPhases.itemId, itemId)).orderBy(asc4(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq24(planPhases.itemId, itemId)).orderBy(asc5(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(eq22(planTasks.itemId, itemId), eq22(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and7(eq22(planPhases.itemId, itemId), eq22(planPhases.idx, oldIdx)));
+    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)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -5789,13 +5881,13 @@ 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(eq22(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq24(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq22(planPhases.itemId, item.id));
+  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq24(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq22(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq24(items.id, item.id));
 }
 
 // src/commands/backlog/removePhase.ts
@@ -5805,9 +5897,9 @@ async function removePhase(id, phase) {
   const { item, orm, itemId, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and8(eq23(planTasks.itemId, itemId), eq23(planTasks.phaseIdx, phaseIdx))
+      and8(eq25(planTasks.itemId, itemId), eq25(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and8(eq23(planPhases.itemId, itemId), eq23(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and8(eq25(planPhases.itemId, itemId), eq25(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
@@ -5818,7 +5910,7 @@ async function removePhase(id, phase) {
 
 // src/commands/backlog/update/index.ts
 import chalk73 from "chalk";
-import { eq as eq24 } from "drizzle-orm";
+import { eq as eq26 } from "drizzle-orm";
 
 // src/commands/backlog/update/parseListIndex.ts
 function parseListIndex(raw, length, label2) {
@@ -5952,7 +6044,7 @@ async function update(id, options2) {
   if (!built) return;
   const { orm } = found;
   const itemId = found.item.id;
-  await orm.update(items).set(built.set).where(eq24(items.id, itemId));
+  await orm.update(items).set(built.set).where(eq26(items.id, itemId));
   console.log(chalk73.green(`Updated ${built.fields} on item #${itemId}.`));
 }
 
@@ -5960,22 +6052,22 @@ async function update(id, options2) {
 import chalk74 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and9, eq as eq25 } from "drizzle-orm";
+import { and as and9, eq as eq27 } 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(eq25(planPhases.itemId, itemId), eq25(planPhases.idx, phaseIdx))
+        and9(eq27(planPhases.itemId, itemId), eq27(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and9(eq25(planPhases.itemId, itemId), eq25(planPhases.idx, phaseIdx))
+        and9(eq27(planPhases.itemId, itemId), eq27(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and9(eq25(planTasks.itemId, itemId), eq25(planTasks.phaseIdx, phaseIdx))
+        and9(eq27(planTasks.itemId, itemId), eq27(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -6265,13 +6357,13 @@ function stripEnvPrefix(parts) {
 }
 
 // src/commands/cliHook/logDeniedToolCall.ts
-import { mkdirSync as mkdirSync5 } from "fs";
+import { mkdirSync as mkdirSync6 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import Database from "better-sqlite3";
 var _db;
 function getDbDir() {
-  return join18(homedir4(), ".assist");
+  return join19(homedir4(), ".assist");
 }
 function initSchema(db) {
   db.exec(`
@@ -6289,8 +6381,8 @@ function initSchema(db) {
 function openPromptsDb(dir) {
   if (_db) return _db;
   const dbDir = dir ?? getDbDir();
-  mkdirSync5(dbDir, { recursive: true });
-  const db = new Database(join18(dbDir, "assist.db"));
+  mkdirSync6(dbDir, { recursive: true });
+  const db = new Database(join19(dbDir, "assist.db"));
   db.pragma("journal_mode = WAL");
   initSchema(db);
   _db = db;
@@ -6392,17 +6484,17 @@ function extractGraphqlQuery(args) {
 }
 
 // src/shared/loadCliReads.ts
-import { existsSync as existsSync21, readFileSync as readFileSync15, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname16, resolve as resolve7 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync16, writeFileSync as writeFileSync15 } from "fs";
+import { dirname as dirname17, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename3 = fileURLToPath5(import.meta.url);
-var __dirname5 = dirname16(__filename3);
+var __dirname5 = dirname17(__filename3);
 function packageRoot() {
   return __dirname5;
 }
-function readLines(path54) {
-  if (!existsSync21(path54)) return [];
-  return readFileSync15(path54, "utf-8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path53) {
+  if (!existsSync21(path53)) return [];
+  return readFileSync16(path53, "utf-8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -6422,7 +6514,7 @@ function loadCliReads() {
   return getCliReadsLines();
 }
 function saveCliReads(commands) {
-  writeFileSync14(
+  writeFileSync15(
     resolve7(packageRoot(), "allowed.cli-reads"),
     `${commands.join("\n")}
 `
@@ -6448,14 +6540,14 @@ function findCliWrite(command) {
 }
 
 // src/shared/readSettingsPerms.ts
-import { existsSync as existsSync22, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync17 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function readSettingsPerms(key) {
   const paths = [
-    join19(homedir5(), ".claude", "settings.json"),
-    join19(process.cwd(), ".claude", "settings.json"),
-    join19(process.cwd(), ".claude", "settings.local.json")
+    join20(homedir5(), ".claude", "settings.json"),
+    join20(process.cwd(), ".claude", "settings.json"),
+    join20(process.cwd(), ".claude", "settings.local.json")
   ];
   const entries = [];
   for (const p of paths) {
@@ -6466,7 +6558,7 @@ function readSettingsPerms(key) {
 function readPermissionArray(filePath, key) {
   if (!existsSync22(filePath)) return [];
   try {
-    const data = JSON.parse(readFileSync16(filePath, "utf-8"));
+    const data = JSON.parse(readFileSync17(filePath, "utf-8"));
     const arr = data?.permissions?.[key];
     return Array.isArray(arr) ? arr.filter((e) => typeof e === "string") : [];
   } catch {
@@ -6746,9 +6838,9 @@ ${reasons.join("\n")}`);
 }
 
 // src/commands/permitCliReads/index.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync6, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync7, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // src/shared/checkCliAvailable.ts
 import { execSync as execSync19 } from "child_process";
@@ -6885,14 +6977,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path54, description, depth, p) {
-  showProgress(p, path54.join(" "));
-  const subHelp = await runHelp([cli, ...path54]);
+async function resolveCommand(cli, path53, description, depth, p) {
+  showProgress(p, path53.join(" "));
+  const subHelp = await runHelp([cli, ...path53]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path54, description }];
+    return [{ path: path53, description }];
   }
-  const children = await discoverAt(cli, path54, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path54, description }];
+  const children = await discoverAt(cli, path53, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path53, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -7037,17 +7129,17 @@ function updateSettings(cli, commands) {
 // src/commands/permitCliReads/index.ts
 function logPath(cli) {
   const safeName = cli.replace(/\s+/g, "-");
-  return join20(homedir6(), ".assist", `cli-discover-${safeName}.log`);
+  return join21(homedir6(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path54 = logPath(cli);
-  if (!existsSync23(path54)) return void 0;
-  return readFileSync17(path54, "utf-8");
+  const path53 = logPath(cli);
+  if (!existsSync23(path53)) return void 0;
+  return readFileSync18(path53, "utf-8");
 }
 function writeCache(cli, output) {
-  const dir = join20(homedir6(), ".assist");
-  mkdirSync6(dir, { recursive: true });
-  writeFileSync15(logPath(cli), output);
+  const dir = join21(homedir6(), ".assist");
+  mkdirSync7(dir, { recursive: true });
+  writeFileSync16(logPath(cli), output);
 }
 async function permitCliReads(cli, options2 = { noCache: false }) {
   if (!cli) {
@@ -7641,6 +7733,11 @@ async function analyze(pattern2) {
     await halstead(file);
     console.log();
     console.log(chalk84.bold.underline("Maintainability Index"));
+    console.log(
+      chalk84.dim(
+        "171 - 5.2*ln(HalsteadVolume) - 0.23*CyclomaticComplexity - 16.2*ln(SLOC), clamped 0-100"
+      )
+    );
     await maintainability(file);
     return;
   }
@@ -7707,8 +7804,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path54, value) {
-  const keys = path54.split(".");
+function setNestedValue(obj, path53, value) {
+  const keys = path53.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -7788,9 +7885,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path54) {
+function getNestedValue(obj, path53) {
   let current = obj;
-  for (const key of path54.split(".")) current = stepInto(current, key);
+  for (const key of path53.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -7824,7 +7921,7 @@ function registerConfig(program2) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync24, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync19, writeFileSync as writeFileSync17 } from "fs";
 import chalk87 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
@@ -7837,7 +7934,7 @@ function redirect() {
     console.log(chalk87.yellow("No index.html found"));
     return;
   }
-  const content = readFileSync18(indexPath, "utf-8");
+  const content = readFileSync19(indexPath, "utf-8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
     console.log(chalk87.dim("Trailing slash script already present"));
     return;
@@ -7848,7 +7945,7 @@ function redirect() {
     return;
   }
   const newContent = content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT + "\n  " + content.slice(headCloseIndex);
-  writeFileSync16(indexPath, newContent);
+  writeFileSync17(indexPath, newContent);
   console.log(chalk87.green("Added trailing slash redirect to index.html"));
 }
 
@@ -7865,10 +7962,10 @@ import { basename as basename4 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
 import { homedir as homedir7 } from "os";
-import { join as join21 } from "path";
-var BLOG_REPO_ROOT = join21(homedir7(), "git/blog");
+import { join as join22 } from "path";
+var BLOG_REPO_ROOT = join22(homedir7(), "git/blog");
 function loadBlogSkipDays(repoName) {
-  const config = loadRawYaml(join21(BLOG_REPO_ROOT, "assist.yml"));
+  const config = loadRawYaml(join22(BLOG_REPO_ROOT, "assist.yml"));
   const devlog = config.devlog;
   const skip2 = devlog?.skip;
   return new Set(skip2?.[repoName] ?? []);
@@ -7879,17 +7976,17 @@ import { execSync as execSync20 } from "child_process";
 import chalk88 from "chalk";
 
 // src/shared/getRepoName.ts
-import { existsSync as existsSync25, readFileSync as readFileSync19 } from "fs";
-import { basename as basename3, join as join22 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync20 } from "fs";
+import { basename as basename3, join as join23 } from "path";
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
     return config.devlog.name;
   }
-  const packageJsonPath = join22(process.cwd(), "package.json");
+  const packageJsonPath = join23(process.cwd(), "package.json");
   if (existsSync25(packageJsonPath)) {
     try {
-      const content = readFileSync19(packageJsonPath, "utf-8");
+      const content = readFileSync20(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.name) {
         return pkg.name;
@@ -7901,9 +7998,9 @@ function getRepoName() {
 }
 
 // src/commands/devlog/loadDevlogEntries.ts
-import { readdirSync, readFileSync as readFileSync20 } from "fs";
-import { join as join23 } from "path";
-var DEVLOG_DIR = join23(BLOG_REPO_ROOT, "src/content/devlog");
+import { readdirSync, readFileSync as readFileSync21 } from "fs";
+import { join as join24 } from "path";
+var DEVLOG_DIR = join24(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
   const fm = content.match(/^---\n([\s\S]*?)\n---/);
   return fm?.[1] ?? null;
@@ -7931,7 +8028,7 @@ function readDevlogFiles(callback) {
   try {
     const files = readdirSync(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync20(join23(DEVLOG_DIR, file), "utf-8");
+      const content = readFileSync21(join24(DEVLOG_DIR, file), "utf-8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -8318,12 +8415,12 @@ function repos(options2) {
 }
 
 // src/commands/devlog/skip.ts
-import { writeFileSync as writeFileSync17 } from "fs";
-import { join as join24 } from "path";
+import { writeFileSync as writeFileSync18 } from "fs";
+import { join as join25 } from "path";
 import chalk93 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
-  return join24(BLOG_REPO_ROOT, "assist.yml");
+  return join25(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
@@ -8347,7 +8444,7 @@ function skip(date) {
   skip2[repoName] = skipDays;
   devlog.skip = skip2;
   config.devlog = devlog;
-  writeFileSync17(configPath, stringifyYaml3(config, { lineWidth: 0 }));
+  writeFileSync18(configPath, stringifyYaml3(config, { lineWidth: 0 }));
   console.log(chalk93.green(`Added ${date} to skip list for ${repoName}`));
 }
 
@@ -8384,7 +8481,7 @@ function registerDevlog(program2) {
 
 // src/commands/dotnet/checkBuildLocks.ts
 import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 import chalk95 from "chalk";
 
 // src/shared/findRepoRoot.ts
@@ -8412,7 +8509,7 @@ function isLockedDll(debugDir) {
   }
   for (const file of files) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
-    const dllPath = join25(debugDir, file);
+    const dllPath = join26(debugDir, file);
     try {
       const fd = openSync2(dllPath, "r+");
       closeSync2(fd);
@@ -8430,13 +8527,13 @@ function findFirstLockedDll(dir) {
     return null;
   }
   if (entries.includes("bin")) {
-    const locked = isLockedDll(join25(dir, "bin", "Debug"));
+    const locked = isLockedDll(join26(dir, "bin", "Debug"));
     if (locked) return locked;
   }
   for (const entry of entries) {
     if (SKIP_DIRS.has(entry) || entry === "bin" || entry.startsWith("."))
       continue;
-    const found = findFirstLockedDll(join25(dir, entry));
+    const found = findFirstLockedDll(join26(dir, entry));
     if (found) return found;
   }
   return null;
@@ -8459,11 +8556,11 @@ async function checkBuildLocksCommand() {
 }
 
 // src/commands/dotnet/buildTree.ts
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 import path21 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
-  const content = readFileSync21(csprojPath, "utf-8");
+  const content = readFileSync22(csprojPath, "utf-8");
   const refs = [];
   for (const match of content.matchAll(PROJECT_REF_RE)) {
     refs.push(match[1].replace(/\\/g, "/"));
@@ -8480,7 +8577,7 @@ function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
   for (const ref of getProjectRefs(abs)) {
     const childAbs = path21.resolve(dir, ref);
     try {
-      readFileSync21(childAbs);
+      readFileSync22(childAbs);
       node.children.push(buildTree(childAbs, repoRoot, visited));
     } catch {
       node.children.push({
@@ -8505,7 +8602,7 @@ function collectAllDeps(node) {
 }
 
 // src/commands/dotnet/findContainingSolutions.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync22, statSync as statSync2 } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync23, statSync as statSync2 } from "fs";
 import path22 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
@@ -8540,7 +8637,7 @@ function findContainingSolutions(csprojPath, repoRoot) {
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
   for (const sln of slnFiles) {
     try {
-      const content = readFileSync22(sln, "utf-8");
+      const content = readFileSync23(sln, "utf-8");
       if (pattern2.test(content)) {
         matches.push(path22.relative(repoRoot, sln));
       }
@@ -8783,11 +8880,11 @@ import chalk101 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
 import { readdirSync as readdirSync4 } from "fs";
-import { dirname as dirname17, join as join26 } from "path";
+import { dirname as dirname18, join as join27 } from "path";
 import chalk100 from "chalk";
 function findSlnInDir(dir) {
   try {
-    return readdirSync4(dir).filter((f) => f.endsWith(".sln")).map((f) => join26(dir, f));
+    return readdirSync4(dir).filter((f) => f.endsWith(".sln")).map((f) => join27(dir, f));
   } catch {
     return [];
   }
@@ -8808,7 +8905,7 @@ function findSolution() {
       process.exit(1);
     }
     if (current === ceiling) break;
-    current = dirname17(current);
+    current = dirname18(current);
   }
   console.error(chalk100.red("No .sln file found between cwd and repo root"));
   process.exit(1);
@@ -8858,7 +8955,7 @@ function parseInspectReport(json) {
 
 // src/commands/dotnet/runInspectCode.ts
 import { execSync as execSync24 } from "child_process";
-import { existsSync as existsSync29, readFileSync as readFileSync23, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync24, unlinkSync as unlinkSync6 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import path25 from "path";
 import chalk102 from "chalk";
@@ -8893,7 +8990,7 @@ function runInspectCode(slnPath, include, swea) {
     console.error(chalk102.red("Report file not generated"));
     process.exit(1);
   }
-  const xml = readFileSync23(reportPath, "utf-8");
+  const xml = readFileSync24(reportPath, "utf-8");
   unlinkSync6(reportPath);
   return xml;
 }
@@ -9020,9 +9117,9 @@ function aggregateCommitters(authorLists) {
 
 // src/shared/runGhGraphql.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { unlinkSync as unlinkSync7, writeFileSync as writeFileSync18 } from "fs";
+import { unlinkSync as unlinkSync7, writeFileSync as writeFileSync19 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function buildArgs(queryFile, vars) {
   const args = ["api", "graphql", "-F", `query=@${queryFile}`];
   for (const [key, value] of Object.entries(vars)) {
@@ -9032,8 +9129,8 @@ function buildArgs(queryFile, vars) {
   return args;
 }
 function runGhGraphql(mutation, vars) {
-  const queryFile = join27(tmpdir4(), `gh-query-${Date.now()}.graphql`);
-  writeFileSync18(queryFile, mutation);
+  const queryFile = join28(tmpdir4(), `gh-query-${Date.now()}.graphql`);
+  writeFileSync19(queryFile, mutation);
   try {
     const result = spawnSync2("gh", buildArgs(queryFile, vars), {
       encoding: "utf-8"
@@ -9210,8 +9307,8 @@ function registerGithub(program2) {
 }
 
 // src/commands/handover/archive.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync7, renameSync as renameSync2 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync8, renameSync as renameSync2 } from "fs";
+import { join as join30 } from "path";
 
 // src/commands/handover/formatArchiveTimestamp.ts
 function formatArchiveTimestamp(date = /* @__PURE__ */ new Date()) {
@@ -9226,9 +9323,9 @@ function formatArchiveTimestamp(date = /* @__PURE__ */ new Date()) {
 }
 
 // src/commands/handover/getHandoverArchiveDir.ts
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 function getHandoverArchiveDir(cwd = process.cwd()) {
-  return join28(cwd, ".assist", "handovers", "archive");
+  return join29(cwd, ".assist", "handovers", "archive");
 }
 
 // src/commands/handover/archive.ts
@@ -9238,11 +9335,11 @@ function buildArchiveFilename(timestamp, suffix) {
   return `${base}.md`;
 }
 function resolveCollisionPath(archiveDir, timestamp, suffix) {
-  const initial = join29(archiveDir, buildArchiveFilename(timestamp, suffix));
+  const initial = join30(archiveDir, buildArchiveFilename(timestamp, suffix));
   if (!existsSync30(initial)) return initial;
   for (let i = 1; i <= MAX_COLLISION_SUFFIX; i++) {
     const collisionSuffix = suffix ? `${suffix}-${i}` : `${i}`;
-    const candidate = join29(
+    const candidate = join30(
       archiveDir,
       buildArchiveFilename(timestamp, collisionSuffix)
     );
@@ -9257,7 +9354,7 @@ function archive(options2 = {}) {
   const handoverPath = getHandoverPath(cwd);
   if (!existsSync30(handoverPath)) return void 0;
   const archiveDir = getHandoverArchiveDir(cwd);
-  mkdirSync7(archiveDir, { recursive: true });
+  mkdirSync8(archiveDir, { recursive: true });
   const timestamp = formatArchiveTimestamp(options2.now);
   const destination = resolveCollisionPath(
     archiveDir,
@@ -9269,7 +9366,7 @@ function archive(options2 = {}) {
 }
 
 // src/commands/handover/load.ts
-import { existsSync as existsSync31, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync26 } from "fs";
 
 // src/commands/handover/parseLoadInput.ts
 async function parseLoadInput(stdin) {
@@ -9385,7 +9482,7 @@ function normaliseOutput(raw) {
 function loadFromHandover(cwd) {
   const handoverPath = getHandoverPath(cwd);
   if (!existsSync31(handoverPath)) return void 0;
-  const content = readFileSync25(handoverPath, "utf-8");
+  const content = readFileSync26(handoverPath, "utf-8");
   archive({ cwd });
   return {
     additionalContext: content,
@@ -9552,20 +9649,20 @@ function acceptanceCriteria(issueKey) {
 import { execSync as execSync27 } from "child_process";
 
 // src/shared/loadJson.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync8, readFileSync as readFileSync26, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync9, readFileSync as readFileSync27, writeFileSync as writeFileSync20 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 function getStoreDir() {
-  return join30(homedir8(), ".assist");
+  return join31(homedir8(), ".assist");
 }
 function getStorePath(filename) {
-  return join30(getStoreDir(), filename);
+  return join31(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path54 = getStorePath(filename);
-  if (existsSync32(path54)) {
+  const path53 = getStorePath(filename);
+  if (existsSync32(path53)) {
     try {
-      return JSON.parse(readFileSync26(path54, "utf-8"));
+      return JSON.parse(readFileSync27(path53, "utf-8"));
     } catch {
       return {};
     }
@@ -9575,9 +9672,9 @@ function loadJson(filename) {
 function saveJson(filename, data) {
   const dir = getStoreDir();
   if (!existsSync32(dir)) {
-    mkdirSync8(dir, { recursive: true });
+    mkdirSync9(dir, { recursive: true });
   }
-  writeFileSync19(getStorePath(filename), JSON.stringify(data, null, 2));
+  writeFileSync20(getStorePath(filename), JSON.stringify(data, null, 2));
 }
 
 // src/shared/promptInput.ts
@@ -9710,12 +9807,12 @@ function registerList(program2) {
 }
 
 // src/commands/mermaid/index.ts
-import { mkdirSync as mkdirSync9, readdirSync as readdirSync5 } from "fs";
+import { mkdirSync as mkdirSync10, readdirSync as readdirSync5 } from "fs";
 import { resolve as resolve10 } from "path";
 import chalk113 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync20 } from "fs";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync21 } from "fs";
 import { basename as basename5, extname, resolve as resolve9 } from "path";
 import chalk112 from "chalk";
 
@@ -9741,7 +9838,7 @@ async function renderBlock(krokiUrl, source) {
 
 // src/commands/mermaid/exportFile.ts
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
-  const content = readFileSync27(file, "utf8");
+  const content = readFileSync28(file, "utf8");
   const blocks = extractMermaidBlocks(content);
   const stem = basename5(file, extname(file));
   if (onlyIndex !== void 0) {
@@ -9766,7 +9863,7 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
     if (onlyIndex !== void 0 && idx !== onlyIndex) continue;
     const outPath = resolve9(outDir, `${stem}-${idx}.svg`);
     const svg = await renderBlock(krokiUrl, source);
-    writeFileSync20(outPath, svg, "utf8");
+    writeFileSync21(outPath, svg, "utf8");
     console.log(chalk112.green(`  \u2192 ${outPath}`));
   }
 }
@@ -9779,7 +9876,7 @@ function extractMermaidBlocks(markdown) {
 async function mermaidExport(file, options2 = {}) {
   const { mermaid } = loadConfig();
   const outDir = resolve10(process.cwd(), options2.out ?? ".");
-  mkdirSync9(outDir, { recursive: true });
+  mkdirSync10(outDir, { recursive: true });
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
       console.error(
@@ -10249,15 +10346,15 @@ function postComment(vars) {
   }
   runGhGraphql(MUTATION_MULTI, { ...base, startLine });
 }
-function comment2(path54, line, body, startLine) {
+function comment2(path53, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path54, line, startLine });
+    postComment({ prId, body, path: path53, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path54}:${range}`);
+    console.log(`Added review comment on ${path53}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -10335,23 +10432,23 @@ import { execSync as execSync32 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
 import { execSync as execSync31 } from "child_process";
-import { unlinkSync as unlinkSync9, writeFileSync as writeFileSync21 } from "fs";
+import { unlinkSync as unlinkSync9, writeFileSync as writeFileSync22 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync33, readFileSync as readFileSync28, unlinkSync as unlinkSync8 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync29, unlinkSync as unlinkSync8 } from "fs";
+import { join as join32 } from "path";
 import { parse as parse2 } from "yaml";
 function getCachePath(prNumber) {
-  return join31(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join32(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
   if (!existsSync33(cachePath)) {
     return null;
   }
-  const content = readFileSync28(cachePath, "utf-8");
+  const content = readFileSync29(cachePath, "utf-8");
   return parse2(content);
 }
 function deleteCommentsCache(prNumber) {
@@ -10371,8 +10468,8 @@ function replyToComment(org, repo, prNumber, commentId, message) {
 }
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join32(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
-  writeFileSync21(queryFile, mutation);
+  const queryFile = join33(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
+  writeFileSync22(queryFile, mutation);
   try {
     execSync31(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
@@ -10453,19 +10550,19 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments/index.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync10, writeFileSync as writeFileSync23 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync11, writeFileSync as writeFileSync24 } from "fs";
+import { join as join35 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
 import { execSync as execSync33 } from "child_process";
-import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync22 } from "fs";
+import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync23 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var THREAD_QUERY = `query($owner: String!, $repo: String!, $prNumber: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $prNumber) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 100) { nodes { databaseId } } } } } } }`;
 function fetchThreadIds(org, repo, prNumber) {
-  const queryFile = join33(tmpdir6(), `gh-query-${Date.now()}.graphql`);
-  writeFileSync22(queryFile, THREAD_QUERY);
+  const queryFile = join34(tmpdir6(), `gh-query-${Date.now()}.graphql`);
+  writeFileSync23(queryFile, THREAD_QUERY);
   try {
     const result = execSync33(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
@@ -10578,17 +10675,17 @@ function printComments2(result) {
 
 // src/commands/prs/listComments/index.ts
 function writeCommentsCache(prNumber, comments3) {
-  const assistDir = join34(process.cwd(), ".assist");
+  const assistDir = join35(process.cwd(), ".assist");
   if (!existsSync34(assistDir)) {
-    mkdirSync10(assistDir, { recursive: true });
+    mkdirSync11(assistDir, { recursive: true });
   }
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  const cachePath = join34(assistDir, `pr-${prNumber}-comments.yaml`);
-  writeFileSync23(cachePath, stringify(cacheData));
+  const cachePath = join35(assistDir, `pr-${prNumber}-comments.yaml`);
+  writeFileSync24(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
   if (isGhNotInstalled(error)) {
@@ -10620,7 +10717,7 @@ async function listComments() {
     ];
     updateCache(prNumber, allComments);
     const hasLineComments = allComments.some((c) => c.type === "line");
-    const cachePath = hasLineComments ? join34(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
+    const cachePath = hasLineComments ? join35(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
     return { comments: allComments, cachePath };
   } catch (error) {
     const handled = handleKnownErrors(error);
@@ -10837,8 +10934,8 @@ function registerPrs(program2) {
   prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason) => {
     wontfix(Number.parseInt(commentId, 10), reason);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path54, line, body) => {
-    comment2(path54, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path53, line, body) => {
+    comment2(path53, Number.parseInt(line, 10), body);
   });
 }
 
@@ -11090,10 +11187,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path54) {
+async function ravenFetch(connection, path53) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path54}`;
+  const url = `${connection.url}${path53}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -11183,16 +11280,16 @@ import chalk129 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path54;
+  let path53;
   if (opts.collection) {
-    path54 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path53 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path54 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path53 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path54 += `&query=${encodeURIComponent(opts.query)}`;
+    path53 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path54;
+  return path53;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -11201,7 +11298,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path54 = buildQueryPath({
+    const path53 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -11209,7 +11306,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path54);
+    const data = await ravenFetch(connection, path53);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -12427,8 +12524,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename11 = path38.basename(file, path38.extname(file));
-    if (basename11 === "index") continue;
+    const basename10 = path38.basename(file, path38.extname(file));
+    if (basename10 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -12905,15 +13002,15 @@ ${context.diff.trimEnd()}
 }
 
 // src/commands/review/buildReviewPaths.ts
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join35(repoRoot, ".assist", "reviews", key);
+  const reviewDir = join36(repoRoot, ".assist", "reviews", key);
   return {
     reviewDir,
-    requestPath: join35(reviewDir, "request.md"),
-    claudePath: join35(reviewDir, "claude.md"),
-    codexPath: join35(reviewDir, "codex.md"),
-    synthesisPath: join35(reviewDir, "synthesis.md")
+    requestPath: join36(reviewDir, "request.md"),
+    claudePath: join36(reviewDir, "claude.md"),
+    codexPath: join36(reviewDir, "codex.md"),
+    synthesisPath: join36(reviewDir, "synthesis.md")
   };
 }
 
@@ -12921,24 +13018,24 @@ function buildReviewPaths(repoRoot, key) {
 import {
   appendFileSync,
   existsSync as existsSync35,
-  readFileSync as readFileSync29,
-  writeFileSync as writeFileSync24
+  readFileSync as readFileSync30,
+  writeFileSync as writeFileSync25
 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 var REVIEWS_ENTRY = ".assist/reviews";
 function coversReviews(line) {
   const pattern2 = line.trim().replace(/^\//, "").replace(/\/$/, "");
   return pattern2 === ".assist" || pattern2 === REVIEWS_ENTRY;
 }
 function ensureReviewsIgnored(repoRoot) {
-  const gitignorePath = join36(repoRoot, ".gitignore");
+  const gitignorePath = join37(repoRoot, ".gitignore");
   if (!existsSync35(gitignorePath)) {
-    writeFileSync24(gitignorePath, `${REVIEWS_ENTRY}
+    writeFileSync25(gitignorePath, `${REVIEWS_ENTRY}
 `);
     console.log(`Created .gitignore with ${REVIEWS_ENTRY} entry.`);
     return;
   }
-  const content = readFileSync29(gitignorePath, "utf-8");
+  const content = readFileSync30(gitignorePath, "utf-8");
   if (content.split("\n").some(coversReviews)) return;
   const separator = content === "" || content.endsWith("\n") ? "" : "\n";
   appendFileSync(gitignorePath, `${separator}${REVIEWS_ENTRY}
@@ -13085,7 +13182,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync30 } from "fs";
+import { readFileSync as readFileSync31 } from "fs";
 
 // src/commands/review/parseFindings.ts
 var SEVERITIES = ["blocker", "major", "minor", "nit"];
@@ -13315,7 +13412,7 @@ async function postReviewToPr(synthesisPath, options2) {
     console.log("No PR found for current branch; nothing posted.");
     return;
   }
-  const markdown = readFileSync30(synthesisPath, "utf-8");
+  const markdown = readFileSync31(synthesisPath, "utf-8");
   const findings = parseFindings(markdown);
   if (findings.length === 0) {
     console.log("Synthesis contains no findings; nothing to post.");
@@ -13392,16 +13489,16 @@ async function handlePostSynthesis(synthesisPath, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync11, unlinkSync as unlinkSync11, writeFileSync as writeFileSync25 } from "fs";
+import { existsSync as existsSync36, mkdirSync as mkdirSync12, unlinkSync as unlinkSync11, writeFileSync as writeFileSync26 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path54 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync36(path54)) unlinkSync11(path54);
+  for (const path53 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync36(path53)) unlinkSync11(path53);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
-  mkdirSync11(paths.reviewDir, { recursive: true });
+  mkdirSync12(paths.reviewDir, { recursive: true });
   if (force) clearReviewFiles(paths);
-  writeFileSync25(paths.requestPath, requestBody);
+  writeFileSync26(paths.requestPath, requestBody);
 }
 
 // src/commands/review/runApplySession.ts
@@ -13744,7 +13841,7 @@ The review request is at: ${requestPath}
 }
 
 // src/commands/review/runClaudeReviewer.ts
-import { writeFileSync as writeFileSync26 } from "fs";
+import { writeFileSync as writeFileSync27 } from "fs";
 
 // src/commands/review/finaliseReviewerSpinner.ts
 var SUMMARY_MAX_LEN = 80;
@@ -14080,7 +14177,7 @@ async function runClaudeReviewer(spec) {
     }
   });
   if (result.exitCode === 0 && finalText)
-    writeFileSync26(spec.outputPath, finalText);
+    writeFileSync27(spec.outputPath, finalText);
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
 
@@ -14196,7 +14293,7 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync31 } from "fs";
+import { readFileSync as readFileSync32 } from "fs";
 
 // src/commands/review/buildSynthesisStdin.ts
 var SYNTHESIS_PROMPT = `You are consolidating two independent code reviews of the same change. The original review request is in request.md. The two reviews are in claude.md and codex.md in the current working directory.
@@ -14252,7 +14349,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary2(synthesisPath) {
-  const markdown = readFileSync31(synthesisPath, "utf-8");
+  const markdown = readFileSync32(synthesisPath, "utf-8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -14531,8 +14628,8 @@ import chalk147 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk144 from "chalk";
-async function fetchSeq(conn, path54, params) {
-  const url = `${conn.url}${path54}?${params}`;
+async function fetchSeq(conn, path53, params) {
+  const url = `${conn.url}${path53}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -15077,7 +15174,7 @@ function registerSql(program2) {
 
 // src/commands/transcript/shared.ts
 import { existsSync as existsSync39, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
-import { basename as basename6, join as join37, relative as relative2 } from "path";
+import { basename as basename6, join as join38, relative as relative2 } from "path";
 import * as readline2 from "readline";
 var DATE_PREFIX_REGEX = /^\d{4}-\d{2}-\d{2}/;
 function getDatePrefix(daysOffset = 0) {
@@ -15095,7 +15192,7 @@ function collectFiles(dir, extension) {
   if (!existsSync39(dir)) return [];
   const results = [];
   for (const entry of readdirSync6(dir)) {
-    const fullPath = join37(dir, entry);
+    const fullPath = join38(dir, entry);
     if (statSync4(fullPath).isDirectory()) {
       results.push(...collectFiles(fullPath, extension));
     } else if (entry.endsWith(extension)) {
@@ -15192,11 +15289,11 @@ async function configure() {
 import { existsSync as existsSync41 } from "fs";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/index.ts
-import { dirname as dirname19, join as join39 } from "path";
+import { dirname as dirname20, join as join40 } from "path";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/promptForDateFix.ts
 import { renameSync as renameSync3 } from "fs";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 async function resolveDate(rl, choice) {
   if (choice === "1") return getDatePrefix(0);
   if (choice === "2") return getDatePrefix(-1);
@@ -15211,7 +15308,7 @@ async function resolveDate(rl, choice) {
 }
 function renameWithPrefix(vttDir, vttFile, prefix2) {
   const newFilename = `${prefix2}.${vttFile}`;
-  renameSync3(join38(vttDir, vttFile), join38(vttDir, newFilename));
+  renameSync3(join39(vttDir, vttFile), join39(vttDir, newFilename));
   console.log(`Renamed to: ${newFilename}`);
   return newFilename;
 }
@@ -15242,15 +15339,15 @@ async function fixInvalidDatePrefixes(vttFiles) {
   for (let i = 0; i < vttFiles.length; i++) {
     const vttFile = vttFiles[i];
     if (!isValidDatePrefix(vttFile.filename)) {
-      const vttFileDir = dirname19(vttFile.absolutePath);
+      const vttFileDir = dirname20(vttFile.absolutePath);
       const newFilename = await promptForDateFix(vttFile.filename, vttFileDir);
       if (newFilename) {
-        const newRelativePath = join39(
-          dirname19(vttFile.relativePath),
+        const newRelativePath = join40(
+          dirname20(vttFile.relativePath),
           newFilename
         );
         vttFiles[i] = {
-          absolutePath: join39(vttFileDir, newFilename),
+          absolutePath: join40(vttFileDir, newFilename),
           relativePath: newRelativePath,
           filename: newFilename
         };
@@ -15263,8 +15360,8 @@ async function fixInvalidDatePrefixes(vttFiles) {
 }
 
 // src/commands/transcript/format/processVttFile/index.ts
-import { existsSync as existsSync40, mkdirSync as mkdirSync12, readFileSync as readFileSync32, writeFileSync as writeFileSync27 } from "fs";
-import { basename as basename7, dirname as dirname20, join as join40 } from "path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync13, readFileSync as readFileSync33, writeFileSync as writeFileSync28 } from "fs";
+import { basename as basename7, dirname as dirname21, join as join41 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text2) {
@@ -15474,22 +15571,22 @@ function toMdFilename(vttFilename) {
   return `${basename7(vttFilename, ".vtt").replace(/\s*Transcription\s*/g, " ").trim()}.md`;
 }
 function resolveOutputDir(relativeDir, transcriptsDir) {
-  return relativeDir === "." ? transcriptsDir : join40(transcriptsDir, relativeDir);
+  return relativeDir === "." ? transcriptsDir : join41(transcriptsDir, relativeDir);
 }
 function buildOutputPaths(vttFile, transcriptsDir) {
   const mdFile = toMdFilename(vttFile.filename);
-  const relativeDir = dirname20(vttFile.relativePath);
+  const relativeDir = dirname21(vttFile.relativePath);
   const outputDir = resolveOutputDir(relativeDir, transcriptsDir);
-  const outputPath = join40(outputDir, mdFile);
+  const outputPath = join41(outputDir, mdFile);
   return { outputDir, outputPath, mdFile, relativeDir };
 }
 function logSkipped(relativeDir, mdFile) {
-  console.log(`Skipping (already exists): ${join40(relativeDir, mdFile)}`);
+  console.log(`Skipping (already exists): ${join41(relativeDir, mdFile)}`);
   return "skipped";
 }
 function ensureDirectory(dir, label2) {
   if (!existsSync40(dir)) {
-    mkdirSync12(dir, { recursive: true });
+    mkdirSync13(dir, { recursive: true });
     console.log(`Created ${label2}: ${dir}`);
   }
 }
@@ -15511,10 +15608,10 @@ function logReduction(cueCount, messageCount) {
 }
 function readAndParseCues(inputPath) {
   console.log(`Reading: ${inputPath}`);
-  return processCues(readFileSync32(inputPath, "utf-8"));
+  return processCues(readFileSync33(inputPath, "utf-8"));
 }
 function writeFormatted(outputPath, content) {
-  writeFileSync27(outputPath, content, "utf-8");
+  writeFileSync28(outputPath, content, "utf-8");
   console.log(`Written: ${outputPath}`);
 }
 function convertVttToMarkdown(inputPath, outputPath) {
@@ -15583,17 +15680,17 @@ async function format() {
 
 // src/commands/transcript/summarise/index.ts
 import { existsSync as existsSync43 } from "fs";
-import { basename as basename8, dirname as dirname22, join as join42, relative as relative3 } from "path";
+import { basename as basename8, dirname as dirname23, join as join43, relative as relative3 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
 import {
   existsSync as existsSync42,
-  mkdirSync as mkdirSync13,
-  readFileSync as readFileSync33,
+  mkdirSync as mkdirSync14,
+  readFileSync as readFileSync34,
   renameSync as renameSync4,
-  rmSync
+  rmSync as rmSync2
 } from "fs";
-import { dirname as dirname21, join as join41 } from "path";
+import { dirname as dirname22, join as join42 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
 import chalk154 from "chalk";
@@ -15622,7 +15719,7 @@ function validateStagedContent(filename, content) {
 }
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
-var STAGING_DIR = join41(process.cwd(), ".assist", "transcript");
+var STAGING_DIR = join42(process.cwd(), ".assist", "transcript");
 function processStagedFile() {
   if (!existsSync42(STAGING_DIR)) {
     return false;
@@ -15633,7 +15730,7 @@ function processStagedFile() {
   }
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
   const stagedFile = stagedFiles[0];
-  const content = readFileSync33(stagedFile.absolutePath, "utf-8");
+  const content = readFileSync34(stagedFile.absolutePath, "utf-8");
   validateStagedContent(stagedFile.filename, content);
   const stagedBaseName = getTranscriptBaseName(stagedFile.filename);
   const transcriptFiles = findMdFilesRecursive(transcriptsDir);
@@ -15646,23 +15743,23 @@ function processStagedFile() {
     );
     process.exit(1);
   }
-  const destPath = join41(summaryDir, matchingTranscript.relativePath);
-  const destDir = dirname21(destPath);
+  const destPath = join42(summaryDir, matchingTranscript.relativePath);
+  const destDir = dirname22(destPath);
   if (!existsSync42(destDir)) {
-    mkdirSync13(destDir, { recursive: true });
+    mkdirSync14(destDir, { recursive: true });
   }
   renameSync4(stagedFile.absolutePath, destPath);
   const remaining = findMdFilesRecursive(STAGING_DIR);
   if (remaining.length === 0) {
-    rmSync(STAGING_DIR, { recursive: true });
+    rmSync2(STAGING_DIR, { recursive: true });
   }
   return true;
 }
 
 // src/commands/transcript/summarise/index.ts
 function buildRelativeKey(relativePath, baseName) {
-  const relDir = dirname22(relativePath);
-  return relDir === "." ? baseName : join42(relDir, baseName);
+  const relDir = dirname23(relativePath);
+  return relDir === "." ? baseName : join43(relDir, baseName);
 }
 function buildSummaryIndex(summaryDir) {
   const summaryFiles = findMdFilesRecursive(summaryDir);
@@ -15696,8 +15793,8 @@ function summarise3() {
   }
   const next3 = missing[0];
   const outputFilename = `${getTranscriptBaseName(next3.filename)}.md`;
-  const outputPath = join42(STAGING_DIR, outputFilename);
-  const summaryFileDir = join42(summaryDir, dirname22(next3.relativePath));
+  const outputPath = join43(STAGING_DIR, outputFilename);
+  const summaryFileDir = join43(summaryDir, dirname23(next3.relativePath));
   const relativeTranscriptPath = encodeURI(
     relative3(summaryFileDir, next3.absolutePath).replace(/\\/g, "/")
   );
@@ -15746,50 +15843,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 
 // src/commands/voice/shared.ts
 import { homedir as homedir9 } from "os";
-import { dirname as dirname23, join as join43 } from "path";
+import { dirname as dirname24, join as join44 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
-var __dirname6 = dirname23(fileURLToPath6(import.meta.url));
-var VOICE_DIR = join43(homedir9(), ".assist", "voice");
+var __dirname6 = dirname24(fileURLToPath6(import.meta.url));
+var VOICE_DIR = join44(homedir9(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join43(VOICE_DIR, "voice.pid"),
-  log: join43(VOICE_DIR, "voice.log"),
-  venv: join43(VOICE_DIR, ".venv"),
-  lock: join43(VOICE_DIR, "voice.lock")
+  pid: join44(VOICE_DIR, "voice.pid"),
+  log: join44(VOICE_DIR, "voice.log"),
+  venv: join44(VOICE_DIR, ".venv"),
+  lock: join44(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join43(__dirname6, "commands", "voice", "python");
+  return join44(__dirname6, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join43(voicePaths.venv, "Scripts", "python.exe") : join43(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join44(voicePaths.venv, "Scripts", "python.exe") : join44(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join43(getLockDir(), "voice.lock");
+  return join44(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join44(getPythonDir(), "list_devices.py");
+  const script = join45(getPythonDir(), "list_devices.py");
   spawnSync4(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync44, readFileSync as readFileSync34 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync35 } from "fs";
 function logs(options2) {
   if (!existsSync44(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count6 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync34(voicePaths.log, "utf-8").trim();
+  const content = readFileSync35(voicePaths.log, "utf-8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -15811,13 +15908,13 @@ function logs(options2) {
 
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { mkdirSync as mkdirSync15 } from "fs";
-import { join as join46 } from "path";
+import { mkdirSync as mkdirSync16 } from "fs";
+import { join as join47 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync44 } from "child_process";
-import { existsSync as existsSync45, mkdirSync as mkdirSync14, readFileSync as readFileSync35, writeFileSync as writeFileSync28 } from "fs";
-import { join as join45 } from "path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync15, readFileSync as readFileSync36, writeFileSync as writeFileSync29 } from "fs";
+import { join as join46 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -15830,7 +15927,7 @@ function checkLockFile() {
   const lockFile = getLockFile();
   if (!existsSync45(lockFile)) return;
   try {
-    const lock = JSON.parse(readFileSync35(lockFile, "utf-8"));
+    const lock = JSON.parse(readFileSync36(lockFile, "utf-8"));
     if (lock.pid && isProcessAlive2(lock.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock.pid}, env: ${lock.env}). Stop it first with: assist voice stop`
@@ -15854,8 +15951,8 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync14(join45(lockFile, ".."), { recursive: true });
-  writeFileSync28(
+  mkdirSync15(join46(lockFile, ".."), { recursive: true });
+  writeFileSync29(
     lockFile,
     JSON.stringify({
       pid,
@@ -15867,10 +15964,10 @@ function writeLockFile(pid) {
 
 // src/commands/voice/setup.ts
 function setup() {
-  mkdirSync15(voicePaths.dir, { recursive: true });
+  mkdirSync16(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join46(getPythonDir(), "setup_models.py");
+  const script = join47(getPythonDir(), "setup_models.py");
   const result = spawnSync5(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -15883,8 +15980,8 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn7 } from "child_process";
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync29 } from "fs";
-import { join as join47 } from "path";
+import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync30 } from "fs";
+import { join as join48 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -15912,17 +16009,17 @@ function spawnBackground(python, script, env) {
     console.error("Failed to start voice daemon");
     process.exit(1);
   }
-  writeFileSync29(voicePaths.pid, String(pid));
+  writeFileSync30(voicePaths.pid, String(pid));
   writeLockFile(pid);
   console.log(`Voice daemon started (PID ${pid})`);
 }
 function start2(options2) {
-  mkdirSync16(voicePaths.dir, { recursive: true });
+  mkdirSync17(voicePaths.dir, { recursive: true });
   checkLockFile();
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join47(getPythonDir(), "voice_daemon.py");
+  const script = join48(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -15932,7 +16029,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync46, readFileSync as readFileSync36 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync37 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -15943,7 +16040,7 @@ function isProcessAlive3(pid) {
 }
 function readRecentLogs(count6) {
   if (!existsSync46(voicePaths.log)) return [];
-  const lines = readFileSync36(voicePaths.log, "utf-8").trim().split("\n");
+  const lines = readFileSync37(voicePaths.log, "utf-8").trim().split("\n");
   return lines.slice(-count6);
 }
 function status() {
@@ -15951,7 +16048,7 @@ function status() {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync36(voicePaths.pid, "utf-8").trim(), 10);
+  const pid = Number.parseInt(readFileSync37(voicePaths.pid, "utf-8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -15970,13 +16067,13 @@ function status() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync47, readFileSync as readFileSync37, unlinkSync as unlinkSync14 } from "fs";
+import { existsSync as existsSync47, readFileSync as readFileSync38, unlinkSync as unlinkSync14 } from "fs";
 function stop2() {
   if (!existsSync47(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync37(voicePaths.pid, "utf-8").trim(), 10);
+  const pid = Number.parseInt(readFileSync38(voicePaths.pid, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -16211,8 +16308,8 @@ async function auth() {
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { readdirSync as readdirSync7, readFileSync as readFileSync38, statSync as statSync5 } from "fs";
-import { join as join48 } from "path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync39, statSync as statSync5 } from "fs";
+import { join as join49 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
@@ -16221,9 +16318,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path54 = join48(roamDir, name);
+    const path53 = join49(roamDir, name);
     try {
-      return { path: path54, mtimeMs: statSync5(path54).mtimeMs };
+      return { path: path53, mtimeMs: statSync5(path53).mtimeMs };
     } catch {
       return void 0;
     }
@@ -16233,11 +16330,11 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join48(appData, "Roam"));
+  const portFile = findPortFile(join49(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync38(portFile, "utf-8").trim();
+    port = readFileSync39(portFile, "utf-8").trim();
   } catch {
     return;
   }
@@ -16380,13 +16477,13 @@ function runPreCommands(pre, cwd) {
 // src/commands/run/spawnRunCommand.ts
 import { execFileSync as execFileSync8, spawn as spawn8 } from "child_process";
 import { existsSync as existsSync48 } from "fs";
-import { dirname as dirname24, join as join49, resolve as resolve11 } from "path";
+import { dirname as dirname25, join as join50, resolve as resolve11 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync8("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
-    const gitRoot = resolve11(dirname24(gitPath), "..");
-    const gitBash = join49(gitRoot, "bin", "bash.exe");
+    const gitRoot = resolve11(dirname25(gitPath), "..");
+    const gitBash = join50(gitRoot, "bin", "bash.exe");
     if (existsSync48(gitBash)) return gitBash;
   } catch {
   }
@@ -16472,8 +16569,8 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync30 } from "fs";
-import { join as join50 } from "path";
+import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync31 } from "fs";
+import { join as join51 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -16534,16 +16631,16 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join50(".claude", "commands");
-  mkdirSync17(dir, { recursive: true });
+  const dir = join51(".claude", "commands");
+  mkdirSync18(dir, { recursive: true });
   const content = `---
 description: Run ${name}
 ---
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join50(dir, `${name}.md`);
-  writeFileSync30(filePath, content);
+  const filePath = join51(dir, `${name}.md`);
+  writeFileSync31(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add3() {
@@ -16566,11 +16663,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path54 = process.argv[idx + 1];
+  const path53 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path54, prefix: prefix2 };
+  return { path: path53, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -16599,7 +16696,7 @@ function link2() {
 
 // src/commands/run/remove.ts
 import { existsSync as existsSync49, unlinkSync as unlinkSync15 } from "fs";
-import { join as join51 } from "path";
+import { join as join52 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -16614,7 +16711,7 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join51(".claude", "commands", `${name}.md`);
+  const filePath = join52(".claude", "commands", `${name}.md`);
   if (existsSync49(filePath)) {
     unlinkSync15(filePath);
     console.log(`Deleted command file: ${filePath}`);
@@ -16654,9 +16751,9 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync47 } from "child_process";
-import { existsSync as existsSync50, mkdirSync as mkdirSync18, unlinkSync as unlinkSync16, writeFileSync as writeFileSync31 } from "fs";
+import { existsSync as existsSync50, mkdirSync as mkdirSync19, unlinkSync as unlinkSync16, writeFileSync as writeFileSync32 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join52, resolve as resolve13 } from "path";
+import { join as join53, resolve as resolve13 } from "path";
 import chalk156 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -16787,14 +16884,14 @@ Write-Output $OutputPath
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
   if (!existsSync50(outputDir)) {
-    mkdirSync18(outputDir, { recursive: true });
+    mkdirSync19(outputDir, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve13(outputDir, `${processName}-${timestamp}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join52(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
-  writeFileSync31(scriptPath, captureWindowPs1, "utf-8");
+  const scriptPath = join53(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
+  writeFileSync32(scriptPath, captureWindowPs1, "utf-8");
   try {
     execSync47(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
@@ -16870,7 +16967,7 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/reportStolenSocket.ts
-import { readFileSync as readFileSync39 } from "fs";
+import { readFileSync as readFileSync40 } from "fs";
 function reportStolenSocket(socketPid) {
   if (!socketPid) return;
   const filePid = readPidFile();
@@ -16882,7 +16979,7 @@ function reportStolenSocket(socketPid) {
 function readPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync39(daemonPaths.pid, "utf-8").trim(),
+      readFileSync40(daemonPaths.pid, "utf-8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -16969,7 +17066,7 @@ async function restartDaemon() {
 }
 
 // src/commands/sessions/daemon/runDaemon.ts
-import { mkdirSync as mkdirSync19 } from "fs";
+import { mkdirSync as mkdirSync21 } from "fs";
 
 // src/commands/sessions/daemon/createAutoExit.ts
 var DEFAULT_GRACE_MS = 6e4;
@@ -17129,27 +17226,20 @@ function broadcast(clients, msg) {
   }
 }
 
-// src/commands/sessions/daemon/repoPrefix.ts
-import * as path47 from "path";
-function repoPrefix(cwd) {
-  if (!cwd) return "";
-  return `${path47.basename(cwd)}/`;
-}
-
 // src/commands/sessions/daemon/spawnPty.ts
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
 import { chmodSync, existsSync as existsSync51, statSync as statSync6 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path48 from "path";
+import path47 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path48.join(path48.dirname(require4.resolve("node-pty")), "..");
-  const helper = path48.join(
+  const ptyRoot = path47.join(path47.dirname(require4.resolve("node-pty")), "..");
+  const helper = path47.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -17161,7 +17251,7 @@ function ensureSpawnHelperExecutable() {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
-function spawnPty(args, cwd) {
+function spawnPty(args, cwd, sessionId) {
   ensureSpawnHelperExecutable();
   const shell = process.platform === "win32" ? "cmd.exe" : process.env.SHELL ?? "bash";
   const shellArgs = process.platform === "win32" ? ["/c", ...args] : ["-c", `exec ${args.map(shellEscape).join(" ")}`];
@@ -17170,7 +17260,13 @@ function spawnPty(args, cwd) {
     cols: 120,
     rows: 30,
     cwd: cwd ?? process.cwd(),
-    env: { ...process.env }
+    env: {
+      ...process.env,
+      ...sessionId && {
+        ASSIST_SESSION_ID: sessionId,
+        ASSIST_ACTIVITY_ID: sessionId
+      }
+    }
   });
 }
 function shellEscape(s) {
@@ -17181,11 +17277,11 @@ function shellEscape(s) {
 function createAssistSession(id, assistArgs, cwd) {
   return {
     id,
-    name: `${repoPrefix(cwd)}assist ${assistArgs.join(" ")}`,
+    name: `assist ${assistArgs.join(" ")}`,
     commandType: "assist",
     status: "running",
     startedAt: Date.now(),
-    pty: spawnPty(["assist", ...assistArgs], cwd),
+    pty: spawnPty(["assist", ...assistArgs], cwd, id),
     scrollback: "",
     idleTimer: null,
     lastResizeAt: 0,
@@ -17213,7 +17309,7 @@ function spawnRun(opts) {
 function createSession(id, prompt, cwd) {
   return {
     id,
-    name: `${repoPrefix(cwd)}${prompt?.slice(0, 40) || `Session ${id}`}`,
+    name: prompt?.slice(0, 40) || `Session ${id}`,
     commandType: "claude",
     status: "running",
     startedAt: Date.now(),
@@ -17227,7 +17323,7 @@ function createSession(id, prompt, cwd) {
 function createRunSession(id, runName, runArgs, cwd) {
   return {
     id,
-    name: `${repoPrefix(cwd)}run: ${runName}`,
+    name: `run: ${runName}`,
     commandType: "run",
     status: "running",
     startedAt: Date.now(),
@@ -17341,7 +17437,7 @@ function restoreSession(id, persisted) {
 function resumeSession(id, sessionId, cwd, name) {
   return {
     id,
-    name: `${repoPrefix(cwd)}${name ? `${name.slice(0, 36)} (R)` : `Resume ${sessionId.slice(0, 8)}`}`,
+    name: name ? `${name.slice(0, 36)} (R)` : `Resume ${sessionId.slice(0, 8)}`,
     commandType: "claude",
     status: "running",
     startedAt: Date.now(),
@@ -17413,7 +17509,7 @@ function respawnThunk(session) {
   if (session.commandType === "run" && runName)
     return () => spawnRun({ name: runName, args: runArgs, cwd });
   if (session.commandType === "assist" && assistArgs)
-    return () => spawnPty(["assist", ...assistArgs], cwd);
+    return () => spawnPty(["assist", ...assistArgs], cwd, session.id);
   return null;
 }
 
@@ -17434,8 +17530,10 @@ function toSessionInfo({
   startedAt,
   runName,
   runArgs,
+  assistArgs,
   cwd,
-  restored
+  restored,
+  activity: activity2
 }) {
   return {
     id,
@@ -17445,14 +17543,45 @@ function toSessionInfo({
     startedAt,
     runName,
     runArgs,
+    assistArgs,
     cwd,
-    restored
+    restored,
+    activity: activity2
+  };
+}
+
+// src/commands/sessions/daemon/watchActivity.ts
+import { existsSync as existsSync52, mkdirSync as mkdirSync20, watch } from "fs";
+import { dirname as dirname27 } from "path";
+var DEBOUNCE_MS = 50;
+function watchActivity(session, notify2) {
+  if (session.commandType !== "assist" || !session.cwd) return;
+  const path53 = activityPath(session.cwd, session.id);
+  const dir = dirname27(path53);
+  try {
+    mkdirSync20(dir, { recursive: true });
+  } catch {
+    return;
+  }
+  let timer = null;
+  const read = () => {
+    timer = null;
+    const activity2 = readActivity(path53);
+    if (!activity2) return;
+    session.activity = activity2;
+    notify2();
   };
+  session.activityWatcher = watch(dir, (_event, filename) => {
+    if (filename && !path53.endsWith(filename)) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(read, DEBOUNCE_MS);
+  });
+  if (existsSync52(path53)) read();
 }
 
 // src/commands/sessions/daemon/discoverClaudeSessionId.ts
 import * as fs26 from "fs";
-import * as path49 from "path";
+import * as path48 from "path";
 var POLL_MS = 3e3;
 async function discoverClaudeSessionId(options2) {
   while (options2.isActive()) {
@@ -17468,7 +17597,7 @@ async function findNewSessionId(options2) {
     if (!await isCreatedSince(filePath, options2.sinceMs)) continue;
     const meta = await parseSessionFile(filePath);
     if (!meta?.cwd || options2.isClaimed(meta.sessionId)) continue;
-    if (path49.resolve(meta.cwd) === path49.resolve(options2.cwd))
+    if (path48.resolve(meta.cwd) === path48.resolve(options2.cwd))
       return meta.sessionId;
   }
   return null;
@@ -17520,6 +17649,8 @@ function dismissSession(sessions, id) {
   if (!s) return false;
   if (s.status !== "done") s.pty?.kill();
   clearIdle(s);
+  s.activityWatcher?.close();
+  if (s.cwd) removeActivity(s.cwd, s.id);
   sessions.delete(id);
   return true;
 }
@@ -17558,6 +17689,7 @@ var SessionManager = class {
   add(session) {
     this.wire(session);
     watchForClaudeSessionId(session, this.sessions, this.notify);
+    watchActivity(session, this.notify);
     return session.id;
   }
   spawn(prompt, cwd) {
@@ -17722,10 +17854,10 @@ function handleConnection(socket, manager) {
 }
 
 // src/commands/sessions/daemon/onListening.ts
-import { unlinkSync as unlinkSync17, writeFileSync as writeFileSync32 } from "fs";
+import { unlinkSync as unlinkSync17, writeFileSync as writeFileSync33 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync40 } from "fs";
+import { readFileSync as readFileSync41 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -17736,7 +17868,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync40(daemonPaths.pid, "utf-8").trim() === String(process.pid);
+    return readFileSync41(daemonPaths.pid, "utf-8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -17744,7 +17876,7 @@ function ownsPidFile() {
 
 // src/commands/sessions/daemon/onListening.ts
 function onListening(manager, checkAutoExit) {
-  writeFileSync32(daemonPaths.pid, String(process.pid));
+  writeFileSync33(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
     manager.shutdown();
@@ -17805,7 +17937,7 @@ async function recoverFromAddrInUse(server, manager, checkAutoExit) {
 
 // src/commands/sessions/daemon/runDaemon.ts
 async function runDaemon() {
-  mkdirSync19(daemonPaths.dir, { recursive: true });
+  mkdirSync21(daemonPaths.dir, { recursive: true });
   daemonLog(
     `starting (reason: ${process.env.ASSIST_DAEMON_SPAWN_REASON ?? "manual"})`
   );
@@ -18105,16 +18237,16 @@ async function statusLine() {
 // src/commands/sync.ts
 import * as fs32 from "fs";
 import * as os2 from "os";
-import * as path52 from "path";
+import * as path51 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
 import * as fs30 from "fs";
-import * as path50 from "path";
+import * as path49 from "path";
 import chalk160 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path50.join(claudeDir, "CLAUDE.md");
-  const target = path50.join(targetBase, "CLAUDE.md");
+  const source = path49.join(claudeDir, "CLAUDE.md");
+  const target = path49.join(targetBase, "CLAUDE.md");
   const sourceContent = fs30.readFileSync(source, "utf-8");
   if (fs30.existsSync(target)) {
     const targetContent = fs30.readFileSync(target, "utf-8");
@@ -18140,11 +18272,11 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 
 // src/commands/sync/syncSettings.ts
 import * as fs31 from "fs";
-import * as path51 from "path";
+import * as path50 from "path";
 import chalk161 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path51.join(claudeDir, "settings.json");
-  const target = path51.join(targetBase, "settings.json");
+  const source = path50.join(claudeDir, "settings.json");
+  const target = path50.join(targetBase, "settings.json");
   const sourceContent = fs31.readFileSync(source, "utf-8");
   const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
   if (fs31.existsSync(target)) {
@@ -18180,23 +18312,23 @@ async function syncSettings(claudeDir, targetBase, options2) {
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath7(import.meta.url);
-var __dirname7 = path52.dirname(__filename4);
+var __dirname7 = path51.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path52.join(__dirname7, "..", "claude");
-  const targetBase = path52.join(os2.homedir(), ".claude");
+  const claudeDir = path51.join(__dirname7, "..", "claude");
+  const targetBase = path51.join(os2.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   await syncClaudeMd(claudeDir, targetBase, { yes });
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path52.join(claudeDir, "commands");
-  const targetDir = path52.join(targetBase, "commands");
+  const sourceDir = path51.join(claudeDir, "commands");
+  const targetDir = path51.join(targetBase, "commands");
   fs32.mkdirSync(targetDir, { recursive: true });
   const files = fs32.readdirSync(sourceDir);
   for (const file of files) {
-    fs32.copyFileSync(path52.join(sourceDir, file), path52.join(targetDir, file));
+    fs32.copyFileSync(path51.join(sourceDir, file), path51.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -18204,15 +18336,15 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync48 } from "child_process";
-import * as path53 from "path";
+import * as path52 from "path";
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path53.resolve(dir);
-    if (resolved.split(path53.sep).includes("node_modules")) {
+    const resolved = path52.resolve(dir);
+    if (resolved.split(path52.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync48("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path53.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path52.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }