@staff0rd/assist 0.170.2 → 0.171.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.170.2",
+  version: "0.171.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -38,6 +38,7 @@ var package_default = {
     url: "https://github.com/staff0rd/assist"
   },
   dependencies: {
+    "better-sqlite3": "^12.8.0",
     chalk: "^5.6.2",
     commander: "^14.0.2",
     diff: "^8.0.2",
@@ -59,6 +60,7 @@ var package_default = {
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^24.10.1",
     "@types/node-notifier": "^8.0.5",
     "@types/react": "^19.2.14",
@@ -97,14 +99,199 @@ async function exitOnCancel(promise) {
 }
 
 // src/commands/backlog/acquireLock.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
 
 // src/commands/backlog/shared.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
+import { join as join3 } from "path";
 import chalk from "chalk";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+
+// src/commands/backlog/deleteItemRelations.ts
+function deleteItemRelations(db, itemId) {
+  db.prepare("DELETE FROM plan_tasks WHERE item_id = ?").run(itemId);
+  db.prepare("DELETE FROM plan_phases WHERE item_id = ?").run(itemId);
+  db.prepare("DELETE FROM comments WHERE item_id = ?").run(itemId);
+  db.prepare("DELETE FROM links WHERE item_id = ?").run(itemId);
+}
+
+// src/commands/backlog/deleteItem.ts
+function deleteItem(db, id) {
+  const del2 = db.transaction(() => {
+    deleteItemRelations(db, id);
+    const result = db.prepare("DELETE FROM items WHERE id = ?").run(id);
+    return result.changes > 0;
+  });
+  return del2();
+}
+
+// src/commands/backlog/exportToJsonl.ts
+import { statSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// src/commands/backlog/loadPlan.ts
+function toPhase(db, itemId, p) {
+  const tasks = db.prepare(
+    "SELECT task, verify FROM plan_tasks WHERE item_id = ? AND phase_idx = ? ORDER BY idx"
+  ).all(itemId, p.idx);
+  const phase = {
+    name: p.name,
+    tasks: tasks.map((t) => ({
+      task: t.task,
+      ...t.verify != null ? { verify: t.verify } : {}
+    }))
+  };
+  if (p.manual_checks) {
+    phase.manualChecks = JSON.parse(p.manual_checks);
+  }
+  return phase;
+}
+function loadPlan(db, itemId) {
+  const phases = db.prepare(
+    "SELECT idx, name, manual_checks FROM plan_phases WHERE item_id = ? ORDER BY idx"
+  ).all(itemId);
+  if (phases.length === 0) return void 0;
+  return phases.map((p) => toPhase(db, itemId, p));
+}
+
+// src/commands/backlog/loadAllItems.ts
+function loadComments(db, itemId) {
+  return db.prepare(
+    "SELECT text, phase, timestamp, type FROM comments WHERE item_id = ? ORDER BY idx"
+  ).all(itemId);
+}
+function loadLinks(db, itemId) {
+  return db.prepare("SELECT type, target_id as targetId FROM links WHERE item_id = ?").all(itemId);
+}
+function rowToItem(db, row) {
+  const comments2 = loadComments(db, row.id);
+  const links = loadLinks(db, row.id);
+  const plan2 = loadPlan(db, row.id);
+  const item = {
+    id: row.id,
+    type: row.type,
+    name: row.name,
+    acceptanceCriteria: JSON.parse(row.acceptance_criteria),
+    status: row.status
+  };
+  if (row.description != null) item.description = row.description;
+  if (row.current_phase != null) item.currentPhase = row.current_phase;
+  if (comments2.length > 0) item.comments = comments2;
+  if (links && links.length > 0) item.links = links;
+  if (plan2) item.plan = plan2;
+  return item;
+}
+function loadAllItems(db) {
+  const rows = db.prepare("SELECT * FROM items ORDER BY id").all();
+  return rows.map((row) => rowToItem(db, row));
+}
+
+// src/commands/backlog/exportToJsonl.ts
+function getJsonlPath(dir) {
+  return join(dir, ".assist", "backlog.jsonl");
+}
+function exportToJsonl(db, dir) {
+  const jsonlPath = getJsonlPath(dir);
+  const items = loadAllItems(db);
+  const lines = items.map((item) => JSON.stringify(item));
+  writeFileSync(jsonlPath, lines.length > 0 ? `${lines.join("\n")}
+` : "");
+  const mtimeMs = statSync(jsonlPath).mtimeMs;
+  db.prepare(
+    "INSERT INTO metadata (key, value) VALUES ('jsonl_last_import_ms', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(String(mtimeMs));
+}
+
+// src/commands/backlog/importFromJsonlIfNeeded.ts
+import { readFileSync, statSync as statSync2 } from "fs";
+
+// src/commands/backlog/insertItemRelations.ts
+function insertComments(db, item) {
+  if (!item.comments) return;
+  const stmt = db.prepare(
+    "INSERT INTO comments (item_id, idx, text, phase, timestamp, type) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  for (let i = 0; i < item.comments.length; i++) {
+    const c = item.comments[i];
+    stmt.run(item.id, i, c.text, c.phase ?? null, c.timestamp, c.type);
+  }
+}
+function insertLinks(db, item) {
+  if (!item.links) return;
+  const stmt = db.prepare(
+    "INSERT INTO links (item_id, type, target_id) VALUES (?, ?, ?)"
+  );
+  for (const l of item.links) {
+    stmt.run(item.id, l.type, l.targetId);
+  }
+}
+function insertPlan(db, item) {
+  if (!item.plan) return;
+  const phaseStmt = db.prepare(
+    "INSERT INTO plan_phases (item_id, idx, name, manual_checks) VALUES (?, ?, ?, ?)"
+  );
+  const taskStmt = db.prepare(
+    "INSERT INTO plan_tasks (item_id, phase_idx, idx, task, verify) VALUES (?, ?, ?, ?, ?)"
+  );
+  for (let pi = 0; pi < item.plan.length; pi++) {
+    const phase = item.plan[pi];
+    phaseStmt.run(
+      item.id,
+      pi,
+      phase.name,
+      phase.manualChecks ? JSON.stringify(phase.manualChecks) : null
+    );
+    for (let ti = 0; ti < phase.tasks.length; ti++) {
+      const task = phase.tasks[ti];
+      taskStmt.run(item.id, pi, ti, task.task, task.verify ?? null);
+    }
+  }
+}
+function insertItemRelations(db, item) {
+  insertComments(db, item);
+  insertLinks(db, item);
+  insertPlan(db, item);
+}
+
+// src/commands/backlog/saveAllItems.ts
+function upsertItem(db, item) {
+  db.prepare(
+    `INSERT INTO items (id, type, name, description, acceptance_criteria, status, current_phase)
+		 VALUES (?, ?, ?, ?, ?, ?, ?)
+		 ON CONFLICT(id) DO UPDATE SET
+			type = excluded.type,
+			name = excluded.name,
+			description = excluded.description,
+			acceptance_criteria = excluded.acceptance_criteria,
+			status = excluded.status,
+			current_phase = excluded.current_phase`
+  ).run(
+    item.id,
+    item.type,
+    item.name,
+    item.description ?? null,
+    JSON.stringify(item.acceptanceCriteria),
+    item.status,
+    item.currentPhase ?? null
+  );
+  deleteItemRelations(db, item.id);
+  insertItemRelations(db, item);
+}
+function saveAllItems(db, items) {
+  const save = db.transaction(() => {
+    const existingIds = db.prepare("SELECT id FROM items").all();
+    const newIds = new Set(items.map((i) => i.id));
+    for (const { id } of existingIds) {
+      if (!newIds.has(id)) {
+        deleteItemRelations(db, id);
+        db.prepare("DELETE FROM items WHERE id = ?").run(id);
+      }
+    }
+    for (const item of items) {
+      upsertItem(db, item);
+    }
+  });
+  save();
+}
 
 // src/commands/backlog/types.ts
 import { z } from "zod";
@@ -145,6 +332,143 @@ var backlogItemSchema = z.strictObject({
 });
 var backlogFileSchema = z.array(backlogItemSchema);
 
+// src/commands/backlog/importFromJsonlIfNeeded.ts
+function getLastImportMs(db) {
+  const row = db.prepare("SELECT value FROM metadata WHERE key = 'jsonl_last_import_ms'").get();
+  return row ? Number(row.value) : 0;
+}
+function setLastImportMs(db, ms) {
+  db.prepare(
+    "INSERT INTO metadata (key, value) VALUES ('jsonl_last_import_ms', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(String(ms));
+}
+function importFromJsonlIfNeeded(db, dir) {
+  const jsonlPath = getJsonlPath(dir);
+  let stat;
+  try {
+    stat = statSync2(jsonlPath);
+  } catch {
+    return;
+  }
+  const fileMtimeMs = stat.mtimeMs;
+  const lastImportMs = getLastImportMs(db);
+  if (fileMtimeMs <= lastImportMs) return;
+  const content = readFileSync(jsonlPath, "utf-8").trim();
+  if (content.length === 0) {
+    setLastImportMs(db, fileMtimeMs);
+    return;
+  }
+  const items = content.split("\n").map((line) => {
+    const parsed = JSON.parse(line);
+    return backlogItemSchema.parse(parsed);
+  });
+  saveAllItems(db, items);
+  setLastImportMs(db, fileMtimeMs);
+}
+
+// src/commands/backlog/migrateYamlIfNeeded.ts
+import { existsSync, readFileSync as readFileSync2, renameSync } from "fs";
+import { parse as parseYaml } from "yaml";
+function migrateYamlIfNeeded(db, yamlPath) {
+  if (!existsSync(yamlPath)) return false;
+  const existing = db.prepare("SELECT COUNT(*) as count FROM items").get();
+  if (existing.count > 0) return false;
+  const content = readFileSync2(yamlPath, "utf-8");
+  const raw = parseYaml(content) || [];
+  const items = backlogFileSchema.parse(raw);
+  if (items.length > 0) {
+    saveAllItems(db, items);
+    renameSync(yamlPath, `${yamlPath}.bak`);
+    return true;
+  }
+  return false;
+}
+
+// src/commands/backlog/openDb.ts
+import { mkdirSync } from "fs";
+import { join as join2 } from "path";
+import Database from "better-sqlite3";
+var _db;
+function getDbPath(dir) {
+  return join2(dir, ".assist", "backlog.db");
+}
+function initSchema(db) {
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS items (
+			id INTEGER PRIMARY KEY,
+			type TEXT NOT NULL DEFAULT 'story',
+			name TEXT NOT NULL,
+			description TEXT,
+			acceptance_criteria TEXT NOT NULL DEFAULT '[]',
+			status TEXT NOT NULL DEFAULT 'todo',
+			current_phase INTEGER
+		);
+
+		CREATE TABLE IF NOT EXISTS comments (
+			item_id INTEGER NOT NULL REFERENCES items(id) ON DELETE CASCADE,
+			idx INTEGER NOT NULL,
+			text TEXT NOT NULL,
+			phase INTEGER,
+			timestamp TEXT NOT NULL,
+			type TEXT NOT NULL DEFAULT 'comment',
+			PRIMARY KEY (item_id, idx)
+		);
+
+		CREATE TABLE IF NOT EXISTS links (
+			item_id INTEGER NOT NULL REFERENCES items(id) ON DELETE CASCADE,
+			type TEXT NOT NULL,
+			target_id INTEGER NOT NULL,
+			PRIMARY KEY (item_id, type, target_id)
+		);
+
+		CREATE TABLE IF NOT EXISTS plan_phases (
+			item_id INTEGER NOT NULL REFERENCES items(id) ON DELETE CASCADE,
+			idx INTEGER NOT NULL,
+			name TEXT NOT NULL,
+			manual_checks TEXT,
+			PRIMARY KEY (item_id, idx)
+		);
+
+		CREATE TABLE IF NOT EXISTS plan_tasks (
+			item_id INTEGER NOT NULL REFERENCES items(id) ON DELETE CASCADE,
+			phase_idx INTEGER NOT NULL,
+			idx INTEGER NOT NULL,
+			task TEXT NOT NULL,
+			verify TEXT,
+			PRIMARY KEY (item_id, phase_idx, idx),
+			FOREIGN KEY (item_id, phase_idx) REFERENCES plan_phases(item_id, idx) ON DELETE CASCADE
+		);
+
+		CREATE TABLE IF NOT EXISTS metadata (
+			key TEXT PRIMARY KEY,
+			value TEXT NOT NULL
+		);
+	`);
+}
+function openDb(dir) {
+  if (_db) return _db;
+  const dbPath = getDbPath(dir);
+  mkdirSync(join2(dir, ".assist"), { recursive: true });
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  initSchema(db);
+  _db = db;
+  return db;
+}
+
+// src/commands/backlog/updateCurrentPhase.ts
+function updateCurrentPhase(db, id, phase) {
+  const result = db.prepare("UPDATE items SET current_phase = ? WHERE id = ?").run(phase, id);
+  return result.changes > 0;
+}
+
+// src/commands/backlog/updateStatus.ts
+function updateStatus(db, id, status2) {
+  const result = db.prepare("UPDATE items SET status = ? WHERE id = ?").run(status2, id);
+  return result.changes > 0;
+}
+
 // src/commands/backlog/shared.ts
 var _backlogDir;
 function setBacklogDir(dir) {
@@ -154,33 +478,29 @@ function getBacklogDir() {
   return _backlogDir ?? process.cwd();
 }
 function getBacklogPath() {
-  return join(getBacklogDir(), "assist.backlog.yml");
+  return join3(getBacklogDir(), "assist.backlog.yml");
+}
+function getDb() {
+  const dir = getBacklogDir();
+  const db = openDb(dir);
+  const migrated = migrateYamlIfNeeded(db, getBacklogPath());
+  if (migrated) exportToJsonl(db, dir);
+  return db;
 }
 function loadBacklog() {
-  const backlogPath = getBacklogPath();
-  if (!existsSync(backlogPath)) {
-    return [];
-  }
-  const content = readFileSync(backlogPath, "utf-8");
-  const raw = parseYaml(content) || [];
-  return backlogFileSchema.parse(raw);
+  const db = getDb();
+  importFromJsonlIfNeeded(db, getBacklogDir());
+  return loadAllItems(db);
 }
 function saveBacklog(items) {
-  const backlogPath = getBacklogPath();
-  writeFileSync(backlogPath, stringifyYaml(items, { lineWidth: 0 }));
+  const db = getDb();
+  saveAllItems(db, items);
+  exportToJsonl(db, getBacklogDir());
 }
 function findItem(items, id) {
   return items.find((item) => item.id === id);
 }
 function loadAndFindItem(id) {
-  if (!existsSync(getBacklogPath())) {
-    console.log(
-      chalk.yellow(
-        "No backlog found. Run 'assist backlog init' to create one."
-      )
-    );
-    return void 0;
-  }
   const items = loadBacklog();
   const item = findItem(items, Number.parseInt(id, 10));
   if (!item) {
@@ -192,20 +512,24 @@ function loadAndFindItem(id) {
 function setStatus(id, status2) {
   const result = loadAndFindItem(id);
   if (!result) return void 0;
-  result.item.status = status2;
-  saveBacklog(result.items);
+  const db = getDb();
+  updateStatus(db, result.item.id, status2);
+  exportToJsonl(db, getBacklogDir());
   return result.item.name;
 }
 function setCurrentPhase(id, phase) {
   const result = loadAndFindItem(id);
   if (!result) return;
-  result.item.currentPhase = phase;
-  saveBacklog(result.items);
+  const db = getDb();
+  updateCurrentPhase(db, result.item.id, phase);
+  exportToJsonl(db, getBacklogDir());
 }
 function removeItem(id) {
   const result = loadAndFindItem(id);
   if (!result) return void 0;
-  saveBacklog(result.items.filter((i) => i.id !== result.item.id));
+  const db = getDb();
+  deleteItem(db, result.item.id);
+  exportToJsonl(db, getBacklogDir());
   return result.item.name;
 }
 function getNextId(items) {
@@ -215,7 +539,7 @@ function getNextId(items) {
 
 // src/commands/backlog/acquireLock.ts
 function getLockPath(itemId) {
-  return join2(getBacklogDir(), `.assist-lock-${itemId}.json`);
+  return join4(getBacklogDir(), `.assist-lock-${itemId}.json`);
 }
 function isProcessAlive(pid) {
   try {
@@ -229,7 +553,7 @@ function isLockedByOther(itemId) {
   const lockPath = getLockPath(itemId);
   if (!existsSync2(lockPath)) return false;
   try {
-    const lock = JSON.parse(readFileSync2(lockPath, "utf-8"));
+    const lock = JSON.parse(readFileSync3(lockPath, "utf-8"));
     if (lock.pid === process.pid) return false;
     return isProcessAlive(lock.pid);
   } catch {
@@ -438,10 +762,10 @@ async function handleIncompletePhase() {
 
 // src/commands/backlog/writeSignal.ts
 import { writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 var SIGNAL_FILE = ".assist-signal.json";
 function getSignalPath() {
-  return join3(getBacklogDir(), SIGNAL_FILE);
+  return join5(getBacklogDir(), SIGNAL_FILE);
 }
 function writeSignal(event, data) {
   const sessionId = process.env.ASSIST_SESSION_ID;
@@ -489,12 +813,12 @@ function spawnClaude(prompt, options2 = {}) {
 import { existsSync as existsSync5, unwatchFile, watchFile } from "fs";
 
 // src/commands/backlog/readSignal.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 function readSignal() {
   const path50 = getSignalPath();
   if (!existsSync4(path50)) return void 0;
   try {
-    return JSON.parse(readFileSync3(path50, "utf-8"));
+    return JSON.parse(readFileSync4(path50, "utf-8"));
   } catch {
     return void 0;
   }
@@ -862,11 +1186,11 @@ function printComments(item) {
 
 // src/shared/web.ts
 import { exec } from "child_process";
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import {
   createServer
 } from "http";
-import { dirname, join as join4 } from "path";
+import { dirname, join as join6 } from "path";
 import { fileURLToPath } from "url";
 import chalk14 from "chalk";
 function respondJson(res, status2, data) {
@@ -878,7 +1202,7 @@ function createBundleHandler(importMetaUrl, bundlePath) {
   let cache;
   return (_req, res) => {
     if (!cache) {
-      cache = readFileSync4(join4(dir, bundlePath), "utf-8");
+      cache = readFileSync5(join6(dir, bundlePath), "utf-8");
     }
     res.writeHead(200, { "Content-Type": "application/javascript" });
     res.end(cache);
@@ -991,7 +1315,7 @@ async function createItem(req, res) {
   saveBacklog(items);
   respondJson(res, 201, newItem);
 }
-function deleteItem(res, id) {
+function deleteItem2(res, id) {
   const result = findItemOr404(res, id);
   if (!result) return;
   saveBacklog(result.items.filter((i) => i.id !== id));
@@ -1033,7 +1357,7 @@ var itemRoutes = {
   GET: (_req, res, id) => getItemById(res, id),
   PUT: (req, res, id) => updateItem(req, res, id),
   PATCH: (req, res, id) => patchItemStatus(req, res, id),
-  DELETE: (_req, res, id) => deleteItem(res, id)
+  DELETE: (_req, res, id) => deleteItem2(res, id)
 };
 var baseHandler = createRouteHandler(routes);
 async function handleRequest(req, res, port) {
@@ -1080,19 +1404,19 @@ async function launchMode(slashCommand) {
 import { execSync } from "child_process";
 
 // src/shared/loadConfig.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { homedir } from "os";
-import { basename, dirname as dirname2, join as join5 } from "path";
+import { basename, dirname as dirname2, join as join7 } from "path";
 import chalk16 from "chalk";
-import { stringify as stringifyYaml2 } from "yaml";
+import { stringify as stringifyYaml } from "yaml";
 
 // src/shared/loadRawYaml.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
 import { parse as parseYaml2 } from "yaml";
 function loadRawYaml(path50) {
   if (!existsSync6(path50)) return {};
   try {
-    const content = readFileSync5(path50, "utf-8");
+    const content = readFileSync6(path50, "utf-8");
     return parseYaml2(content) || {};
   } catch {
     return {};
@@ -1222,9 +1546,9 @@ var assistConfigSchema = z2.strictObject({
 function findConfigUp(startDir) {
   let current = startDir;
   while (current !== dirname2(current)) {
-    const claudePath = join5(current, ".claude", "assist.yml");
+    const claudePath = join7(current, ".claude", "assist.yml");
     if (existsSync7(claudePath)) return claudePath;
-    const rootPath = join5(current, "assist.yml");
+    const rootPath = join7(current, "assist.yml");
     if (existsSync7(rootPath)) return rootPath;
     current = dirname2(current);
   }
@@ -1233,10 +1557,10 @@ function findConfigUp(startDir) {
 function getConfigPath() {
   const found = findConfigUp(process.cwd());
   if (found) return found;
-  return join5(process.cwd(), "assist.yml");
+  return join7(process.cwd(), "assist.yml");
 }
 function getGlobalConfigPath() {
-  return join5(homedir(), ".assist.yml");
+  return join7(homedir(), ".assist.yml");
 }
 function loadConfig() {
   const globalRaw = loadRawYaml(getGlobalConfigPath());
@@ -1251,21 +1575,21 @@ function loadGlobalConfigRaw() {
   return loadRawYaml(getGlobalConfigPath());
 }
 function saveGlobalConfig(config) {
-  writeFileSync4(getGlobalConfigPath(), stringifyYaml2(config, { lineWidth: 0 }));
+  writeFileSync4(getGlobalConfigPath(), stringifyYaml(config, { lineWidth: 0 }));
 }
 function saveConfig(config) {
   const configPath = getConfigPath();
-  writeFileSync4(configPath, stringifyYaml2(config, { lineWidth: 0 }));
+  writeFileSync4(configPath, stringifyYaml(config, { lineWidth: 0 }));
 }
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
     return config.devlog.name;
   }
-  const packageJsonPath = join5(process.cwd(), "package.json");
+  const packageJsonPath = join7(process.cwd(), "package.json");
   if (existsSync7(packageJsonPath)) {
     try {
-      const content = readFileSync6(packageJsonPath, "utf-8");
+      const content = readFileSync7(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.name) {
         return pkg.name;
@@ -1369,7 +1693,7 @@ function commit(args) {
 
 // src/commands/config/index.ts
 import chalk17 from "chalk";
-import { stringify as stringifyYaml3 } from "yaml";
+import { stringify as stringifyYaml2 } from "yaml";
 
 // src/commands/config/setNestedValue.ts
 function isPlainObject(val) {
@@ -1476,7 +1800,7 @@ function configSet(key, value, options2 = {}) {
 }
 function configList() {
   const config = loadConfig();
-  console.log(stringifyYaml3(config, { lineWidth: 0 }).trimEnd());
+  console.log(stringifyYaml2(config, { lineWidth: 0 }).trimEnd());
 }
 
 // src/commands/config/configGet.ts
@@ -1714,17 +2038,17 @@ import * as path3 from "path";
 import chalk25 from "chalk";
 
 // src/commands/verify/addToKnipIgnoreBinaries.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join9 } from "path";
 import chalk24 from "chalk";
 function loadKnipConfig(knipJsonPath) {
   if (existsSync9(knipJsonPath)) {
-    return JSON.parse(readFileSync8(knipJsonPath, "utf-8"));
+    return JSON.parse(readFileSync9(knipJsonPath, "utf-8"));
   }
   return { $schema: "https://unpkg.com/knip@5/schema.json" };
 }
 function addToKnipIgnoreBinaries(cwd, binary) {
-  const knipJsonPath = join7(cwd, "knip.json");
+  const knipJsonPath = join9(cwd, "knip.json");
   try {
     const knipConfig = loadKnipConfig(knipJsonPath);
     const ignoreBinaries = knipConfig.ignoreBinaries ?? [];
@@ -1772,8 +2096,8 @@ import chalk29 from "chalk";
 
 // src/commands/lint/init.ts
 import { execSync as execSync5 } from "child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname7, join as join8 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname7, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk28 from "chalk";
 
@@ -1798,7 +2122,7 @@ async function promptConfirm(message, initial = true) {
 
 // src/shared/removeEslint/index.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
 
 // src/shared/removeEslint/removeEslintConfigFiles.ts
 import { existsSync as existsSync10, unlinkSync as unlinkSync3 } from "fs";
@@ -1842,7 +2166,7 @@ function removeEslintFromPackageJson(options2) {
   if (!existsSync11(packageJsonPath)) {
     return false;
   }
-  const packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
   let modified = false;
   modified = removeEslintDeps(packageJson.dependencies) || modified;
   modified = removeEslintDeps(packageJson.devDependencies) || modified;
@@ -1920,9 +2244,9 @@ async function init() {
     console.log("No biome.json found, skipping linter config");
     return;
   }
-  const linterConfigPath = join8(__dirname2, "commands/lint/biome.linter.json");
-  const linterConfig = JSON.parse(readFileSync10(linterConfigPath, "utf-8"));
-  const biomeConfig = JSON.parse(readFileSync10(biomeConfigPath, "utf-8"));
+  const linterConfigPath = join10(__dirname2, "commands/lint/biome.linter.json");
+  const linterConfig = JSON.parse(readFileSync11(linterConfigPath, "utf-8"));
+  const biomeConfig = JSON.parse(readFileSync11(biomeConfigPath, "utf-8"));
   const oldContent = `${JSON.stringify(biomeConfig, null, 2)}
 `;
   biomeConfig.linter = linterConfig.linter;
@@ -2980,7 +3304,7 @@ function initPackageJson(name) {
 }
 
 // src/commands/new/registerNew/newCli/writeCliTemplate.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync11 } from "fs";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync11 } from "fs";
 function writeCliTemplate(name) {
   console.log("Writing tsconfig.json...");
   writeFileSync11(
@@ -3021,7 +3345,7 @@ export default defineConfig({
 `
   );
   console.log("Writing src/index.ts...");
-  mkdirSync2("src", { recursive: true });
+  mkdirSync3("src", { recursive: true });
   writeFileSync11(
     "src/index.ts",
     `#!/usr/bin/env node
@@ -3050,7 +3374,7 @@ async function newCli() {
 
 // src/commands/new/registerNew/newProject.ts
 import { execSync as execSync13 } from "child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "fs";
 
 // src/commands/deploy/init/index.ts
 import { execSync as execSync12 } from "child_process";
@@ -3058,8 +3382,8 @@ import chalk40 from "chalk";
 import enquirer5 from "enquirer";
 
 // src/commands/deploy/init/updateWorkflow.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname13, join as join11 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync4, readFileSync as readFileSync13, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname13, join as join13 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import chalk39 from "chalk";
 var WORKFLOW_PATH = ".github/workflows/build.yml";
@@ -3068,23 +3392,23 @@ function getExistingSiteId() {
   if (!existsSync15(WORKFLOW_PATH)) {
     return null;
   }
-  const content = readFileSync12(WORKFLOW_PATH, "utf-8");
+  const content = readFileSync13(WORKFLOW_PATH, "utf-8");
   const match = content.match(/-s\s+([a-f0-9-]{36})/);
   return match ? match[1] : null;
 }
 function getTemplateContent(siteId) {
-  const templatePath = join11(__dirname3, "commands/deploy/build.yml");
-  const template = readFileSync12(templatePath, "utf-8");
+  const templatePath = join13(__dirname3, "commands/deploy/build.yml");
+  const template = readFileSync13(templatePath, "utf-8");
   return template.replace("{{NETLIFY_SITE_ID}}", siteId);
 }
 async function updateWorkflow(siteId) {
   const newContent = getTemplateContent(siteId);
   const workflowDir = ".github/workflows";
   if (!existsSync15(workflowDir)) {
-    mkdirSync3(workflowDir, { recursive: true });
+    mkdirSync4(workflowDir, { recursive: true });
   }
   if (existsSync15(WORKFLOW_PATH)) {
-    const oldContent = readFileSync12(WORKFLOW_PATH, "utf-8");
+    const oldContent = readFileSync13(WORKFLOW_PATH, "utf-8");
     if (oldContent === newContent) {
       console.log(chalk39.green("build.yml is already up to date"));
       return;
@@ -3182,7 +3506,7 @@ function addViteBaseConfig() {
     console.log("No vite.config.ts found, skipping base config");
     return;
   }
-  const content = readFileSync13(viteConfigPath, "utf-8");
+  const content = readFileSync14(viteConfigPath, "utf-8");
   if (content.includes("base:")) {
     console.log("vite.config.ts already has base config");
     return;
@@ -3365,12 +3689,13 @@ import chalk45 from "chalk";
 
 // src/commands/backlog/commitBacklog.ts
 import { execSync as execSync14 } from "child_process";
+import { join as join14 } from "path";
 import chalk43 from "chalk";
 function commitBacklog(id, name) {
   try {
-    const backlogPath = getBacklogPath();
+    const jsonlPath = join14(getBacklogDir(), ".assist", "backlog.jsonl");
     const message = `chore: add backlog item #${id} \u2014 ${name}`;
-    execSync14(`git add ${shellQuote(backlogPath)}`, { stdio: "ignore" });
+    execSync14(`git add ${shellQuote(jsonlPath)}`, { stdio: "ignore" });
     execSync14(`git commit -m ${shellQuote(message)}`, { stdio: "ignore" });
   } catch {
     console.log(chalk43.yellow("Warning: could not auto-commit backlog file."));
@@ -3378,7 +3703,7 @@ function commitBacklog(id, name) {
 }
 
 // src/commands/backlog/add/parseItemFile.ts
-import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
 import chalk44 from "chalk";
 import { ZodError } from "zod";
 var addItemSchema = backlogItemSchema.omit({ id: true, status: true });
@@ -3390,7 +3715,7 @@ function readJsonFile(filePath) {
   }
   let raw;
   try {
-    raw = readFileSync14(filePath, "utf-8");
+    raw = readFileSync15(filePath, "utf-8");
   } catch {
     console.log(chalk44.red(`Failed to read file: ${filePath}`));
     process.exitCode = 1;
@@ -3428,9 +3753,9 @@ function parseItemFile(filePath) {
 
 // src/commands/backlog/add/shared.ts
 import { spawnSync } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync15, unlinkSync as unlinkSync4, writeFileSync as writeFileSync14 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync16, unlinkSync as unlinkSync4, writeFileSync as writeFileSync14 } from "fs";
 import { tmpdir } from "os";
-import { join as join12 } from "path";
+import { join as join15 } from "path";
 import enquirer6 from "enquirer";
 async function promptType() {
   const { type } = await enquirer6.prompt({
@@ -3470,15 +3795,15 @@ async function promptDescription() {
 }
 function openEditor() {
   const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-  const dir = mkdtempSync(join12(tmpdir(), "assist-"));
-  const filePath = join12(dir, "description.md");
+  const dir = mkdtempSync(join15(tmpdir(), "assist-"));
+  const filePath = join15(dir, "description.md");
   writeFileSync14(filePath, "");
   const result = spawnSync(editor, [filePath], { stdio: "inherit" });
   if (result.status !== 0) {
     unlinkSync4(filePath);
     return void 0;
   }
-  const content = readFileSync15(filePath, "utf-8").trim();
+  const content = readFileSync16(filePath, "utf-8").trim();
   unlinkSync4(filePath);
   return content || void 0;
 }
@@ -3870,7 +4195,7 @@ function extractGraphqlQuery(args) {
 }
 
 // src/shared/loadCliReads.ts
-import { existsSync as existsSync21, readFileSync as readFileSync16, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "fs";
 import { dirname as dirname14, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __filename2 = fileURLToPath4(import.meta.url);
@@ -3880,7 +4205,7 @@ function packageRoot() {
 }
 function readLines(path50) {
   if (!existsSync21(path50)) return [];
-  return readFileSync16(path50, "utf-8").split("\n").filter((line) => line.trim() !== "");
+  return readFileSync17(path50, "utf-8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -3926,14 +4251,14 @@ function findCliWrite(command) {
 }
 
 // src/shared/readSettingsPerms.ts
-import { existsSync as existsSync22, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync18 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join13 } from "path";
+import { join as join16 } from "path";
 function readSettingsPerms(key) {
   const paths = [
-    join13(homedir3(), ".claude", "settings.json"),
-    join13(process.cwd(), ".claude", "settings.json"),
-    join13(process.cwd(), ".claude", "settings.local.json")
+    join16(homedir3(), ".claude", "settings.json"),
+    join16(process.cwd(), ".claude", "settings.json"),
+    join16(process.cwd(), ".claude", "settings.local.json")
   ];
   const entries = [];
   for (const p of paths) {
@@ -3944,7 +4269,7 @@ function readSettingsPerms(key) {
 function readPermissionArray(filePath, key) {
   if (!existsSync22(filePath)) return [];
   try {
-    const data = JSON.parse(readFileSync17(filePath, "utf-8"));
+    const data = JSON.parse(readFileSync18(filePath, "utf-8"));
     const arr = data?.permissions?.[key];
     return Array.isArray(arr) ? arr.filter((e) => typeof e === "string") : [];
   } catch {
@@ -4229,9 +4554,9 @@ function denyRemove(pattern2) {
 }
 
 // src/commands/permitCliReads/index.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync4, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync5, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join14 } from "path";
+import { join as join17 } from "path";
 
 // src/shared/getInstallDir.ts
 import { execSync as execSync15 } from "child_process";
@@ -4533,16 +4858,16 @@ function updateSettings(cli, commands) {
 // src/commands/permitCliReads/index.ts
 function logPath(cli) {
   const safeName = cli.replace(/\s+/g, "-");
-  return join14(homedir4(), ".assist", `cli-discover-${safeName}.log`);
+  return join17(homedir4(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
   const path50 = logPath(cli);
   if (!existsSync23(path50)) return void 0;
-  return readFileSync18(path50, "utf-8");
+  return readFileSync19(path50, "utf-8");
 }
 function writeCache(cli, output) {
-  const dir = join14(homedir4(), ".assist");
-  mkdirSync4(dir, { recursive: true });
+  const dir = join17(homedir4(), ".assist");
+  mkdirSync5(dir, { recursive: true });
   writeFileSync16(logPath(cli), output);
 }
 async function permitCliReads(cli, options2 = { noCache: false }) {
@@ -5090,7 +5415,7 @@ function registerComplexity(program2) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync24, readFileSync as readFileSync19, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "fs";
 import chalk64 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
@@ -5103,7 +5428,7 @@ function redirect() {
     console.log(chalk64.yellow("No index.html found"));
     return;
   }
-  const content = readFileSync19(indexPath, "utf-8");
+  const content = readFileSync20(indexPath, "utf-8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
     console.log(chalk64.dim("Trailing slash script already present"));
     return;
@@ -5131,10 +5456,10 @@ import { basename as basename3 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
 import { homedir as homedir5 } from "os";
-import { join as join15 } from "path";
-var BLOG_REPO_ROOT = join15(homedir5(), "git/blog");
+import { join as join18 } from "path";
+var BLOG_REPO_ROOT = join18(homedir5(), "git/blog");
 function loadBlogSkipDays(repoName) {
-  const config = loadRawYaml(join15(BLOG_REPO_ROOT, "assist.yml"));
+  const config = loadRawYaml(join18(BLOG_REPO_ROOT, "assist.yml"));
   const devlog = config.devlog;
   const skip2 = devlog?.skip;
   return new Set(skip2?.[repoName] ?? []);
@@ -5145,9 +5470,9 @@ import { execSync as execSync17 } from "child_process";
 import chalk65 from "chalk";
 
 // src/commands/devlog/loadDevlogEntries.ts
-import { readdirSync, readFileSync as readFileSync20 } from "fs";
-import { join as join16 } from "path";
-var DEVLOG_DIR = join16(BLOG_REPO_ROOT, "src/content/devlog");
+import { readdirSync, readFileSync as readFileSync21 } from "fs";
+import { join as join19 } from "path";
+var DEVLOG_DIR = join19(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
   const fm = content.match(/^---\n([\s\S]*?)\n---/);
   return fm?.[1] ?? null;
@@ -5175,7 +5500,7 @@ function readDevlogFiles(callback) {
   try {
     const files = readdirSync(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync20(join16(DEVLOG_DIR, file), "utf-8");
+      const content = readFileSync21(join19(DEVLOG_DIR, file), "utf-8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -5354,7 +5679,8 @@ function getLastVersionInfo(repoName, config) {
     const gitInfo = getLastVersionInfoFromGit();
     if (gitInfo) return { date: lastDate, version: gitInfo.version };
   }
-  const lastVersion = entries.get(lastDate)?.[0]?.version;
+  const dayEntries = entries.get(lastDate);
+  const lastVersion = dayEntries?.[dayEntries.length - 1]?.version;
   return lastVersion ? { date: lastDate, version: lastVersion } : null;
 }
 function cleanVersion(version2) {
@@ -5561,11 +5887,11 @@ function repos(options2) {
 
 // src/commands/devlog/skip.ts
 import { writeFileSync as writeFileSync18 } from "fs";
-import { join as join17 } from "path";
+import { join as join20 } from "path";
 import chalk70 from "chalk";
-import { stringify as stringifyYaml4 } from "yaml";
+import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
-  return join17(BLOG_REPO_ROOT, "assist.yml");
+  return join20(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
@@ -5589,7 +5915,7 @@ function skip(date) {
   skip2[repoName] = skipDays;
   devlog.skip = skip2;
   config.devlog = devlog;
-  writeFileSync18(configPath, stringifyYaml4(config, { lineWidth: 0 }));
+  writeFileSync18(configPath, stringifyYaml3(config, { lineWidth: 0 }));
   console.log(chalk70.green(`Added ${date} to skip list for ${repoName}`));
 }
 
@@ -5626,7 +5952,7 @@ function registerDevlog(program2) {
 
 // src/commands/dotnet/checkBuildLocks.ts
 import { closeSync, openSync, readdirSync as readdirSync2 } from "fs";
-import { join as join18 } from "path";
+import { join as join21 } from "path";
 import chalk72 from "chalk";
 
 // src/shared/findRepoRoot.ts
@@ -5654,7 +5980,7 @@ function isLockedDll(debugDir) {
   }
   for (const file of files) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
-    const dllPath = join18(debugDir, file);
+    const dllPath = join21(debugDir, file);
     try {
       const fd = openSync(dllPath, "r+");
       closeSync(fd);
@@ -5672,13 +5998,13 @@ function findFirstLockedDll(dir) {
     return null;
   }
   if (entries.includes("bin")) {
-    const locked = isLockedDll(join18(dir, "bin", "Debug"));
+    const locked = isLockedDll(join21(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(join18(dir, entry));
+    const found = findFirstLockedDll(join21(dir, entry));
     if (found) return found;
   }
   return null;
@@ -5701,11 +6027,11 @@ async function checkBuildLocksCommand() {
 }
 
 // src/commands/dotnet/buildTree.ts
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 import path22 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, "/"));
@@ -5722,7 +6048,7 @@ function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
   for (const ref of getProjectRefs(abs)) {
     const childAbs = path22.resolve(dir, ref);
     try {
-      readFileSync21(childAbs);
+      readFileSync22(childAbs);
       node.children.push(buildTree(childAbs, repoRoot, visited));
     } catch {
       node.children.push({
@@ -5747,7 +6073,7 @@ function collectAllDeps(node) {
 }
 
 // src/commands/dotnet/findContainingSolutions.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync22, statSync } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync23, statSync as statSync3 } from "fs";
 import path23 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
@@ -5763,7 +6089,7 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
       continue;
     const full = path23.join(dir, entry);
     try {
-      const stat = statSync(full);
+      const stat = statSync3(full);
       if (stat.isFile() && entry.endsWith(".sln")) {
         results.push(full);
       } else if (stat.isDirectory()) {
@@ -5782,7 +6108,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(path23.relative(repoRoot, sln));
       }
@@ -6025,11 +6351,11 @@ import chalk78 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
 import { readdirSync as readdirSync4 } from "fs";
-import { dirname as dirname16, join as join19 } from "path";
+import { dirname as dirname16, join as join22 } from "path";
 import chalk77 from "chalk";
 function findSlnInDir(dir) {
   try {
-    return readdirSync4(dir).filter((f) => f.endsWith(".sln")).map((f) => join19(dir, f));
+    return readdirSync4(dir).filter((f) => f.endsWith(".sln")).map((f) => join22(dir, f));
   } catch {
     return [];
   }
@@ -6100,7 +6426,7 @@ function parseInspectReport(json) {
 
 // src/commands/dotnet/runInspectCode.ts
 import { execSync as execSync23 } from "child_process";
-import { existsSync as existsSync28, readFileSync as readFileSync23, unlinkSync as unlinkSync5 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync24, unlinkSync as unlinkSync5 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import path26 from "path";
 import chalk79 from "chalk";
@@ -6135,7 +6461,7 @@ function runInspectCode(slnPath, include, swea) {
     console.error(chalk79.red("Report file not generated"));
     process.exit(1);
   }
-  const xml = readFileSync23(reportPath, "utf-8");
+  const xml = readFileSync24(reportPath, "utf-8");
   unlinkSync5(reportPath);
   return xml;
 }
@@ -6363,20 +6689,20 @@ function acceptanceCriteria(issueKey) {
 import { execSync as execSync26 } from "child_process";
 
 // src/shared/loadJson.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync5, readFileSync as readFileSync24, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync6, readFileSync as readFileSync25, writeFileSync as writeFileSync19 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join20 } from "path";
+import { join as join23 } from "path";
 function getStoreDir() {
-  return join20(homedir6(), ".assist");
+  return join23(homedir6(), ".assist");
 }
 function getStorePath(filename) {
-  return join20(getStoreDir(), filename);
+  return join23(getStoreDir(), filename);
 }
 function loadJson(filename) {
   const path50 = getStorePath(filename);
   if (existsSync29(path50)) {
     try {
-      return JSON.parse(readFileSync24(path50, "utf-8"));
+      return JSON.parse(readFileSync25(path50, "utf-8"));
     } catch {
       return {};
     }
@@ -6386,7 +6712,7 @@ function loadJson(filename) {
 function saveJson(filename, data) {
   const dir = getStoreDir();
   if (!existsSync29(dir)) {
-    mkdirSync5(dir, { recursive: true });
+    mkdirSync6(dir, { recursive: true });
   }
   writeFileSync19(getStorePath(filename), JSON.stringify(data, null, 2));
 }
@@ -6702,7 +7028,7 @@ function registerNews(program2) {
 import { spawnSync as spawnSync2 } from "child_process";
 import { unlinkSync as unlinkSync6, writeFileSync as writeFileSync20 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join21 } from "path";
+import { join as join24 } from "path";
 
 // src/commands/prs/shared.ts
 import { execSync as execSync27 } from "child_process";
@@ -6774,7 +7100,7 @@ function comment2(path50, line, body) {
   validateLine(line);
   try {
     const prId = getCurrentPrNodeId();
-    const queryFile = join21(tmpdir3(), `gh-query-${Date.now()}.graphql`);
+    const queryFile = join24(tmpdir3(), `gh-query-${Date.now()}.graphql`);
     writeFileSync20(queryFile, MUTATION);
     try {
       const result = spawnSync2(
@@ -6819,21 +7145,21 @@ import { execSync as execSync29 } from "child_process";
 import { execSync as execSync28 } from "child_process";
 import { unlinkSync as unlinkSync8, writeFileSync as writeFileSync21 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join23 } from "path";
+import { join as join26 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync30, readFileSync as readFileSync25, unlinkSync as unlinkSync7 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync26, unlinkSync as unlinkSync7 } from "fs";
+import { join as join25 } from "path";
 import { parse as parse2 } from "yaml";
 function getCachePath(prNumber) {
-  return join22(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join25(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
   if (!existsSync30(cachePath)) {
     return null;
   }
-  const content = readFileSync25(cachePath, "utf-8");
+  const content = readFileSync26(cachePath, "utf-8");
   return parse2(content);
 }
 function deleteCommentsCache(prNumber) {
@@ -6853,7 +7179,7 @@ function replyToComment(org, repo, prNumber, commentId, message) {
 }
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join23(tmpdir4(), `gh-mutation-${Date.now()}.graphql`);
+  const queryFile = join26(tmpdir4(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync21(queryFile, mutation);
   try {
     execSync28(
@@ -6935,18 +7261,18 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments/index.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync6, writeFileSync as writeFileSync23 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync7, writeFileSync as writeFileSync23 } from "fs";
+import { join as join28 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
 import { execSync as execSync30 } from "child_process";
 import { unlinkSync as unlinkSync9, writeFileSync as writeFileSync22 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join24 } from "path";
+import { join as join27 } 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 = join24(tmpdir5(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join27(tmpdir5(), `gh-query-${Date.now()}.graphql`);
   writeFileSync22(queryFile, THREAD_QUERY);
   try {
     const result = execSync30(
@@ -7060,16 +7386,16 @@ function printComments2(result) {
 
 // src/commands/prs/listComments/index.ts
 function writeCommentsCache(prNumber, comments2) {
-  const assistDir = join25(process.cwd(), ".assist");
+  const assistDir = join28(process.cwd(), ".assist");
   if (!existsSync31(assistDir)) {
-    mkdirSync6(assistDir, { recursive: true });
+    mkdirSync7(assistDir, { recursive: true });
   }
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments2
   };
-  const cachePath = join25(assistDir, `pr-${prNumber}-comments.yaml`);
+  const cachePath = join28(assistDir, `pr-${prNumber}-comments.yaml`);
   writeFileSync23(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
@@ -7102,7 +7428,7 @@ async function listComments() {
     ];
     updateCache(prNumber, allComments);
     const hasLineComments = allComments.some((c) => c.type === "line");
-    const cachePath = hasLineComments ? join25(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
+    const cachePath = hasLineComments ? join28(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
     return { comments: allComments, cachePath };
   } catch (error) {
     const handled = handleKnownErrors(error);
@@ -7996,7 +8322,7 @@ function isNameReferencedInSource(sourceFile, name) {
 }
 async function applyExtraction(functionName, sourceFile, destPath, plan2, project) {
   project.createSourceFile(destPath, plan2.destContent, { overwrite: false });
-  for (const fn of [plan2.target, ...plan2.dependencies]) {
+  for (const fn of [plan2.target, ...plan2.functionsToRemove]) {
     fn.remove();
   }
   for (const stmt of plan2.statementsToRemove) {
@@ -8033,7 +8359,7 @@ async function applyExtraction(functionName, sourceFile, destPath, plan2, projec
 
 // src/commands/refactor/extract/collectDependencies.ts
 import {
-  SyntaxKind as SyntaxKind5
+  SyntaxKind as SyntaxKind7
 } from "ts-morph";
 
 // src/commands/refactor/extract/collectPrivateFunctions.ts
@@ -8072,6 +8398,41 @@ function collectPrivateFunctions(target, fnMap) {
   });
 }
 
+// src/commands/refactor/extract/collectPrivateStatements.ts
+import { SyntaxKind as SyntaxKind5 } from "ts-morph";
+function getReferencedIdentifiers(fn) {
+  const names = /* @__PURE__ */ new Set();
+  for (const id of fn.getDescendantsOfKind(SyntaxKind5.Identifier)) {
+    names.add(id.getText());
+  }
+  return names;
+}
+function collectPrivateStatements(functions, stmtMap) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const fn of functions) {
+    for (const name of getReferencedIdentifiers(fn)) {
+      const stmt = stmtMap.get(name);
+      if (stmt) seen.add(stmt);
+    }
+  }
+  return [...seen];
+}
+
+// src/commands/refactor/extract/getFunctionMap.ts
+import {
+  SyntaxKind as SyntaxKind6
+} from "ts-morph";
+function getFunctionMap(sourceFile) {
+  const map = /* @__PURE__ */ new Map();
+  for (const fn of sourceFile.getDescendantsOfKind(
+    SyntaxKind6.FunctionDeclaration
+  )) {
+    const name = fn.getName();
+    if (name) map.set(name, fn);
+  }
+  return map;
+}
+
 // src/commands/refactor/extract/getPrivateStatementMap.ts
 function getPrivateStatementMap(sourceFile) {
   const map = /* @__PURE__ */ new Map();
@@ -8089,73 +8450,61 @@ function getPrivateStatementMap(sourceFile) {
 }
 
 // src/commands/refactor/extract/collectDependencies.ts
-function getReferencedIdentifiers(fn) {
-  const names = /* @__PURE__ */ new Set();
-  for (const id of fn.getDescendantsOfKind(SyntaxKind5.Identifier)) {
-    names.add(id.getText());
-  }
-  return names;
-}
-function getFunctionMap(sourceFile) {
-  const map = /* @__PURE__ */ new Map();
-  for (const fn of sourceFile.getDescendantsOfKind(
-    SyntaxKind5.FunctionDeclaration
-  )) {
-    const name = fn.getName();
-    if (name) map.set(name, fn);
-  }
-  return map;
+function getRemainingFunctions(sourceFile, extracted) {
+  return sourceFile.getDescendantsOfKind(SyntaxKind7.FunctionDeclaration).filter((fn) => !extracted.has(fn));
 }
-function collectPrivateStatements(functions, stmtMap) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const fn of functions) {
-    for (const name of getReferencedIdentifiers(fn)) {
-      const stmt = stmtMap.get(name);
-      if (stmt) seen.add(stmt);
+function collectFnsUsedByRemaining(remaining, fnMap) {
+  const used = /* @__PURE__ */ new Set();
+  for (const fn of remaining) {
+    for (const dep of collectPrivateFunctions(fn, fnMap)) {
+      used.add(dep);
     }
   }
-  return [...seen];
-}
-function getRemainingFunctions(sourceFile, extracted) {
-  return sourceFile.getDescendantsOfKind(SyntaxKind5.FunctionDeclaration).filter((fn) => !extracted.has(fn));
+  return used;
 }
 function collectDependencies(target, sourceFile) {
   const fnMap = getFunctionMap(sourceFile);
   const depFunctions = collectPrivateFunctions(target, fnMap);
   const allExtracted = [target, ...depFunctions];
   const stmtMap = getPrivateStatementMap(sourceFile);
-  const toCopy = collectPrivateStatements(allExtracted, stmtMap);
-  const extractedSet = new Set(allExtracted);
-  const remaining = getRemainingFunctions(sourceFile, extractedSet);
-  const usedByRemaining = new Set(collectPrivateStatements(remaining, stmtMap));
-  const toRemove = toCopy.filter((s) => !usedByRemaining.has(s));
+  const stmtsToCopy = collectPrivateStatements(allExtracted, stmtMap);
+  const remaining = getRemainingFunctions(sourceFile, new Set(allExtracted));
+  const fnsUsedByRemaining = collectFnsUsedByRemaining(remaining, fnMap);
+  const fnsToRemove = depFunctions.filter((fn) => !fnsUsedByRemaining.has(fn));
+  const staysInSource = [
+    ...remaining,
+    ...depFunctions.filter((fn) => fnsUsedByRemaining.has(fn))
+  ];
+  const stmtsToRemove = stmtsToCopy.filter(
+    (s) => !new Set(collectPrivateStatements(staysInSource, stmtMap)).has(s)
+  );
   return {
-    functions: depFunctions,
-    statements: { toCopy, toRemove }
+    functions: { toCopy: depFunctions, toRemove: fnsToRemove },
+    statements: { toCopy: stmtsToCopy, toRemove: stmtsToRemove }
   };
 }
 
 // src/commands/refactor/extract/findFunction.ts
 import {
-  SyntaxKind as SyntaxKind6
+  SyntaxKind as SyntaxKind8
 } from "ts-morph";
 function findFunction(sourceFile, functionName) {
-  return sourceFile.getDescendantsOfKind(SyntaxKind6.FunctionDeclaration).find((fn) => fn.getName() === functionName);
+  return sourceFile.getDescendantsOfKind(SyntaxKind8.FunctionDeclaration).find((fn) => fn.getName() === functionName);
 }
 
 // src/commands/refactor/extract/getExportedDependencyNames.ts
-import { SyntaxKind as SyntaxKind7 } from "ts-morph";
+import { SyntaxKind as SyntaxKind9 } from "ts-morph";
 function getExportedDependencyNames(target, sourceFile) {
   const calledNames = /* @__PURE__ */ new Set();
-  for (const call of target.getDescendantsOfKind(SyntaxKind7.CallExpression)) {
+  for (const call of target.getDescendantsOfKind(SyntaxKind9.CallExpression)) {
     const expr = call.getExpression();
-    if (expr.getKind() === SyntaxKind7.Identifier) {
+    if (expr.getKind() === SyntaxKind9.Identifier) {
       calledNames.add(expr.getText());
     }
   }
   const exported = [];
   for (const fn of sourceFile.getDescendantsOfKind(
-    SyntaxKind7.FunctionDeclaration
+    SyntaxKind9.FunctionDeclaration
   )) {
     const name = fn.getName();
     if (name && calledNames.has(name) && fn.isExported()) {
@@ -8166,9 +8515,9 @@ function getExportedDependencyNames(target, sourceFile) {
 }
 
 // src/commands/refactor/extract/getStatementNames.ts
-import { SyntaxKind as SyntaxKind8 } from "ts-morph";
+import { SyntaxKind as SyntaxKind10 } from "ts-morph";
 function getStatementNames(node) {
-  if (node.getKind() === SyntaxKind8.VariableStatement) {
+  if (node.getKind() === SyntaxKind10.VariableStatement) {
     const stmt = node;
     return stmt.getDeclarations().map((d) => d.getName());
   }
@@ -8178,7 +8527,7 @@ function getStatementNames(node) {
 
 // src/commands/refactor/extract/resolveImports.ts
 import {
-  SyntaxKind as SyntaxKind9
+  SyntaxKind as SyntaxKind11
 } from "ts-morph";
 
 // src/commands/refactor/extract/matchImport.ts
@@ -8222,7 +8571,7 @@ function matchImport(importDecl, neededNames) {
 function getReferencedNames(nodes) {
   const names = /* @__PURE__ */ new Set();
   for (const node of nodes) {
-    for (const id of node.getDescendantsOfKind(SyntaxKind9.Identifier)) {
+    for (const id of node.getDescendantsOfKind(SyntaxKind11.Identifier)) {
       names.add(id.getText());
     }
   }
@@ -8237,7 +8586,7 @@ function getLocallyDeclaredNames(functions) {
       names.add(param.getName());
     }
     for (const varDecl of fn.getDescendantsOfKind(
-      SyntaxKind9.VariableDeclaration
+      SyntaxKind11.VariableDeclaration
     )) {
       names.add(varDecl.getName());
     }
@@ -8274,26 +8623,24 @@ function extractTexts(target, allFunctions, statements) {
 function analyseTarget(sourceFile, functionName) {
   const target = findFunction(sourceFile, functionName);
   if (!target) throw new Error(`Function "${functionName}" not found`);
-  const { functions: dependencies, statements } = collectDependencies(
-    target,
-    sourceFile
-  );
-  const all = [target, ...dependencies];
+  const { functions, statements } = collectDependencies(target, sourceFile);
+  const all = [target, ...functions.toCopy];
   return {
     target,
-    dependencies,
+    dependencies: functions.toCopy,
+    functionsToRemove: functions.toRemove,
     statementsToCopy: statements.toCopy,
     statementsToRemove: statements.toRemove,
     imports: resolveImports(
       target,
-      dependencies,
+      functions.toCopy,
       sourceFile,
       statements.toCopy
     ),
     exportedDeps: getExportedDependencyNames(target, sourceFile),
     extractedNames: [
       ...statements.toRemove.flatMap(getStatementNames),
-      ...all.map((fn) => fn.getName()).filter(Boolean)
+      ...[target, ...functions.toRemove].map((fn) => fn.getName()).filter(Boolean)
     ],
     functionTexts: extractTexts(target, all, statements.toCopy)
   };
@@ -8394,16 +8741,16 @@ function rewriteImportPaths(imports, sourcePath, destPath) {
 }
 
 // src/commands/refactor/extract/sourceReferencesName.ts
-import { SyntaxKind as SyntaxKind10 } from "ts-morph";
+import { SyntaxKind as SyntaxKind12 } from "ts-morph";
 var DECLARATION_KINDS = /* @__PURE__ */ new Set([
-  SyntaxKind10.FunctionDeclaration,
-  SyntaxKind10.ImportSpecifier,
-  SyntaxKind10.ExportSpecifier
+  SyntaxKind12.FunctionDeclaration,
+  SyntaxKind12.ImportSpecifier,
+  SyntaxKind12.ExportSpecifier
 ]);
 function isInsideExtractedFunction(node, extracted) {
   let current = node;
   while (current) {
-    if (current.getKind() !== SyntaxKind10.FunctionDeclaration) {
+    if (current.getKind() !== SyntaxKind12.FunctionDeclaration) {
       current = current.getParent();
       continue;
     }
@@ -8415,7 +8762,7 @@ function isInsideExtractedFunction(node, extracted) {
 }
 function sourceReferencesName(sourceFile, functionName, extractedNames) {
   const extracted = new Set(extractedNames);
-  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind10.Identifier)) {
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind12.Identifier)) {
     if (id.getText() !== functionName) continue;
     const parent = id.getParent();
     if (!parent || DECLARATION_KINDS.has(parent.getKind())) continue;
@@ -8620,24 +8967,24 @@ import chalk107 from "chalk";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
-import { SyntaxKind as SyntaxKind11 } from "ts-morph";
+import { SyntaxKind as SyntaxKind13 } from "ts-morph";
 var declarationKinds = [
-  SyntaxKind11.VariableDeclaration,
-  SyntaxKind11.FunctionDeclaration,
-  SyntaxKind11.ClassDeclaration,
-  SyntaxKind11.InterfaceDeclaration,
-  SyntaxKind11.TypeAliasDeclaration,
-  SyntaxKind11.EnumDeclaration,
-  SyntaxKind11.PropertyDeclaration,
-  SyntaxKind11.MethodDeclaration,
-  SyntaxKind11.Parameter
+  SyntaxKind13.VariableDeclaration,
+  SyntaxKind13.FunctionDeclaration,
+  SyntaxKind13.ClassDeclaration,
+  SyntaxKind13.InterfaceDeclaration,
+  SyntaxKind13.TypeAliasDeclaration,
+  SyntaxKind13.EnumDeclaration,
+  SyntaxKind13.PropertyDeclaration,
+  SyntaxKind13.MethodDeclaration,
+  SyntaxKind13.Parameter
 ];
 function isDeclaration(identifier) {
   const parent = identifier.getParent();
   return parent !== void 0 && declarationKinds.includes(parent.getKind());
 }
 function findSymbol(sourceFile, symbolName) {
-  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind11.Identifier)) {
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind13.Identifier)) {
     if (id.getText() === symbolName && isDeclaration(id)) return id;
   }
   return void 0;
@@ -9475,8 +9822,8 @@ function registerSeq(program2) {
 }
 
 // src/commands/transcript/shared.ts
-import { existsSync as existsSync32, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
-import { basename as basename4, join as join26, relative } from "path";
+import { existsSync as existsSync32, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
+import { basename as basename4, join as join29, relative } from "path";
 import * as readline2 from "readline";
 var DATE_PREFIX_REGEX = /^\d{4}-\d{2}-\d{2}/;
 function getDatePrefix(daysOffset = 0) {
@@ -9494,8 +9841,8 @@ function collectFiles(dir, extension) {
   if (!existsSync32(dir)) return [];
   const results = [];
   for (const entry of readdirSync5(dir)) {
-    const fullPath = join26(dir, entry);
-    if (statSync2(fullPath).isDirectory()) {
+    const fullPath = join29(dir, entry);
+    if (statSync4(fullPath).isDirectory()) {
       results.push(...collectFiles(fullPath, extension));
     } else if (entry.endsWith(extension)) {
       results.push(fullPath);
@@ -9591,11 +9938,11 @@ async function configure() {
 import { existsSync as existsSync34 } from "fs";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/index.ts
-import { dirname as dirname18, join as join28 } from "path";
+import { dirname as dirname18, join as join31 } from "path";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/promptForDateFix.ts
-import { renameSync } from "fs";
-import { join as join27 } from "path";
+import { renameSync as renameSync2 } from "fs";
+import { join as join30 } from "path";
 async function resolveDate(rl, choice) {
   if (choice === "1") return getDatePrefix(0);
   if (choice === "2") return getDatePrefix(-1);
@@ -9610,7 +9957,7 @@ async function resolveDate(rl, choice) {
 }
 function renameWithPrefix(vttDir, vttFile, prefix2) {
   const newFilename = `${prefix2}.${vttFile}`;
-  renameSync(join27(vttDir, vttFile), join27(vttDir, newFilename));
+  renameSync2(join30(vttDir, vttFile), join30(vttDir, newFilename));
   console.log(`Renamed to: ${newFilename}`);
   return newFilename;
 }
@@ -9644,12 +9991,12 @@ async function fixInvalidDatePrefixes(vttFiles) {
       const vttFileDir = dirname18(vttFile.absolutePath);
       const newFilename = await promptForDateFix(vttFile.filename, vttFileDir);
       if (newFilename) {
-        const newRelativePath = join28(
+        const newRelativePath = join31(
           dirname18(vttFile.relativePath),
           newFilename
         );
         vttFiles[i] = {
-          absolutePath: join28(vttFileDir, newFilename),
+          absolutePath: join31(vttFileDir, newFilename),
           relativePath: newRelativePath,
           filename: newFilename
         };
@@ -9662,8 +10009,8 @@ async function fixInvalidDatePrefixes(vttFiles) {
 }
 
 // src/commands/transcript/format/processVttFile/index.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync7, readFileSync as readFileSync26, writeFileSync as writeFileSync24 } from "fs";
-import { basename as basename5, dirname as dirname19, join as join29 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync8, readFileSync as readFileSync27, writeFileSync as writeFileSync24 } from "fs";
+import { basename as basename5, dirname as dirname19, join as join32 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text) {
@@ -9873,22 +10220,22 @@ function toMdFilename(vttFilename) {
   return `${basename5(vttFilename, ".vtt").replace(/\s*Transcription\s*/g, " ").trim()}.md`;
 }
 function resolveOutputDir(relativeDir, transcriptsDir) {
-  return relativeDir === "." ? transcriptsDir : join29(transcriptsDir, relativeDir);
+  return relativeDir === "." ? transcriptsDir : join32(transcriptsDir, relativeDir);
 }
 function buildOutputPaths(vttFile, transcriptsDir) {
   const mdFile = toMdFilename(vttFile.filename);
   const relativeDir = dirname19(vttFile.relativePath);
   const outputDir = resolveOutputDir(relativeDir, transcriptsDir);
-  const outputPath = join29(outputDir, mdFile);
+  const outputPath = join32(outputDir, mdFile);
   return { outputDir, outputPath, mdFile, relativeDir };
 }
 function logSkipped(relativeDir, mdFile) {
-  console.log(`Skipping (already exists): ${join29(relativeDir, mdFile)}`);
+  console.log(`Skipping (already exists): ${join32(relativeDir, mdFile)}`);
   return "skipped";
 }
 function ensureDirectory(dir, label2) {
   if (!existsSync33(dir)) {
-    mkdirSync7(dir, { recursive: true });
+    mkdirSync8(dir, { recursive: true });
     console.log(`Created ${label2}: ${dir}`);
   }
 }
@@ -9910,7 +10257,7 @@ function logReduction(cueCount, messageCount) {
 }
 function readAndParseCues(inputPath) {
   console.log(`Reading: ${inputPath}`);
-  return processCues(readFileSync26(inputPath, "utf-8"));
+  return processCues(readFileSync27(inputPath, "utf-8"));
 }
 function writeFormatted(outputPath, content) {
   writeFileSync24(outputPath, content, "utf-8");
@@ -9982,17 +10329,17 @@ async function format() {
 
 // src/commands/transcript/summarise/index.ts
 import { existsSync as existsSync36 } from "fs";
-import { basename as basename6, dirname as dirname21, join as join31, relative as relative2 } from "path";
+import { basename as basename6, dirname as dirname21, join as join34, relative as relative2 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
 import {
   existsSync as existsSync35,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync27,
-  renameSync as renameSync2,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync28,
+  renameSync as renameSync3,
   rmSync
 } from "fs";
-import { dirname as dirname20, join as join30 } from "path";
+import { dirname as dirname20, join as join33 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
 import chalk118 from "chalk";
@@ -10021,7 +10368,7 @@ function validateStagedContent(filename, content) {
 }
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
-var STAGING_DIR = join30(process.cwd(), ".assist", "transcript");
+var STAGING_DIR = join33(process.cwd(), ".assist", "transcript");
 function processStagedFile() {
   if (!existsSync35(STAGING_DIR)) {
     return false;
@@ -10032,7 +10379,7 @@ function processStagedFile() {
   }
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
   const stagedFile = stagedFiles[0];
-  const content = readFileSync27(stagedFile.absolutePath, "utf-8");
+  const content = readFileSync28(stagedFile.absolutePath, "utf-8");
   validateStagedContent(stagedFile.filename, content);
   const stagedBaseName = getTranscriptBaseName(stagedFile.filename);
   const transcriptFiles = findMdFilesRecursive(transcriptsDir);
@@ -10045,12 +10392,12 @@ function processStagedFile() {
     );
     process.exit(1);
   }
-  const destPath = join30(summaryDir, matchingTranscript.relativePath);
+  const destPath = join33(summaryDir, matchingTranscript.relativePath);
   const destDir = dirname20(destPath);
   if (!existsSync35(destDir)) {
-    mkdirSync8(destDir, { recursive: true });
+    mkdirSync9(destDir, { recursive: true });
   }
-  renameSync2(stagedFile.absolutePath, destPath);
+  renameSync3(stagedFile.absolutePath, destPath);
   const remaining = findMdFilesRecursive(STAGING_DIR);
   if (remaining.length === 0) {
     rmSync(STAGING_DIR, { recursive: true });
@@ -10061,7 +10408,7 @@ function processStagedFile() {
 // src/commands/transcript/summarise/index.ts
 function buildRelativeKey(relativePath, baseName) {
   const relDir = dirname21(relativePath);
-  return relDir === "." ? baseName : join31(relDir, baseName);
+  return relDir === "." ? baseName : join34(relDir, baseName);
 }
 function buildSummaryIndex(summaryDir) {
   const summaryFiles = findMdFilesRecursive(summaryDir);
@@ -10095,8 +10442,8 @@ function summarise2() {
   }
   const next3 = missing[0];
   const outputFilename = `${getTranscriptBaseName(next3.filename)}.md`;
-  const outputPath = join31(STAGING_DIR, outputFilename);
-  const summaryFileDir = join31(summaryDir, dirname21(next3.relativePath));
+  const outputPath = join34(STAGING_DIR, outputFilename);
+  const summaryFileDir = join34(summaryDir, dirname21(next3.relativePath));
   const relativeTranscriptPath = encodeURI(
     relative2(summaryFileDir, next3.absolutePath).replace(/\\/g, "/")
   );
@@ -10142,50 +10489,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { join as join33 } from "path";
+import { join as join36 } from "path";
 
 // src/commands/voice/shared.ts
 import { homedir as homedir7 } from "os";
-import { dirname as dirname22, join as join32 } from "path";
+import { dirname as dirname22, join as join35 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var __dirname6 = dirname22(fileURLToPath6(import.meta.url));
-var VOICE_DIR = join32(homedir7(), ".assist", "voice");
+var VOICE_DIR = join35(homedir7(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join32(VOICE_DIR, "voice.pid"),
-  log: join32(VOICE_DIR, "voice.log"),
-  venv: join32(VOICE_DIR, ".venv"),
-  lock: join32(VOICE_DIR, "voice.lock")
+  pid: join35(VOICE_DIR, "voice.pid"),
+  log: join35(VOICE_DIR, "voice.log"),
+  venv: join35(VOICE_DIR, ".venv"),
+  lock: join35(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join32(__dirname6, "commands", "voice", "python");
+  return join35(__dirname6, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join32(voicePaths.venv, "Scripts", "python.exe") : join32(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join35(voicePaths.venv, "Scripts", "python.exe") : join35(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join32(getLockDir(), "voice.lock");
+  return join35(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join33(getPythonDir(), "list_devices.py");
+  const script = join36(getPythonDir(), "list_devices.py");
   spawnSync3(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync37, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync29 } from "fs";
 function logs(options2) {
   if (!existsSync37(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync28(voicePaths.log, "utf-8").trim();
+  const content = readFileSync29(voicePaths.log, "utf-8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -10207,13 +10554,13 @@ function logs(options2) {
 
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join35 } from "path";
+import { mkdirSync as mkdirSync11 } from "fs";
+import { join as join38 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync37 } from "child_process";
-import { existsSync as existsSync38, mkdirSync as mkdirSync9, readFileSync as readFileSync29, writeFileSync as writeFileSync25 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync38, mkdirSync as mkdirSync10, readFileSync as readFileSync30, writeFileSync as writeFileSync25 } from "fs";
+import { join as join37 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -10226,7 +10573,7 @@ function checkLockFile() {
   const lockFile = getLockFile();
   if (!existsSync38(lockFile)) return;
   try {
-    const lock = JSON.parse(readFileSync29(lockFile, "utf-8"));
+    const lock = JSON.parse(readFileSync30(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`
@@ -10250,7 +10597,7 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync9(join34(lockFile, ".."), { recursive: true });
+  mkdirSync10(join37(lockFile, ".."), { recursive: true });
   writeFileSync25(
     lockFile,
     JSON.stringify({
@@ -10263,10 +10610,10 @@ function writeLockFile(pid) {
 
 // src/commands/voice/setup.ts
 function setup() {
-  mkdirSync10(voicePaths.dir, { recursive: true });
+  mkdirSync11(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join35(getPythonDir(), "setup_models.py");
+  const script = join38(getPythonDir(), "setup_models.py");
   const result = spawnSync4(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -10279,8 +10626,8 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn5 } from "child_process";
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync26 } from "fs";
-import { join as join36 } from "path";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync26 } from "fs";
+import { join as join39 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -10313,12 +10660,12 @@ function spawnBackground(python, script, env) {
   console.log(`Voice daemon started (PID ${pid})`);
 }
 function start2(options2) {
-  mkdirSync11(voicePaths.dir, { recursive: true });
+  mkdirSync12(voicePaths.dir, { recursive: true });
   checkLockFile();
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join36(getPythonDir(), "voice_daemon.py");
+  const script = join39(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -10328,7 +10675,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync39, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync31 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -10339,7 +10686,7 @@ function isProcessAlive3(pid) {
 }
 function readRecentLogs(count) {
   if (!existsSync39(voicePaths.log)) return [];
-  const lines = readFileSync30(voicePaths.log, "utf-8").trim().split("\n");
+  const lines = readFileSync31(voicePaths.log, "utf-8").trim().split("\n");
   return lines.slice(-count);
 }
 function status() {
@@ -10347,7 +10694,7 @@ function status() {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync30(voicePaths.pid, "utf-8").trim(), 10);
+  const pid = Number.parseInt(readFileSync31(voicePaths.pid, "utf-8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -10366,13 +10713,13 @@ function status() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync40, readFileSync as readFileSync31, unlinkSync as unlinkSync10 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync32, unlinkSync as unlinkSync10 } from "fs";
 function stop() {
   if (!existsSync40(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync31(voicePaths.pid, "utf-8").trim(), 10);
+  const pid = Number.parseInt(readFileSync32(voicePaths.pid, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -10606,15 +10953,15 @@ async function auth() {
 }
 
 // src/commands/roam/showClaudeCodeIcon.ts
-import { readFileSync as readFileSync32 } from "fs";
-import { join as join37 } from "path";
+import { readFileSync as readFileSync33 } from "fs";
+import { join as join40 } from "path";
 async function showClaudeCodeIcon() {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = join37(appData, "Roam", "roam-local-api.port");
+  const portFile = join40(appData, "Roam", "roam-local-api.port");
   let port;
   try {
-    port = readFileSync32(portFile, "utf-8").trim();
+    port = readFileSync33(portFile, "utf-8").trim();
   } catch {
     return;
   }
@@ -10685,8 +11032,8 @@ Done in ${elapsed}`);
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync27 } from "fs";
-import { join as join38 } from "path";
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync27 } from "fs";
+import { join as join41 } from "path";
 function findAddIndex() {
   const addIndex = process.argv.indexOf("add");
   if (addIndex === -1 || addIndex + 2 >= process.argv.length) return -1;
@@ -10732,15 +11079,15 @@ function saveNewRunConfig(name, command, args) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join38(".claude", "commands");
-  mkdirSync12(dir, { recursive: true });
+  const dir = join41(".claude", "commands");
+  mkdirSync13(dir, { recursive: true });
   const content = `---
 description: Run ${name}
 ---
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join38(dir, `${name}.md`);
+  const filePath = join41(dir, `${name}.md`);
   writeFileSync27(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
@@ -10811,9 +11158,9 @@ function run3(name, args) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync40 } from "child_process";
-import { existsSync as existsSync41, mkdirSync as mkdirSync13, unlinkSync as unlinkSync11, writeFileSync as writeFileSync28 } from "fs";
+import { existsSync as existsSync41, mkdirSync as mkdirSync14, unlinkSync as unlinkSync11, writeFileSync as writeFileSync28 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join39, resolve as resolve5 } from "path";
+import { join as join42, resolve as resolve5 } from "path";
 import chalk120 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -10944,13 +11291,13 @@ Write-Output $OutputPath
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
   if (!existsSync41(outputDir)) {
-    mkdirSync13(outputDir, { recursive: true });
+    mkdirSync14(outputDir, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve5(outputDir, `${processName}-${timestamp}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join39(tmpdir6(), `assist-screenshot-${Date.now()}.ps1`);
+  const scriptPath = join42(tmpdir6(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync28(scriptPath, captureWindowPs1, "utf-8");
   try {
     execSync40(