@staff0rd/assist 0.652.0 → 0.654.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.652.0",
+  version: "0.654.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -674,6 +674,7 @@ var assistConfigShape = {
     slack: z3.string().optional(),
     required: z3.boolean().default(false),
     promptJira: z3.boolean().default(false),
+    promptGithub: z3.boolean().default(false),
     draft: z3.boolean().default(false),
     readingWordsPerMinute: z3.number().int().positive().optional()
   }).optional(),
@@ -3126,6 +3127,11 @@ var prsRaiseConfigHelp = [
     setter: "assist config set prs.promptJira true",
     note: "'assist prs raise' help asks the user for a Jira key to --resolves (default false)"
   },
+  {
+    key: "prs.promptGithub",
+    setter: "assist config set prs.promptGithub true",
+    note: "'assist prs raise' help asks the user for a GitHub issue to --resolves (default false)"
+  },
   {
     key: "prs.draft",
     setter: "assist config set prs.draft true",
@@ -5081,9 +5087,148 @@ function registerActivity(program2) {
   ).action(activity);
 }
 
+// src/commands/advise/adviceContextFor.ts
+function adviceContextFor(cwd) {
+  return {
+    config: loadConfigFrom(cwd),
+    rootDir: findConfigUp(cwd)?.rootDir ?? cwd
+  };
+}
+
+// src/commands/advise/loadAdviceFragments.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync14 } from "fs";
+import { basename as basename4, join as join13 } from "path";
+
+// src/commands/advise/adviceDir.ts
+import { existsSync as existsSync18 } from "fs";
+import { dirname as dirname13, join as join12 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function adviceDir() {
+  let current = dirname13(fileURLToPath3(import.meta.url));
+  while (current !== dirname13(current)) {
+    const candidate = join12(current, "claude", "advice");
+    if (existsSync18(candidate)) return candidate;
+    current = dirname13(current);
+  }
+  throw new Error("Could not locate the shipped claude/advice directory");
+}
+
+// src/commands/advise/parseAdviceFragment.ts
+import { parse as parseYaml2 } from "yaml";
+var frontmatter = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function parseAdviceFragment(name, content) {
+  const match = frontmatter.exec(content);
+  if (!match) throw new Error(`Advice fragment ${name} has no frontmatter`);
+  const meta = parseYaml2(match[1]) ?? {};
+  const title = meta.title;
+  const when = meta.when;
+  if (typeof title !== "string" || typeof when !== "string")
+    throw new Error(
+      `Advice fragment ${name} needs a title and a when condition`
+    );
+  return {
+    name,
+    title,
+    when,
+    body: content.slice(match[0].length).trim()
+  };
+}
+
+// src/commands/advise/loadAdviceFragments.ts
+function loadAdviceFragments(dir = adviceDir()) {
+  return readdirSync2(dir).filter((file) => file.endsWith(".md")).sort().map(
+    (file) => parseAdviceFragment(
+      basename4(file, ".md"),
+      readFileSync14(join13(dir, file), "utf8")
+    )
+  );
+}
+
+// src/commands/advise/adviceConditions.ts
+var adviceConditions = {
+  always: {
+    whenMet: "always included",
+    whenUnmet: "always included",
+    matches: () => true
+  },
+  jira: {
+    whenMet: "jira is configured",
+    whenUnmet: "jira is not configured",
+    matches: ({ config }) => config.jira !== void 0
+  }
+};
+
+// src/commands/advise/selectAdvice.ts
+function selectAdvice(fragments, context) {
+  return fragments.map((fragment) => {
+    const condition = adviceConditions[fragment.when];
+    if (!condition)
+      return {
+        fragment,
+        included: false,
+        reason: `unknown condition "${fragment.when}"`
+      };
+    const included = condition.matches(context);
+    return {
+      fragment,
+      included,
+      reason: included ? condition.whenMet : condition.whenUnmet
+    };
+  });
+}
+
+// src/commands/advise/composeAdvice.ts
+var heading = "# Instructions for this repo (composed by assist)";
+function composeAdvice(context, fragments = loadAdviceFragments()) {
+  const sections = selectAdvice(fragments, context).filter((decision) => decision.included).map(({ fragment }) => `## ${fragment.title}
+
+${fragment.body}`);
+  if (sections.length === 0) return "";
+  return [heading, ...sections].join("\n\n");
+}
+
+// src/commands/advise/advise.ts
+async function hookCwd(options2) {
+  const read3 = options2.stdin ?? (process.stdin.isTTY ? void 0 : readStdin);
+  if (!read3) return void 0;
+  try {
+    const raw = await read3();
+    if (!raw.trim()) return void 0;
+    return JSON.parse(raw).cwd;
+  } catch {
+    return void 0;
+  }
+}
+async function advise(options2 = {}) {
+  const fallback = options2.cwdFallback ?? process.cwd();
+  const cwd = options2.hook ? await hookCwd(options2) ?? fallback : fallback;
+  const markdown = composeAdvice(adviceContextFor(cwd));
+  if (!markdown) return "";
+  const output = options2.hook ? JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: markdown
+    }
+  }) : markdown;
+  console.log(output);
+  return output;
+}
+
+// src/commands/registerAdvise.ts
+function registerAdvise(program2) {
+  program2.command("advise").description(
+    "Print the advice fragments that apply to this repo, composed from config and repo facts"
+  ).option(
+    "--hook",
+    "emit the advice as SessionStart hook JSON (additionalContext)"
+  ).action(async (options2) => {
+    await advise({ hook: options2.hook });
+  });
+}
+
 // src/commands/registerBackup.ts
 import { mkdir as mkdir2, stat } from "fs/promises";
-import { join as join13, resolve as resolve7 } from "path";
+import { join as join15, resolve as resolve7 } from "path";
 import chalk31 from "chalk";
 
 // src/shared/db/getDb.ts
@@ -5717,7 +5862,7 @@ function expandTilde2(value) {
 
 // src/commands/backup/scheduleBackup.ts
 import { mkdir } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
 import chalk29 from "chalk";
 
 // src/commands/backup/readCrontab.ts
@@ -5859,7 +6004,7 @@ async function scheduleBackup({
     const cronExpr = durationToCron(every);
     const dir = expandTilde2(loadConfig().backup.dir);
     await mkdir(dir, { recursive: true });
-    const logPath2 = join12(dir, "cron.log");
+    const logPath2 = join14(dir, "cron.log");
     const cronLine = `${cronExpr} ${resolveAssistCommand()} backup >> ${logPath2} 2>&1`;
     writeCrontab(upsertScheduleBlock(readCrontab(), every, cronLine));
     console.error(
@@ -6038,7 +6183,7 @@ async function backup({ out }) {
   await mkdir2(dir, { recursive: true });
   const start3 = Date.now();
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const filePath = resolve7(join13(dir, `backup-${timestamp6}.dump`));
+  const filePath = resolve7(join15(dir, `backup-${timestamp6}.dump`));
   await exportBacklog(filePath);
   const { size } = await stat(filePath);
   const durationMs = Date.now() - start3;
@@ -6139,19 +6284,19 @@ function parseItemId(input) {
 
 // src/commands/backlog/acquireLock.ts
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync14
 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 function getLocksDir() {
-  return join14(homedir5(), ".assist", "locks");
+  return join16(homedir5(), ".assist", "locks");
 }
 function getLockPath(itemId2) {
-  return join14(getLocksDir(), `lock-${itemId2}.json`);
+  return join16(getLocksDir(), `lock-${itemId2}.json`);
 }
 function isProcessAlive(pid) {
   try {
@@ -6163,9 +6308,9 @@ function isProcessAlive(pid) {
 }
 function foreignLockHolder(itemId2) {
   const lockPath = getLockPath(itemId2);
-  if (!existsSync18(lockPath)) return null;
+  if (!existsSync19(lockPath)) return null;
   try {
-    const lock2 = JSON.parse(readFileSync14(lockPath, "utf8"));
+    const lock2 = JSON.parse(readFileSync15(lockPath, "utf8"));
     if (typeof lock2.pid !== "number" || lock2.pid === process.pid) return null;
     if (!isProcessAlive(lock2.pid)) return null;
     return { pid: lock2.pid, timestamp: lock2.timestamp };
@@ -6276,7 +6421,7 @@ import chalk45 from "chalk";
 
 // src/commands/sessions/daemon/ensureHooksSettings.ts
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 var SET_STATUS = "assist sessions set-status";
 function running(source) {
   return `${SET_STATUS} running --source ${source}`;
@@ -6308,7 +6453,7 @@ var hooksSettings = {
 };
 function ensureHooksSettings() {
   const path91 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname13(path91), { recursive: true });
+  mkdirSync5(dirname14(path91), { recursive: true });
   writeFileSync15(path91, JSON.stringify(hooksSettings, null, 2));
   return path91;
 }
@@ -6363,7 +6508,7 @@ function buildArgs(prompt, options2) {
 
 // src/commands/backlog/ensureStoryBranch.ts
 import { execSync as execSync21 } from "child_process";
-import { basename as basename4 } from "path";
+import { basename as basename5 } from "path";
 
 // src/commands/branch/createBranch.ts
 import { execSync as execSync20 } from "child_process";
@@ -6698,7 +6843,7 @@ function worktreeBranchInPlay() {
   const tree = linkedWorktree(process.cwd());
   if (!tree) return null;
   const head = currentBranch();
-  return head === basename4(tree.root) ? head : null;
+  return head === basename5(tree.root) ? head : null;
 }
 function currentBranch() {
   try {
@@ -6721,19 +6866,19 @@ function message(error) {
 import chalk37 from "chalk";
 
 // src/commands/backlog/migrateLocalBacklog.ts
-import { existsSync as existsSync20 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync21 } from "fs";
+import { join as join18 } from "path";
 import chalk36 from "chalk";
 
 // src/commands/backlog/backupLocalBacklogFiles.ts
-import { existsSync as existsSync19, renameSync } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync20, renameSync } from "fs";
+import { join as join17 } from "path";
 var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path91 = join15(dir, ".assist", name);
-    if (existsSync19(path91)) {
+    const path91 = join17(dir, ".assist", name);
+    if (existsSync20(path91)) {
       renameSync(path91, `${path91}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
@@ -7125,7 +7270,7 @@ async function loadAllItems(orm, origin) {
 }
 
 // src/commands/backlog/parseBacklogJsonl.ts
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 
 // src/commands/backlog/types.ts
 import { z as z4 } from "zod";
@@ -7219,14 +7364,14 @@ var backlogFileSchema = z4.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
 function parseBacklogJsonl(path91) {
-  const content = readFileSync15(path91, "utf8").trim();
+  const content = readFileSync16(path91, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
 
 // src/commands/backlog/migrateLocalBacklog.ts
 function jsonlPath(dir) {
-  return join16(dir, ".assist", "backlog.jsonl");
+  return join18(dir, ".assist", "backlog.jsonl");
 }
 async function verifyImport(orm, origin, items2, imported) {
   const reloaded = await loadAllItems(orm, origin);
@@ -7242,7 +7387,7 @@ async function verifyImport(orm, origin, items2, imported) {
   }
 }
 async function migrateLocalBacklog(orm, dir, origin) {
-  if (!existsSync20(jsonlPath(dir))) return;
+  if (!existsSync21(jsonlPath(dir))) return;
   const existing = (await loadAllItems(orm, origin)).length;
   if (existing > 0) {
     const moved2 = backupLocalBacklogFiles(dir);
@@ -7281,20 +7426,20 @@ async function deleteItem(orm, id) {
 }
 
 // src/commands/backlog/findBacklogUp.ts
-import { existsSync as existsSync21 } from "fs";
-import { dirname as dirname14, join as join17 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { dirname as dirname15, join as join19 } from "path";
 var BACKLOG_MARKERS = [
-  join17(".assist", "backlog.db"),
-  join17(".assist", "backlog.jsonl"),
+  join19(".assist", "backlog.db"),
+  join19(".assist", "backlog.jsonl"),
   "assist.backlog.yml"
 ];
 function findBacklogUp(startDir) {
   let current = startDir;
-  while (current !== dirname14(current)) {
-    if (BACKLOG_MARKERS.some((marker2) => existsSync21(join17(current, marker2)))) {
+  while (current !== dirname15(current)) {
+    if (BACKLOG_MARKERS.some((marker2) => existsSync22(join19(current, marker2)))) {
       return current;
     }
-    current = dirname14(current);
+    current = dirname15(current);
   }
   return null;
 }
@@ -7545,14 +7690,14 @@ function reportDuplicateRun(itemId2, holder) {
 }
 
 // src/commands/backlog/consumePause.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync16 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 function getControlsDir() {
-  return join18(homedir6(), ".assist", "controls");
+  return join20(homedir6(), ".assist", "controls");
 }
 function getPausePath(itemId2) {
-  return join18(getControlsDir(), `pause-${itemId2}.json`);
+  return join20(getControlsDir(), `pause-${itemId2}.json`);
 }
 function requestPause(itemId2) {
   mkdirSync6(getControlsDir(), { recursive: true });
@@ -7562,7 +7707,7 @@ function requestPause(itemId2) {
   );
 }
 function isPausePending(itemId2) {
-  return existsSync22(getPausePath(itemId2));
+  return existsSync23(getPausePath(itemId2));
 }
 function clearPause(itemId2) {
   try {
@@ -7572,7 +7717,7 @@ function clearPause(itemId2) {
 }
 function consumePause(itemId2) {
   const pausePath = getPausePath(itemId2);
-  if (!existsSync22(pausePath)) return false;
+  if (!existsSync23(pausePath)) return false;
   try {
     unlinkSync3(pausePath);
   } catch {
@@ -8003,42 +8148,42 @@ function spawnHarness(harness, prompt, options2 = {}) {
 }
 
 // src/commands/backlog/watchForMarker.ts
-import { existsSync as existsSync25, unwatchFile, watchFile } from "fs";
+import { existsSync as existsSync26, unwatchFile, watchFile } from "fs";
 
 // src/commands/backlog/readSignal.ts
-import { existsSync as existsSync24, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync18 } from "fs";
 
 // src/commands/backlog/writeSignal.ts
 import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync18 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname16, join as join21 } from "path";
+import { dirname as dirname17, join as join23 } from "path";
 import chalk41 from "chalk";
 
 // src/commands/backlog/recordSignalOwner.ts
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   rmSync,
   writeFileSync as writeFileSync17
 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname15, join as join20 } from "path";
+import { dirname as dirname16, join as join22 } from "path";
 function getOwnerPath(itemId2) {
-  return join20(homedir8(), ".assist", "signals", `owner-${itemId2}.json`);
+  return join22(homedir8(), ".assist", "signals", `owner-${itemId2}.json`);
 }
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
   const path91 = getOwnerPath(itemId2);
-  mkdirSync7(dirname15(path91), { recursive: true });
+  mkdirSync7(dirname16(path91), { recursive: true });
   writeFileSync17(path91, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
   const path91 = getOwnerPath(itemId2);
-  if (!existsSync23(path91)) return void 0;
+  if (!existsSync24(path91)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync16(path91, "utf8"));
+    const parsed = JSON.parse(readFileSync17(path91, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
@@ -8055,7 +8200,7 @@ function clearSignalOwner(itemId2) {
 // src/commands/backlog/writeSignal.ts
 function getSignalPath(sessionId = process.env.ASSIST_SESSION_ID) {
   if (!sessionId) return void 0;
-  return join21(homedir9(), ".assist", "signals", `signal-${sessionId}.json`);
+  return join23(homedir9(), ".assist", "signals", `signal-${sessionId}.json`);
 }
 function resolveSignalTarget(event, data) {
   const caller = process.env.ASSIST_SESSION_ID;
@@ -8087,16 +8232,16 @@ function writeSignal(event, data) {
   const path91 = getSignalPath(target);
   if (!path91) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname16(path91), { recursive: true });
+  mkdirSync8(dirname17(path91), { recursive: true });
   writeFileSync18(path91, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
   const path91 = getSignalPath();
-  if (!path91 || !existsSync24(path91)) return void 0;
+  if (!path91 || !existsSync25(path91)) return void 0;
   try {
-    return JSON.parse(readFileSync17(path91, "utf8"));
+    return JSON.parse(readFileSync18(path91, "utf8"));
   } catch {
     return void 0;
   }
@@ -8108,7 +8253,7 @@ function watchForMarker(child, options2) {
   const statusPath = getSignalPath();
   if (!statusPath) return { killedOnMarker: () => killed };
   watchFile(statusPath, { interval: 1e3 }, () => {
-    if (!existsSync25(statusPath)) return;
+    if (!existsSync26(statusPath)) return;
     const signal = readSignal();
     if (!signal) return;
     if (signal.event === "done" && !options2?.actOnDone) return;
@@ -8160,7 +8305,7 @@ function launchPhaseSession(item, phaseNumber, phase, phaseLabel2, claudeSession
 }
 
 // src/commands/backlog/resolvePhaseResult.ts
-import { existsSync as existsSync26, unlinkSync as unlinkSync4 } from "fs";
+import { existsSync as existsSync27, unlinkSync as unlinkSync4 } from "fs";
 import chalk42 from "chalk";
 
 // src/commands/backlog/handleIncompletePhase.ts
@@ -8182,7 +8327,7 @@ async function handleIncompletePhase() {
 // src/commands/backlog/resolvePhaseResult.ts
 function cleanupSignal() {
   const statusPath = getSignalPath();
-  if (statusPath && existsSync26(statusPath)) {
+  if (statusPath && existsSync27(statusPath)) {
     unlinkSync4(statusPath);
   }
 }
@@ -8193,7 +8338,7 @@ async function isTerminalStatus(itemId2) {
 }
 async function resolvePhaseResult(phaseIndex, itemId2) {
   const signalPath = getSignalPath();
-  if (!signalPath || !existsSync26(signalPath)) {
+  if (!signalPath || !existsSync27(signalPath)) {
     if (await isTerminalStatus(itemId2)) return { kind: "abort" };
     const action = await handleIncompletePhase();
     if (action === "abort") return { kind: "abort" };
@@ -8272,9 +8417,9 @@ async function persistPhaseSessionId(itemId2, phaseIdx, claudeSessionId) {
 }
 
 // src/shared/emitActivity.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync18, rmSync as rmSync2, writeFileSync as writeFileSync19 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync19, rmSync as rmSync2, writeFileSync as writeFileSync19 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname17, join as join22 } from "path";
+import { dirname as dirname18, join as join24 } from "path";
 import { z as z5 } from "zod";
 var activitySchema = z5.object({
   kind: z5.enum(["command", "backlog"]),
@@ -8289,18 +8434,18 @@ var activitySchema = z5.object({
   startedAt: z5.number()
 });
 function activityPath(sessionId) {
-  return join22(homedir10(), ".assist", "activity", `activity-${sessionId}.json`);
+  return join24(homedir10(), ".assist", "activity", `activity-${sessionId}.json`);
 }
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
   const path91 = activityPath(sessionId);
-  mkdirSync9(dirname17(path91), { recursive: true });
+  mkdirSync9(dirname18(path91), { recursive: true });
   writeFileSync19(path91, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
 function readActivity(path91) {
   try {
-    return JSON.parse(readFileSync18(path91, "utf8"));
+    return JSON.parse(readFileSync19(path91, "utf8"));
   } catch {
     return void 0;
   }
@@ -8311,7 +8456,7 @@ function reconcileActivity(sessionId, activity2) {
     return;
   }
   const path91 = activityPath(sessionId);
-  mkdirSync9(dirname17(path91), { recursive: true });
+  mkdirSync9(dirname18(path91), { recursive: true });
   writeFileSync19(path91, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
@@ -8370,13 +8515,13 @@ import * as fs16 from "fs";
 import * as path25 from "path";
 
 // src/commands/sessions/shared/codex/codexSessionsDir.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import * as path24 from "path";
 function codexSessionsDir() {
   return path24.join(harnesses.codex.homeDir, "sessions");
 }
 function hasCodexSessions() {
-  return existsSync27(codexSessionsDir());
+  return existsSync28(codexSessionsDir());
 }
 
 // src/commands/sessions/shared/codex/discoverCodexRolloutPaths.ts
@@ -9406,10 +9551,10 @@ import { WebSocketServer } from "ws";
 
 // src/shared/getInstallDir.ts
 import { execSync as execSync24 } from "child_process";
-import { dirname as dirname19, resolve as resolve8 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname3 = dirname19(__filename2);
+import { dirname as dirname20, resolve as resolve8 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __filename2 = fileURLToPath4(import.meta.url);
+var __dirname3 = dirname20(__filename2);
 function getInstallDir() {
   return resolve8(__dirname3, "..");
 }
@@ -9652,7 +9797,7 @@ function originForCwd(cwd) {
 }
 
 // src/commands/sessions/daemon/repoDirExists.ts
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 
 // src/commands/sessions/web/windowsCwdToWslPath.ts
 function windowsCwdToWslPath(cwd) {
@@ -9670,7 +9815,7 @@ function toGitCwd(cwd) {
 
 // src/commands/sessions/daemon/repoDirExists.ts
 function repoDirExists(cwd) {
-  return existsSync28(toGitCwd(cwd));
+  return existsSync29(toGitCwd(cwd));
 }
 
 // src/commands/sessions/daemon/worktree/git.ts
@@ -9767,20 +9912,20 @@ function gitCommonDir(cwd) {
 }
 
 // src/shared/loadJson.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync20 } from "fs";
 import { homedir as homedir12 } from "os";
-import { join as join26 } from "path";
+import { join as join28 } from "path";
 function getStoreDir() {
-  return process.env.ASSIST_STORE_DIR || join26(homedir12(), ".assist");
+  return process.env.ASSIST_STORE_DIR || join28(homedir12(), ".assist");
 }
 function getStorePath(filename) {
-  return join26(getStoreDir(), filename);
+  return join28(getStoreDir(), filename);
 }
 function loadJson(filename) {
   const path91 = getStorePath(filename);
-  if (existsSync29(path91)) {
+  if (existsSync30(path91)) {
     try {
-      return JSON.parse(readFileSync19(path91, "utf8"));
+      return JSON.parse(readFileSync20(path91, "utf8"));
     } catch {
       return {};
     }
@@ -9789,7 +9934,7 @@ function loadJson(filename) {
 }
 function saveJson(filename, data) {
   const dir = getStoreDir();
-  if (!existsSync29(dir)) {
+  if (!existsSync30(dir)) {
     mkdirSync11(dir, { recursive: true });
   }
   writeFileSync20(getStorePath(filename), JSON.stringify(data, null, 2));
@@ -9853,16 +9998,16 @@ function hostedGroup(cwd, origin, clone) {
 
 // src/shared/createBundleHandler.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync20, statSync as statSync3 } from "fs";
-import { dirname as dirname20, join as join27 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { readFileSync as readFileSync21, statSync as statSync3 } from "fs";
+import { dirname as dirname21, join as join29 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 function createBundleHandler(importMetaUrl, bundlePath, contentType = "application/javascript") {
-  const file = join27(dirname20(fileURLToPath4(importMetaUrl)), bundlePath);
+  const file = join29(dirname21(fileURLToPath5(importMetaUrl)), bundlePath);
   let cache5;
   return (req, res) => {
     const mtimeMs = statSync3(file).mtimeMs;
     if (cache5?.mtimeMs !== mtimeMs) {
-      const body = readFileSync20(file, "utf8");
+      const body = readFileSync21(file, "utf8");
       const etag = `"${createHash("sha256").update(body).digest("hex").slice(0, 16)}"`;
       cache5 = { body, etag, mtimeMs };
     }
@@ -9992,15 +10137,15 @@ async function loadItemSummaries(orm, origin) {
 }
 
 // src/commands/backlog/resolveRepoLocation.ts
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 
 // src/commands/backlog/cloneTargetDir.ts
-import { join as join28, resolve as resolve9 } from "path";
+import { join as join30, resolve as resolve9 } from "path";
 function cloneTargetDir(origin, baseDir) {
   if (origin.startsWith("local:")) return null;
   const repoName = origin.split("/").filter(Boolean).pop();
   if (!repoName) return null;
-  return resolve9(join28(baseDir, repoName));
+  return resolve9(join30(baseDir, repoName));
 }
 
 // src/commands/backlog/resolveRepoLocation.ts
@@ -10008,7 +10153,7 @@ function resolveRepoLocation(origin, knownCwd, baseDir) {
   if (knownCwd) return { cwd: knownCwd };
   const target = cloneTargetDir(origin, baseDir);
   if (!target) return {};
-  if (existsSync30(target) && getCurrentOrigin(target) === origin)
+  if (existsSync31(target) && getCurrentOrigin(target) === origin)
     return { cwd: target };
   return { cloneTarget: target };
 }
@@ -10849,7 +10994,7 @@ async function getBackups(_req, res) {
 }
 
 // src/shared/globalConfigTargetFor.ts
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 import { posix as posix2 } from "path";
 
 // src/shared/windowsHomeFromWsl.ts
@@ -10870,7 +11015,7 @@ function globalConfigTargetFor(cwd) {
       ok: false,
       error: `${cwd} runs on the Windows host, whose ~/.assist.yml cannot be located because sessions.windowsProjectsRoot is unset. Set it with: assist config set sessions.windowsProjectsRoot /mnt/c/Users/<you>/.claude/projects`
     };
-  if (!existsSync31(winHome))
+  if (!existsSync32(winHome))
     return {
       ok: false,
       error: `${cwd} runs on the Windows host, whose home ${winHome} is not reachable from here. Check that the Windows drive is mounted and sessions.windowsProjectsRoot points at it.`
@@ -11214,20 +11359,20 @@ function handleServerRuns(req, res) {
 
 // src/commands/sessions/web/getReviewSynthesis.ts
 import { execFile as execFile4 } from "child_process";
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir13 } from "os";
-import { basename as basename10, join as join30 } from "path";
+import { basename as basename11, join as join32 } from "path";
 import { promisify as promisify3 } from "util";
 
 // src/commands/sessions/web/findSynthesisForBranch.ts
-import { existsSync as existsSync32, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
-import { basename as basename9, dirname as dirname21, join as join29 } from "path";
+import { existsSync as existsSync33, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { basename as basename10, dirname as dirname22, join as join31 } from "path";
 function findSynthesisForBranch(repoReviewsDir, branch2) {
-  const branchKeyPath = join29(repoReviewsDir, `${branch2}-`);
-  const parent = dirname21(branchKeyPath);
-  const branchPrefix = basename9(branchKeyPath);
-  if (!existsSync32(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join29(parent, name, "synthesis.md")).filter((path91) => existsSync32(path91)).map((path91) => ({ path: path91, mtime: statSync4(path91).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const branchKeyPath = join31(repoReviewsDir, `${branch2}-`);
+  const parent = dirname22(branchKeyPath);
+  const branchPrefix = basename10(branchKeyPath);
+  if (!existsSync33(parent)) return null;
+  const synthesisFiles = readdirSync3(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join31(parent, name, "synthesis.md")).filter((path91) => existsSync33(path91)).map((path91) => ({ path: path91, mtime: statSync4(path91).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -11245,11 +11390,11 @@ async function resolveSynthesisPath(cwd) {
     runGit2(cwd, ["rev-parse", "--show-toplevel"]),
     runGit2(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])
   ]);
-  const repoReviewsDir = join30(
+  const repoReviewsDir = join32(
     homedir13(),
     ".assist",
     "reviews",
-    basename10(repoRoot2)
+    basename11(repoRoot2)
   );
   return findSynthesisForBranch(repoReviewsDir, branch2);
 }
@@ -11262,7 +11407,7 @@ async function getReviewSynthesis(req, res) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync21(path91, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync22(path91, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -11485,8 +11630,8 @@ function subsequenceScore(text18, query) {
 function scoreFilePath(path91, query) {
   const needle = query.trim().toLowerCase();
   if (!needle) return 0;
-  const basename28 = path91.slice(path91.lastIndexOf("/") + 1);
-  const inBasename = subsequenceScore(basename28, needle);
+  const basename29 = path91.slice(path91.lastIndexOf("/") + 1);
+  const inBasename = subsequenceScore(basename29, needle);
   if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
   return subsequenceScore(path91, needle);
 }
@@ -11658,7 +11803,7 @@ async function listNewsItems(_req, res) {
 import path33 from "path";
 
 // src/commands/rules/readScopedRules.ts
-import { existsSync as existsSync34, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync23 } from "fs";
 import path32 from "path";
 
 // src/commands/rules/rulesSectionRange.ts
@@ -11707,11 +11852,11 @@ function parseRulesSection(content) {
 }
 
 // src/commands/rules/scopeDirectory.ts
-import { existsSync as existsSync33, statSync as statSync5 } from "fs";
+import { existsSync as existsSync34, statSync as statSync5 } from "fs";
 import path31 from "path";
 function scopeDirectory(target) {
   const resolved = path31.resolve(target);
-  return existsSync33(resolved) && statSync5(resolved).isDirectory() ? resolved : path31.dirname(resolved);
+  return existsSync34(resolved) && statSync5(resolved).isDirectory() ? resolved : path31.dirname(resolved);
 }
 
 // src/commands/rules/readScopedRules.ts
@@ -11722,7 +11867,7 @@ function scopedClaudeFiles(target) {
   let current = startDir;
   while (true) {
     const candidate = path32.join(current, "CLAUDE.md");
-    if (existsSync34(candidate)) files.push(candidate);
+    if (existsSync35(candidate)) files.push(candidate);
     if (current === root || current === path32.dirname(current)) break;
     current = path32.dirname(current);
   }
@@ -11730,7 +11875,7 @@ function scopedClaudeFiles(target) {
 }
 function readScopedRules(target) {
   return scopedClaudeFiles(target).flatMap(
-    (source) => parseRulesSection(readFileSync22(source, "utf8")).map((rule) => ({
+    (source) => parseRulesSection(readFileSync23(source, "utf8")).map((rule) => ({
       ...rule,
       source
     }))
@@ -13023,7 +13168,7 @@ function uploadSizeLimit(contentType) {
 // src/commands/sessions/web/writeTempImage.ts
 import { mkdtemp, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir } from "os";
-import { extname, join as join31 } from "path";
+import { extname, join as join33 } from "path";
 var EXT_BY_MIME = {
   "image/png": "png",
   "image/jpeg": "jpg",
@@ -13054,8 +13199,8 @@ function safeBaseName(name) {
   return base.replace(/^-+|-+$/g, "").slice(0, 60) || "screenshot";
 }
 async function writeTempImage(name, contentType, body) {
-  const dir = await mkdtemp(join31(tmpdir(), "assist-pr-img-"));
-  const filePath = join31(
+  const dir = await mkdtemp(join33(tmpdir(), "assist-pr-img-"));
+  const filePath = join33(
     dir,
     `${safeBaseName(name)}.${pickExtension(name, contentType)}`
   );
@@ -13106,17 +13251,17 @@ import { readFile as readFile2, stat as stat3, writeFile as writeFile3 } from "f
 
 // src/commands/sessions/web/formatWithOxfmt.ts
 import { execFile as execFile8 } from "child_process";
-import { existsSync as existsSync35 } from "fs";
-import { dirname as dirname22, join as join32 } from "path";
+import { existsSync as existsSync36 } from "fs";
+import { dirname as dirname23, join as join34 } from "path";
 import { promisify as promisify8 } from "util";
 var execFileAsync7 = promisify8(execFile8);
 var TIMEOUT_MS = 15e3;
 function findOxfmtScript(root) {
   let dir = root;
   for (; ; ) {
-    const candidate = join32(dir, "node_modules", "oxfmt", "bin", "oxfmt");
-    if (existsSync35(candidate)) return candidate;
-    const parent = dirname22(dir);
+    const candidate = join34(dir, "node_modules", "oxfmt", "bin", "oxfmt");
+    if (existsSync36(candidate)) return candidate;
+    const parent = dirname23(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -13186,7 +13331,7 @@ async function writeFileContent(req, res) {
 
 // src/commands/sessions/web/createCssHandler.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync23 } from "fs";
+import { readFileSync as readFileSync24 } from "fs";
 import { createRequire as createRequire2 } from "module";
 var require3 = createRequire2(import.meta.url);
 function createCssHandler(packageEntry) {
@@ -13194,7 +13339,7 @@ function createCssHandler(packageEntry) {
   return (req, res) => {
     if (!cache5) {
       const resolved = require3.resolve(packageEntry);
-      const body = readFileSync23(resolved, "utf8");
+      const body = readFileSync24(resolved, "utf8");
       const etag = `"${createHash2("sha256").update(body).digest("hex").slice(0, 16)}"`;
       cache5 = { body, etag };
     }
@@ -14007,7 +14152,7 @@ function registerAssociateJiraCommand(cmd) {
 
 // src/commands/backlog/cloneRepo.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import { mkdir as mkdir3 } from "fs/promises";
 import chalk69 from "chalk";
 
@@ -14043,7 +14188,7 @@ async function cloneRepo(originRaw) {
   if (!target) {
     return fail2(`Could not derive a repository name from "${origin}".`);
   }
-  if (existsSync37(target)) {
+  if (existsSync38(target)) {
     return fail2(`Clone target already exists: ${target}`);
   }
   await mkdir3(baseDir, { recursive: true });
@@ -14595,9 +14740,9 @@ function ensureRemoteOrigin() {
 
 // src/commands/backlog/add/shared.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync24, unlinkSync as unlinkSync6, writeFileSync as writeFileSync21 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync25, unlinkSync as unlinkSync6, writeFileSync as writeFileSync21 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join36 } from "path";
+import { join as join38 } from "path";
 import enquirer6 from "enquirer";
 async function promptType() {
   const { type } = await enquirer6.prompt({
@@ -14637,15 +14782,15 @@ async function promptDescription() {
 }
 function openEditor() {
   const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-  const dir = mkdtempSync(join36(tmpdir2(), "assist-"));
-  const filePath = join36(dir, "description.md");
+  const dir = mkdtempSync(join38(tmpdir2(), "assist-"));
+  const filePath = join38(dir, "description.md");
   writeFileSync21(filePath, "");
   const result = spawnSync3(editor, [filePath], { stdio: "inherit" });
   if (result.status !== 0) {
     unlinkSync6(filePath);
     return void 0;
   }
-  const content = readFileSync24(filePath, "utf8").trim();
+  const content = readFileSync25(filePath, "utf8").trim();
   unlinkSync6(filePath);
   return content || void 0;
 }
@@ -14821,7 +14966,7 @@ async function list2(options2) {
 import chalk82 from "chalk";
 
 // src/commands/backlog/readJsonPayload.ts
-import { readFileSync as readFileSync25 } from "fs";
+import { readFileSync as readFileSync26 } from "fs";
 import chalk80 from "chalk";
 function fail3(message3) {
   console.error(chalk80.red(message3));
@@ -14833,7 +14978,7 @@ function describe(error) {
 async function readSource(source) {
   try {
     if (source === "-") return (await readStdinBuffer()).toString("utf8");
-    return readFileSync25(source, "utf8");
+    return readFileSync26(source, "utf8");
   } catch (error) {
     return fail3(
       `Cannot read the payload from ${source === "-" ? "stdin" : source}: ${describe(error)}`
@@ -16660,7 +16805,7 @@ function registerBranch(program2) {
 }
 
 // src/commands/cliHook/index.ts
-import { basename as basename12 } from "path";
+import { basename as basename13 } from "path";
 
 // src/shared/splitCompound.ts
 import { parse } from "shell-quote";
@@ -17226,17 +17371,17 @@ function extractGraphqlQuery(args) {
 }
 
 // src/shared/loadCliReads.ts
-import { existsSync as existsSync38, readFileSync as readFileSync26, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname23, resolve as resolve12 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
-var __filename3 = fileURLToPath5(import.meta.url);
-var __dirname4 = dirname23(__filename3);
+import { existsSync as existsSync39, readFileSync as readFileSync27, writeFileSync as writeFileSync22 } from "fs";
+import { dirname as dirname24, resolve as resolve12 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+var __filename3 = fileURLToPath6(import.meta.url);
+var __dirname4 = dirname24(__filename3);
 function packageRoot() {
   return __dirname4;
 }
 function readLines(path91) {
-  if (!existsSync38(path91)) return [];
-  return readFileSync26(path91, "utf8").split("\n").filter((line) => line.trim() !== "");
+  if (!existsSync39(path91)) return [];
+  return readFileSync27(path91, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -17282,14 +17427,14 @@ function findCliWrite(command) {
 }
 
 // src/shared/readSettingsPerms.ts
-import { existsSync as existsSync39, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync28 } from "fs";
 import { homedir as homedir15 } from "os";
-import { join as join37 } from "path";
+import { join as join39 } from "path";
 function readSettingsPerms(key) {
   const paths = [
-    join37(homedir15(), ".claude", "settings.json"),
-    join37(process.cwd(), ".claude", "settings.json"),
-    join37(process.cwd(), ".claude", "settings.local.json")
+    join39(homedir15(), ".claude", "settings.json"),
+    join39(process.cwd(), ".claude", "settings.json"),
+    join39(process.cwd(), ".claude", "settings.local.json")
   ];
   const entries = [];
   for (const p of paths) {
@@ -17298,9 +17443,9 @@ function readSettingsPerms(key) {
   return entries;
 }
 function readPermissionArray(filePath, key) {
-  if (!existsSync39(filePath)) return [];
+  if (!existsSync40(filePath)) return [];
   try {
-    const data = JSON.parse(readFileSync27(filePath, "utf8"));
+    const data = JSON.parse(readFileSync28(filePath, "utf8"));
     const arr = data?.permissions?.[key];
     return Array.isArray(arr) ? arr.filter((e) => typeof e === "string") : [];
   } catch {
@@ -17505,11 +17650,11 @@ function decideCommand(toolName, rawCommand) {
 // src/commands/cliHook/logDeniedToolCall.ts
 import { mkdirSync as mkdirSync12 } from "fs";
 import { homedir as homedir16 } from "os";
-import { join as join38 } from "path";
+import { join as join40 } from "path";
 import Database from "better-sqlite3";
 var _db;
 function getDbDir() {
-  return join38(homedir16(), ".assist");
+  return join40(homedir16(), ".assist");
 }
 function initSchema(db) {
   db.exec(`
@@ -17528,7 +17673,7 @@ function openPromptsDb(dir) {
   if (_db) return _db;
   const dbDir = dir ?? getDbDir();
   mkdirSync12(dbDir, { recursive: true });
-  const db = new Database(join38(dbDir, "assist.db"));
+  const db = new Database(join40(dbDir, "assist.db"));
   db.pragma("journal_mode = WAL");
   initSchema(db);
   _db = db;
@@ -17599,7 +17744,7 @@ async function cliHook() {
       logDeniedToolCall({
         tool: input.toolName,
         command: input.command,
-        repo: basename12(process.cwd()),
+        repo: basename13(process.cwd()),
         sessionId: process.env.CLAUDE_SESSION_ID,
         denyReason: decision.permissionDecisionReason
       });
@@ -17647,9 +17792,9 @@ ${reasons.join("\n")}`);
 }
 
 // src/commands/permitCliReads/index.ts
-import { existsSync as existsSync40, mkdirSync as mkdirSync13, readFileSync as readFileSync28, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync41, mkdirSync as mkdirSync13, readFileSync as readFileSync29, writeFileSync as writeFileSync23 } from "fs";
 import { homedir as homedir17 } from "os";
-import { join as join39 } from "path";
+import { join as join41 } from "path";
 
 // src/commands/permitCliReads/assertCliExists.ts
 function assertCliExists(cli) {
@@ -17912,15 +18057,15 @@ function updateSettings(cli, commands) {
 // src/commands/permitCliReads/index.ts
 function logPath(cli) {
   const safeName = cli.replace(/\s+/g, "-");
-  return join39(homedir17(), ".assist", `cli-discover-${safeName}.log`);
+  return join41(homedir17(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
   const path91 = logPath(cli);
-  if (!existsSync40(path91)) return void 0;
-  return readFileSync28(path91, "utf8");
+  if (!existsSync41(path91)) return void 0;
+  return readFileSync29(path91, "utf8");
 }
 function writeCache(cli, output) {
-  const dir = join39(homedir17(), ".assist");
+  const dir = join41(homedir17(), ".assist");
   mkdirSync13(dir, { recursive: true });
   writeFileSync23(logPath(cli), output);
 }
@@ -18051,33 +18196,33 @@ function registerCliHook(program2) {
 }
 
 // src/commands/codeComment/codeCommentConfirm.ts
-import { existsSync as existsSync42, readFileSync as readFileSync30, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync31, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
 import chalk121 from "chalk";
 
 // src/commands/codeComment/getRestrictedDir.ts
 import { homedir as homedir18 } from "os";
-import { join as join40 } from "path";
+import { join as join42 } from "path";
 function getRestrictedDir() {
-  return join40(homedir18(), ".assist", "restricted");
+  return join42(homedir18(), ".assist", "restricted");
 }
 function getPinStatePath(pin) {
-  return join40(getRestrictedDir(), `code-comment-${pin}.json`);
+  return join42(getRestrictedDir(), `code-comment-${pin}.json`);
 }
 
 // src/commands/codeComment/sweepRestrictedDir.ts
-import { readdirSync as readdirSync5, statSync as statSync7, unlinkSync as unlinkSync7 } from "fs";
-import { join as join41 } from "path";
+import { readdirSync as readdirSync6, statSync as statSync7, unlinkSync as unlinkSync7 } from "fs";
+import { join as join43 } from "path";
 var STALE_AFTER_MS = 30 * 60 * 1e3;
 function sweepRestrictedDir(dir = getRestrictedDir()) {
   let entries;
   try {
-    entries = readdirSync5(dir);
+    entries = readdirSync6(dir);
   } catch {
     return;
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path91 = join41(dir, entry);
+    const path91 = join43(dir, entry);
     try {
       if (statSync7(path91).mtimeMs < cutoff) unlinkSync7(path91);
     } catch {
@@ -18087,12 +18232,12 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 }
 
 // src/commands/codeComment/readPinState.ts
-import { existsSync as existsSync41, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync30 } from "fs";
 function readPinState(pin) {
   const path91 = getPinStatePath(pin);
-  if (!existsSync41(path91)) return void 0;
+  if (!existsSync42(path91)) return void 0;
   try {
-    const state = JSON.parse(readFileSync29(path91, "utf8"));
+    const state = JSON.parse(readFileSync30(path91, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -18109,12 +18254,12 @@ function codeCommentConfirm(pin) {
     process.exitCode = 1;
     return;
   }
-  if (!existsSync42(state.file)) {
+  if (!existsSync43(state.file)) {
     console.error(chalk121.red(`Target file no longer exists: ${state.file}`));
     process.exitCode = 1;
     return;
   }
-  const original = readFileSync30(state.file, "utf8");
+  const original = readFileSync31(state.file, "utf8");
   const lines2 = original.split("\n");
   const index3 = state.line - 1;
   if (index3 > lines2.length) {
@@ -18431,9 +18576,9 @@ function findUnmergedPaths() {
 }
 
 // src/commands/commit/abortOnConflicts.ts
-function abort(headline2, guidance2) {
+function abort(headline2, guidance) {
   console.error(`Error: refusing to commit \u2014 ${headline2}`);
-  console.error(guidance2);
+  console.error(guidance);
   console.error("Nothing was committed or pushed.");
   process.exit(1);
 }
@@ -19619,19 +19764,19 @@ import { cp } from "fs/promises";
 import chalk139 from "chalk";
 
 // src/commands/criteriaExtension/criteriaExtensionDir.ts
-import { existsSync as existsSync43 } from "fs";
-import { dirname as dirname24, join as join42 } from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
-var moduleDir = dirname24(fileURLToPath6(import.meta.url));
+import { existsSync as existsSync44 } from "fs";
+import { dirname as dirname25, join as join44 } from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
+var moduleDir = dirname25(fileURLToPath7(import.meta.url));
 function criteriaExtensionDir() {
-  const bundled = join42(
+  const bundled = join44(
     moduleDir,
     "commands",
     "criteriaExtension",
     "criteria-extension"
   );
-  if (existsSync43(bundled)) return bundled;
-  return join42(moduleDir, "..", "..", "..", "criteria-extension");
+  if (existsSync44(bundled)) return bundled;
+  return join44(moduleDir, "..", "..", "..", "criteria-extension");
 }
 
 // src/commands/criteriaExtension/criteriaExtension.ts
@@ -19660,28 +19805,28 @@ async function criteriaExtension() {
 // src/commands/criteriaExtension/signCriteriaExtension.ts
 import { rm as rm3 } from "fs/promises";
 import { homedir as homedir19, tmpdir as tmpdir4 } from "os";
-import { join as join47 } from "path";
+import { join as join49 } from "path";
 import chalk141 from "chalk";
 
 // src/commands/criteriaExtension/copySignedXpi.ts
 import { copyFile } from "fs/promises";
-import { join as join43 } from "path";
+import { join as join45 } from "path";
 var SIGNED_XPI_NAME = "criteria-extension.xpi";
 async function copySignedXpi(xpi, dir) {
-  const fixed2 = join43(dir, SIGNED_XPI_NAME);
+  const fixed2 = join45(dir, SIGNED_XPI_NAME);
   if (fixed2 === xpi) return fixed2;
   await copyFile(xpi, fixed2);
   return fixed2;
 }
 
 // src/commands/criteriaExtension/findSignedXpi.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import { readdir } from "fs/promises";
-import { join as join44 } from "path";
+import { join as join46 } from "path";
 async function findSignedXpi(dir) {
-  if (!existsSync44(dir)) return null;
+  if (!existsSync45(dir)) return null;
   const name = (await readdir(dir)).find((entry) => entry.endsWith(".xpi"));
-  return name ? join44(dir, name) : null;
+  return name ? join46(dir, name) : null;
 }
 
 // src/commands/criteriaExtension/signedAddonInstallPath.ts
@@ -19703,11 +19848,11 @@ async function signedAddonInstallPath(xpi) {
 }
 
 // src/commands/criteriaExtension/signPreflightProblem.ts
-import { existsSync as existsSync45 } from "fs";
-import { join as join45 } from "path";
+import { existsSync as existsSync46 } from "fs";
+import { join as join47 } from "path";
 var KEY_URL = "https://addons.mozilla.org/en-US/developers/addon/api/key/";
 function signPreflightProblem(source) {
-  if (!existsSync45(join45(source, "content.js")))
+  if (!existsSync46(join47(source, "content.js")))
     return {
       message: `no content.js in ${source}`,
       hint: "run npm run build to bundle the content script"
@@ -19722,7 +19867,7 @@ function signPreflightProblem(source) {
 
 // src/commands/criteriaExtension/stageCriteriaExtension.ts
 import { cp as cp3, mkdir as mkdir4, readFile as readFile4, rm as rm2, writeFile as writeFile4 } from "fs/promises";
-import { join as join46 } from "path";
+import { join as join48 } from "path";
 
 // src/commands/criteriaExtension/stampManifestVersion.ts
 function stampManifestVersion(manifest, version2) {
@@ -19736,7 +19881,7 @@ async function stageCriteriaExtension(source, staging, version2) {
   await rm2(staging, { recursive: true, force: true });
   await mkdir4(staging, { recursive: true });
   await cp3(source, staging, { recursive: true });
-  const manifest = join46(staging, "manifest.json");
+  const manifest = join48(staging, "manifest.json");
   const stamped = stampManifestVersion(
     await readFile4(manifest, "utf8"),
     version2
@@ -19745,8 +19890,8 @@ async function stageCriteriaExtension(source, staging, version2) {
 }
 
 // src/commands/criteriaExtension/signCriteriaExtension.ts
-var ARTIFACTS_DIR = join47(homedir19(), ".assist", "criteria-extension");
-var STAGING_DIR = join47(tmpdir4(), "assist-criteria-extension");
+var ARTIFACTS_DIR = join49(homedir19(), ".assist", "criteria-extension");
+var STAGING_DIR = join49(tmpdir4(), "assist-criteria-extension");
 async function signCriteriaExtension() {
   const source = criteriaExtensionDir();
   const problem = signPreflightProblem(source);
@@ -19869,21 +20014,21 @@ import { unlinkSync as unlinkSync9, writeFileSync as writeFileSync26 } from "fs"
 import chalk143 from "chalk";
 
 // src/commands/dbMigration/getMigrationPinPath.ts
-import { join as join48 } from "path";
+import { join as join50 } from "path";
 function getMigrationPinPath(pin) {
-  return join48(getRestrictedDir(), `db-migration-pin-${pin}.json`);
+  return join50(getRestrictedDir(), `db-migration-pin-${pin}.json`);
 }
 function getMigrationApprovalPath(migrationId) {
-  return join48(getRestrictedDir(), `db-migration-approval-${migrationId}.json`);
+  return join50(getRestrictedDir(), `db-migration-approval-${migrationId}.json`);
 }
 
 // src/commands/dbMigration/readMigrationPinState.ts
-import { existsSync as existsSync46, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync47, readFileSync as readFileSync32 } from "fs";
 function readMigrationPinState(pin) {
   const path91 = getMigrationPinPath(pin);
-  if (!existsSync46(path91)) return void 0;
+  if (!existsSync47(path91)) return void 0;
   try {
-    const state = JSON.parse(readFileSync31(path91, "utf8"));
+    const state = JSON.parse(readFileSync32(path91, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -19970,7 +20115,7 @@ function registerDbMigration(parent) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync47, readFileSync as readFileSync32, writeFileSync as writeFileSync28 } from "fs";
+import { existsSync as existsSync48, readFileSync as readFileSync33, writeFileSync as writeFileSync28 } from "fs";
 import chalk145 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
@@ -19979,11 +20124,11 @@ var TRAILING_SLASH_SCRIPT = `    <script>
     </script>`;
 function redirect() {
   const indexPath = "index.html";
-  if (!existsSync47(indexPath)) {
+  if (!existsSync48(indexPath)) {
     console.log(chalk145.yellow("No index.html found"));
     return;
   }
-  const content = readFileSync32(indexPath, "utf8");
+  const content = readFileSync33(indexPath, "utf8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
     console.log(chalk145.dim("Trailing slash script already present"));
     return;
@@ -20008,14 +20153,14 @@ function registerDeploy(program2) {
 
 // src/commands/devlog/list/index.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { basename as basename14 } from "path";
+import { basename as basename15 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
 import { homedir as homedir20 } from "os";
-import { join as join49 } from "path";
-var BLOG_REPO_ROOT = join49(homedir20(), "git/blog");
+import { join as join51 } from "path";
+var BLOG_REPO_ROOT = join51(homedir20(), "git/blog");
 function loadBlogSkipDays(repoName) {
-  const config = loadRawYaml(join49(BLOG_REPO_ROOT, "assist.yml"));
+  const config = loadRawYaml(join51(BLOG_REPO_ROOT, "assist.yml"));
   const devlog = config.devlog;
   const skip2 = devlog?.skip;
   return new Set(skip2?.[repoName]);
@@ -20026,17 +20171,17 @@ import { execSync as execSync37 } from "child_process";
 import chalk146 from "chalk";
 
 // src/shared/getRepoName.ts
-import { existsSync as existsSync48, readFileSync as readFileSync33 } from "fs";
-import { basename as basename13, join as join50 } from "path";
+import { existsSync as existsSync49, readFileSync as readFileSync34 } from "fs";
+import { basename as basename14, join as join52 } from "path";
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
     return config.devlog.name;
   }
-  const packageJsonPath = join50(process.cwd(), "package.json");
-  if (existsSync48(packageJsonPath)) {
+  const packageJsonPath = join52(process.cwd(), "package.json");
+  if (existsSync49(packageJsonPath)) {
     try {
-      const content = readFileSync33(packageJsonPath, "utf8");
+      const content = readFileSync34(packageJsonPath, "utf8");
       const pkg = JSON.parse(content);
       if (pkg.name) {
         return pkg.name;
@@ -20044,41 +20189,41 @@ function getRepoName() {
     } catch {
     }
   }
-  return basename13(process.cwd());
+  return basename14(process.cwd());
 }
 
 // src/commands/devlog/loadDevlogEntries.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync34 } from "fs";
-import { join as join51 } from "path";
-var DEVLOG_DIR = join51(BLOG_REPO_ROOT, "src/content/devlog");
+import { readdirSync as readdirSync7, readFileSync as readFileSync35 } from "fs";
+import { join as join53 } from "path";
+var DEVLOG_DIR = join53(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
   const fm = content.match(/^---\n([\s\S]*?)\n---/);
   return fm?.[1] ?? null;
 }
-function matchField(frontmatter, pattern2) {
-  return frontmatter.match(pattern2)?.[1]?.trim() ?? null;
+function matchField(frontmatter2, pattern2) {
+  return frontmatter2.match(pattern2)?.[1]?.trim() ?? null;
 }
 function parseFrontmatter(content, filename) {
-  const frontmatter = extractFrontmatter(content);
-  if (!frontmatter) return null;
-  const date = matchField(frontmatter, /date:\s*"?(\d{4}-\d{2}-\d{2})"?/);
-  const tagsRaw = matchField(frontmatter, /tags:\s*\[([^\]]*)\]/);
+  const frontmatter2 = extractFrontmatter(content);
+  if (!frontmatter2) return null;
+  const date = matchField(frontmatter2, /date:\s*"?(\d{4}-\d{2}-\d{2})"?/);
+  const tagsRaw = matchField(frontmatter2, /tags:\s*\[([^\]]*)\]/);
   if (!date || !tagsRaw) return null;
   const repoTag = tagsRaw.split(",")[0]?.trim();
   if (!repoTag) return null;
   return {
     date,
     repoTag,
-    version: matchField(frontmatter, /version:\s*(.+)/),
-    title: matchField(frontmatter, /title:\s*(.+)/),
+    version: matchField(frontmatter2, /version:\s*(.+)/),
+    title: matchField(frontmatter2, /title:\s*(.+)/),
     filename
   };
 }
 function readDevlogFiles(callback) {
   try {
-    const files = readdirSync6(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
+    const files = readdirSync7(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync34(join51(DEVLOG_DIR, file), "utf8");
+      const content = readFileSync35(join53(DEVLOG_DIR, file), "utf8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -20180,7 +20325,7 @@ function list3(options2) {
   const config = loadConfig();
   const days = options2.days ?? 30;
   const ignore3 = options2.ignore ?? config.devlog?.ignore ?? [];
-  const repoName = basename14(process.cwd());
+  const repoName = basename15(process.cwd());
   const skipDays = loadBlogSkipDays(repoName);
   const devlogEntries = loadDevlogEntries(repoName);
   const args = ["log"];
@@ -20466,11 +20611,11 @@ function repos(options2) {
 
 // src/commands/devlog/skip.ts
 import { writeFileSync as writeFileSync29 } from "fs";
-import { join as join52 } from "path";
+import { join as join54 } from "path";
 import chalk151 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
-  return join52(BLOG_REPO_ROOT, "assist.yml");
+  return join54(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
@@ -20531,20 +20676,20 @@ function registerDevlog(program2) {
 }
 
 // src/commands/dotnet/checkBuildLocks.ts
-import { closeSync as closeSync3, openSync as openSync3, readdirSync as readdirSync7 } from "fs";
-import { join as join53 } from "path";
+import { closeSync as closeSync3, openSync as openSync3, readdirSync as readdirSync8 } from "fs";
+import { join as join55 } from "path";
 import chalk153 from "chalk";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "packages"]);
 function isLockedDll(debugDir) {
   let files;
   try {
-    files = readdirSync7(debugDir, { recursive: true });
+    files = readdirSync8(debugDir, { recursive: true });
   } catch {
     return null;
   }
   for (const file of files) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
-    const dllPath = join53(debugDir, file);
+    const dllPath = join55(debugDir, file);
     try {
       const fd = openSync3(dllPath, "r+");
       closeSync3(fd);
@@ -20557,18 +20702,18 @@ function isLockedDll(debugDir) {
 function findFirstLockedDll(dir) {
   let entries;
   try {
-    entries = readdirSync7(dir);
+    entries = readdirSync8(dir);
   } catch {
     return null;
   }
   if (entries.includes("bin")) {
-    const locked = isLockedDll(join53(dir, "bin", "Debug"));
+    const locked = isLockedDll(join55(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(join53(dir, entry));
+    const found = findFirstLockedDll(join55(dir, entry));
     if (found) return found;
   }
   return null;
@@ -20591,11 +20736,11 @@ async function checkBuildLocksCommand() {
 }
 
 // src/commands/dotnet/buildTree.ts
-import { readFileSync as readFileSync35 } from "fs";
+import { readFileSync as readFileSync36 } from "fs";
 import path41 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
-  const content = readFileSync35(csprojPath, "utf8");
+  const content = readFileSync36(csprojPath, "utf8");
   const refs = [];
   for (const match of content.matchAll(PROJECT_REF_RE)) {
     refs.push(match[1].replace(/\\/g, "/"));
@@ -20612,7 +20757,7 @@ function buildTree(csprojPath, repoRoot2, visited = /* @__PURE__ */ new Set()) {
   for (const ref of getProjectRefs(abs)) {
     const childAbs = path41.resolve(dir, ref);
     try {
-      readFileSync35(childAbs);
+      readFileSync36(childAbs);
       node.children.push(buildTree(childAbs, repoRoot2, visited));
     } catch {
       node.children.push({
@@ -20637,14 +20782,14 @@ function collectAllDeps(node) {
 }
 
 // src/commands/dotnet/findContainingSolutions.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync36, statSync as statSync8 } from "fs";
+import { readdirSync as readdirSync9, readFileSync as readFileSync37, statSync as statSync8 } from "fs";
 import path42 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
   const results = [];
   let entries;
   try {
-    entries = readdirSync8(dir);
+    entries = readdirSync9(dir);
   } catch {
     return results;
   }
@@ -20672,7 +20817,7 @@ function findContainingSolutions(csprojPath, repoRoot2) {
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
   for (const sln of slnFiles) {
     try {
-      const content = readFileSync36(sln, "utf8");
+      const content = readFileSync37(sln, "utf8");
       if (pattern2.test(content)) {
         matches.push(path42.relative(repoRoot2, sln));
       }
@@ -20736,12 +20881,12 @@ function printJson(tree, totalCount, solutions) {
 }
 
 // src/commands/dotnet/resolveCsproj.ts
-import { existsSync as existsSync49 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 import path43 from "path";
 import chalk155 from "chalk";
 function resolveCsproj(csprojPath) {
   const resolved = path43.resolve(csprojPath);
-  if (!existsSync49(resolved)) {
+  if (!existsSync50(resolved)) {
     console.error(chalk155.red(`File not found: ${resolved}`));
     process.exit(1);
   }
@@ -20909,17 +21054,17 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 }
 
 // src/commands/dotnet/resolveSolution.ts
-import { existsSync as existsSync50 } from "fs";
+import { existsSync as existsSync51 } from "fs";
 import path44 from "path";
 import chalk159 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
-import { readdirSync as readdirSync9 } from "fs";
-import { dirname as dirname25, join as join54 } from "path";
+import { readdirSync as readdirSync10 } from "fs";
+import { dirname as dirname26, join as join56 } from "path";
 import chalk158 from "chalk";
 function findSlnInDir(dir) {
   try {
-    return readdirSync9(dir).filter((f) => f.endsWith(".sln")).map((f) => join54(dir, f));
+    return readdirSync10(dir).filter((f) => f.endsWith(".sln")).map((f) => join56(dir, f));
   } catch {
     return [];
   }
@@ -20940,7 +21085,7 @@ function findSolution() {
       process.exit(1);
     }
     if (current === ceiling) break;
-    current = dirname25(current);
+    current = dirname26(current);
   }
   console.error(chalk158.red("No .sln file found between cwd and repo root"));
   process.exit(1);
@@ -20950,7 +21095,7 @@ function findSolution() {
 function resolveSolution(sln) {
   if (sln) {
     const resolved = path44.resolve(sln);
-    if (!existsSync50(resolved)) {
+    if (!existsSync51(resolved)) {
       console.error(chalk159.red(`Solution file not found: ${resolved}`));
       process.exit(1);
     }
@@ -20990,7 +21135,7 @@ function parseInspectReport(json) {
 
 // src/commands/dotnet/runInspectCode.ts
 import { execSync as execSync41 } from "child_process";
-import { existsSync as existsSync51, readFileSync as readFileSync37, unlinkSync as unlinkSync10 } from "fs";
+import { existsSync as existsSync52, readFileSync as readFileSync38, unlinkSync as unlinkSync10 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
 import path45 from "path";
 import chalk160 from "chalk";
@@ -21021,11 +21166,11 @@ function runInspectCode(slnPath, include, swea) {
     console.error(chalk160.red("jb inspectcode failed"));
     process.exit(1);
   }
-  if (!existsSync51(reportPath)) {
+  if (!existsSync52(reportPath)) {
     console.error(chalk160.red("Report file not generated"));
     process.exit(1);
   }
-  const xml = readFileSync37(reportPath, "utf8");
+  const xml = readFileSync38(reportPath, "utf8");
   unlinkSync10(reportPath);
   return xml;
 }
@@ -21310,11 +21455,11 @@ function decideCommentGuard(input, existingContent) {
 }
 
 // src/commands/dbMigration/consumeMigrationApproval.ts
-import { existsSync as existsSync52, unlinkSync as unlinkSync11 } from "fs";
+import { existsSync as existsSync53, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
   const path91 = getMigrationApprovalPath(migrationId);
-  if (!existsSync52(path91)) return false;
+  if (!existsSync53(path91)) return false;
   try {
     unlinkSync11(path91);
     return true;
@@ -21434,7 +21579,7 @@ function aggregateCommitters(authorLists) {
 import { spawnSync as spawnSync4 } from "child_process";
 import { unlinkSync as unlinkSync12, writeFileSync as writeFileSync30 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join55 } from "path";
+import { join as join57 } from "path";
 
 // src/shared/throwOnGraphqlErrors.ts
 function throwOnGraphqlErrors(stdout) {
@@ -21463,7 +21608,7 @@ function buildArgs2(queryFile, vars) {
   return args;
 }
 function runGhGraphql(mutation, vars) {
-  const queryFile = join55(tmpdir6(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join57(tmpdir6(), `gh-query-${Date.now()}.graphql`);
   writeFileSync30(queryFile, mutation);
   try {
     const result = spawnSync4("gh", buildArgs2(queryFile, vars), {
@@ -22845,28 +22990,28 @@ function fetchIssue2(number, repo) {
 }
 
 // src/commands/github/issue/resumeIssueBody.ts
-import { existsSync as existsSync53, readFileSync as readFileSync38 } from "fs";
+import { existsSync as existsSync54, readFileSync as readFileSync39 } from "fs";
 
 // src/commands/github/issue/issueWorkingFile.ts
-import { join as join56 } from "path";
+import { join as join58 } from "path";
 function issueWorkingFile(slug, number) {
   const [owner = "unknown", repo = "unknown"] = slug.split("/");
-  const dir = join56(getStoreDir(), "github-issues", owner, repo);
+  const dir = join58(getStoreDir(), "github-issues", owner, repo);
   return {
     dir,
-    bodyPath: join56(dir, `${number}.md`),
-    metaPath: join56(dir, `${number}.json`)
+    bodyPath: join58(dir, `${number}.md`),
+    metaPath: join58(dir, `${number}.json`)
   };
 }
 
 // src/commands/github/issue/resumeIssueBody.ts
 function resumeIssueBody(slug, number, updatedAt) {
   const { bodyPath, metaPath } = issueWorkingFile(slug, number);
-  if (!existsSync53(bodyPath) || !existsSync53(metaPath)) return void 0;
+  if (!existsSync54(bodyPath) || !existsSync54(metaPath)) return void 0;
   try {
-    const meta = JSON.parse(readFileSync38(metaPath, "utf8"));
+    const meta = JSON.parse(readFileSync39(metaPath, "utf8"));
     if (meta.updatedAt !== updatedAt) return void 0;
-    return readFileSync38(bodyPath, "utf8");
+    return readFileSync39(bodyPath, "utf8");
   } catch {
     return void 0;
   }
@@ -23122,24 +23267,24 @@ async function countPendingHandovers(orm, origin) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 import {
-  existsSync as existsSync54,
-  readdirSync as readdirSync10,
-  readFileSync as readFileSync39,
+  existsSync as existsSync55,
+  readdirSync as readdirSync11,
+  readFileSync as readFileSync40,
   rmSync as rmSync3,
   statSync as statSync9
 } from "fs";
-import { basename as basename15, join as join59 } from "path";
+import { basename as basename16, join as join61 } from "path";
 
 // src/commands/handover/getHandoverPath.ts
-import { join as join57 } from "path";
+import { join as join59 } from "path";
 function getHandoverPath(cwd = process.cwd()) {
-  return join57(cwd, ".assist", "HANDOVER.md");
+  return join59(cwd, ".assist", "HANDOVER.md");
 }
 
 // src/commands/handover/getHandoversDir.ts
-import { join as join58 } from "path";
+import { join as join60 } from "path";
 function getHandoversDir(cwd = process.cwd()) {
-  return join58(cwd, ".assist", "handovers");
+  return join60(cwd, ".assist", "handovers");
 }
 
 // src/commands/handover/parseArchiveTimestamp.ts
@@ -23177,17 +23322,17 @@ function summariseHandoverContent(content) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 function collectMarkdown(dir) {
-  if (!existsSync54(dir)) return [];
+  if (!existsSync55(dir)) return [];
   const out = [];
-  for (const entry of readdirSync10(dir, { withFileTypes: true })) {
-    const full = join59(dir, entry.name);
+  for (const entry of readdirSync11(dir, { withFileTypes: true })) {
+    const full = join61(dir, entry.name);
     if (entry.isDirectory()) out.push(...collectMarkdown(full));
     else if (entry.isFile() && entry.name.endsWith(".md")) out.push(full);
   }
   return out;
 }
 async function migrateFile(orm, origin, file, createdAt) {
-  const content = readFileSync39(file, "utf8");
+  const content = readFileSync40(file, "utf8");
   await saveHandover(orm, {
     origin,
     summary: summariseHandoverContent(content),
@@ -23199,12 +23344,12 @@ async function migrateFile(orm, origin, file, createdAt) {
 async function migrateDiskHandovers(orm, origin, cwd = process.cwd()) {
   let migrated = 0;
   for (const file of collectMarkdown(getHandoversDir(cwd))) {
-    const createdAt = parseArchiveTimestamp(basename15(file)) ?? statSync9(file).mtime;
+    const createdAt = parseArchiveTimestamp(basename16(file)) ?? statSync9(file).mtime;
     await migrateFile(orm, origin, file, createdAt);
     migrated++;
   }
   const handoverPath = getHandoverPath(cwd);
-  if (existsSync54(handoverPath)) {
+  if (existsSync55(handoverPath)) {
     await migrateFile(orm, origin, handoverPath, statSync9(handoverPath).mtime);
     migrated++;
   }
@@ -23561,18 +23706,18 @@ function canonicalTreePath(path91) {
 }
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
-import { existsSync as existsSync55 } from "fs";
-import { basename as basename17, dirname as dirname26 } from "path";
+import { existsSync as existsSync56 } from "fs";
+import { basename as basename18, dirname as dirname27 } from "path";
 
 // src/commands/sessions/daemon/worktree/planAllocation.ts
-import { basename as basename16, join as join60 } from "path";
+import { basename as basename17, join as join62 } from "path";
 function planAllocation(clone, boundTreeRoots2) {
   return boundTreeRoots2.has(clone) ? "spill" : "primary";
 }
 function nextWorktreePath(clone, base, isTaken) {
-  const name = basename16(clone);
+  const name = basename17(clone);
   for (let n = 2; n < 1e3; n++) {
-    const candidate = join60(base, `${name}-${n}`);
+    const candidate = join62(base, `${name}-${n}`);
     if (!isTaken(candidate)) return candidate;
   }
   throw new Error(`no free worktree suffix for ${clone}`);
@@ -23605,10 +23750,10 @@ function cloneHead(clone) {
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
 function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
-  const base = strategy.root ? expandTilde2(strategy.root) : dirname26(clone);
+  const base = strategy.root ? expandTilde2(strategy.root) : dirname27(clone);
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
-  const isTaken = (candidate) => registered.has(candidate) || existsSync55(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename17(candidate));
+  const isTaken = (candidate) => registered.has(candidate) || existsSync56(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename18(candidate));
   const path91 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
   const start3 = worktreeStartPoint(clone, strategy.trunk);
   gitSync(clone, [
@@ -23616,13 +23761,13 @@ function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
     "add",
     start3.track ? "--track" : "--no-track",
     "-b",
-    basename17(path91),
+    basename18(path91),
     path91,
     start3.ref
   ]);
   recordWorktree(path91, clone, getCurrentOrigin(clone));
   daemonLog(
-    start3.track ? `worktree allocated ${path91} (branch ${basename17(path91)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path91} (branch ${basename17(path91)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
+    start3.track ? `worktree allocated ${path91} (branch ${basename18(path91)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path91} (branch ${basename18(path91)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
   );
   return path91;
 }
@@ -23634,7 +23779,7 @@ function keptInTree(cwd, reason4) {
 }
 
 // src/commands/sessions/daemon/worktree/treeDurability.ts
-import { existsSync as existsSync56 } from "fs";
+import { existsSync as existsSync57 } from "fs";
 var treeIsGone = { durable: true, gone: true };
 function treeDurability(state) {
   if (state.dirty) return { durable: false, reason: "uncommitted changes" };
@@ -23665,14 +23810,14 @@ function* durabilityProbes() {
   });
 }
 async function checkDurability(cwd) {
-  if (!existsSync56(cwd)) return treeIsGone;
+  if (!existsSync57(cwd)) return treeIsGone;
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(await gitResult(cwd, step2.value));
   return step2.value;
 }
 function checkDurabilitySync(cwd) {
-  if (!existsSync56(cwd)) return treeIsGone;
+  if (!existsSync57(cwd)) return treeIsGone;
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(gitSyncResult(cwd, step2.value));
@@ -23917,20 +24062,20 @@ function persistedTreeRoots() {
 }
 
 // src/commands/sessions/daemon/worktree/seedWorktree.ts
-import { copyFileSync, existsSync as existsSync58, mkdirSync as mkdirSync17 } from "fs";
-import { dirname as dirname27, join as join62 } from "path";
+import { copyFileSync, existsSync as existsSync59, mkdirSync as mkdirSync17 } from "fs";
+import { dirname as dirname28, join as join64 } from "path";
 
 // src/commands/sessions/daemon/worktree/runInstall.ts
 import { spawn as spawn5 } from "child_process";
 
 // src/commands/sessions/daemon/worktree/resolveInstallCommand.ts
-import { existsSync as existsSync57 } from "fs";
-import { join as join61 } from "path";
+import { existsSync as existsSync58 } from "fs";
+import { join as join63 } from "path";
 function detectInstallCommand(repoRoot2) {
-  if (!existsSync57(join61(repoRoot2, "package.json"))) return null;
-  if (existsSync57(join61(repoRoot2, "pnpm-lock.yaml"))) return "pnpm install";
-  if (existsSync57(join61(repoRoot2, "yarn.lock"))) return "yarn install";
-  if (existsSync57(join61(repoRoot2, "bun.lockb"))) return "bun install";
+  if (!existsSync58(join63(repoRoot2, "package.json"))) return null;
+  if (existsSync58(join63(repoRoot2, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync58(join63(repoRoot2, "yarn.lock"))) return "yarn install";
+  if (existsSync58(join63(repoRoot2, "bun.lockb"))) return "bun install";
   return "npm install";
 }
 function resolveInstallCommand(repoRoot2, install) {
@@ -24042,11 +24187,11 @@ function seedWorktree(worktreePath, clone, onSeeded = () => {
 }
 function copyConfigFiles(worktreePath, clone, copy) {
   for (const rel of copy) {
-    const src = join62(clone, rel);
-    if (!existsSync58(src)) continue;
-    const dest = join62(worktreePath, rel);
+    const src = join64(clone, rel);
+    if (!existsSync59(src)) continue;
+    const dest = join64(worktreePath, rel);
     try {
-      mkdirSync17(dirname27(dest), { recursive: true });
+      mkdirSync17(dirname28(dest), { recursive: true });
       copyFileSync(src, dest);
       daemonLog(`worktree ${worktreePath} seeded ${rel}`);
     } catch (error) {
@@ -24349,13 +24494,13 @@ function registerLitellm(program2) {
 }
 
 // src/commands/mermaid/index.ts
-import { mkdirSync as mkdirSync18, readdirSync as readdirSync11 } from "fs";
+import { mkdirSync as mkdirSync18, readdirSync as readdirSync12 } from "fs";
 import { resolve as resolve16 } from "path";
 import chalk175 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
-import { readFileSync as readFileSync40, writeFileSync as writeFileSync32 } from "fs";
-import { basename as basename18, extname as extname2, resolve as resolve15 } from "path";
+import { readFileSync as readFileSync41, writeFileSync as writeFileSync32 } from "fs";
+import { basename as basename19, extname as extname2, resolve as resolve15 } from "path";
 import chalk174 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
@@ -24380,9 +24525,9 @@ async function renderBlock(krokiUrl, source) {
 
 // src/commands/mermaid/exportFile.ts
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
-  const content = readFileSync40(file, "utf8");
+  const content = readFileSync41(file, "utf8");
   const blocks = extractMermaidBlocks(content);
-  const stem = basename18(file, extname2(file));
+  const stem = basename19(file, extname2(file));
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
@@ -24431,7 +24576,7 @@ async function mermaidExport(file, options2 = {}) {
       process.exit(1);
     }
   }
-  const files = file ? [file] : readdirSync11(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
+  const files = file ? [file] : readdirSync12(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
   if (files.length === 0) {
     console.log(chalk175.gray("No markdown files found in current directory."));
     return;
@@ -24514,7 +24659,7 @@ import { stringify as stringify2 } from "yaml";
 
 // src/commands/miro/writeExtract.ts
 import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync33 } from "fs";
-import { dirname as dirname28 } from "path";
+import { dirname as dirname29 } from "path";
 import { stringify } from "yaml";
 function headerLines(header) {
   const { rect } = header;
@@ -24527,7 +24672,7 @@ function headerLines(header) {
   ];
 }
 function writeExtract(file, header, texts) {
-  mkdirSync19(dirname28(file), { recursive: true });
+  mkdirSync19(dirname29(file), { recursive: true });
   writeFileSync33(file, `${headerLines(header).join("\n")}
 ${stringify(texts)}`);
 }
@@ -24592,14 +24737,14 @@ function applyIgnore(texts, ignore3) {
 }
 
 // src/commands/miro/readIgnoreList.ts
-import { existsSync as existsSync59, readFileSync as readFileSync41 } from "fs";
+import { existsSync as existsSync60, readFileSync as readFileSync42 } from "fs";
 import { parse as parse2 } from "yaml";
 function readIgnoreList(file) {
-  if (!existsSync59(file))
+  if (!existsSync60(file))
     throw new MiroExtractError(
       `No ignore file at ${file}. Write a YAML list of the box texts to drop, or omit --ignore.`
     );
-  const parsed = parse2(readFileSync41(file, "utf8"));
+  const parsed = parse2(readFileSync42(file, "utf8"));
   if (parsed === null || parsed === void 0) return [];
   if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string"))
     throw new MiroExtractError(
@@ -24781,7 +24926,7 @@ async function pickAnchors(sessionId, items2) {
 }
 
 // src/commands/miro/readMiroItems.ts
-import { readFileSync as readFileSync42 } from "fs";
+import { readFileSync as readFileSync43 } from "fs";
 function tryParse(text18) {
   try {
     return JSON.parse(text18);
@@ -24810,7 +24955,7 @@ function parsePages(raw, file) {
   return Array.isArray(parsed) ? parsed.map(toPage) : [toPage(parsed)];
 }
 function readMiroItems(file) {
-  const items2 = parsePages(readFileSync42(file, "utf8"), file).flatMap(
+  const items2 = parsePages(readFileSync43(file, "utf8"), file).flatMap(
     (page) => page.data ?? []
   );
   if (items2.length === 0)
@@ -25000,7 +25145,7 @@ function registerMiro(program2) {
 // src/commands/netcap/netcap.ts
 import { mkdir as mkdir5 } from "fs/promises";
 import { createServer as createServer2 } from "http";
-import { dirname as dirname30 } from "path";
+import { dirname as dirname31 } from "path";
 import chalk179 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
@@ -25079,15 +25224,15 @@ function createNetcapHandler(options2) {
 // src/commands/netcap/prepareExtensionForLoad.ts
 import { cp as cp4, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 import { networkInterfaces } from "os";
-import { join as join64 } from "path";
+import { join as join66 } from "path";
 import chalk178 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname29, join as join63 } from "path";
-import { fileURLToPath as fileURLToPath7 } from "url";
-var moduleDir2 = dirname29(fileURLToPath7(import.meta.url));
+import { dirname as dirname30, join as join65 } from "path";
+import { fileURLToPath as fileURLToPath8 } from "url";
+var moduleDir2 = dirname30(fileURLToPath8(import.meta.url));
 function netcapExtensionDir() {
-  return join63(moduleDir2, "commands", "netcap", "netcap-extension");
+  return join65(moduleDir2, "commands", "netcap", "netcap-extension");
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
@@ -25102,7 +25247,7 @@ function lanIPv4() {
   return void 0;
 }
 async function configureBackground(dir, host, port, filter) {
-  const file = join64(dir, "background.js");
+  const file = join66(dir, "background.js");
   const source = await readFile5(file, "utf8");
   await writeFile5(
     file,
@@ -25142,20 +25287,20 @@ async function prepareExtensionForLoad(port, filter = "") {
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute as isAbsolute4, join as join66, resolve as resolve18 } from "path";
+import { isAbsolute as isAbsolute4, join as join68, resolve as resolve18 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
 import { homedir as homedir21 } from "os";
-import { join as join65 } from "path";
+import { join as join67 } from "path";
 function defaultCapturePath() {
-  return join65(homedir21(), ".assist", "netcap", "capture.jsonl");
+  return join67(homedir21(), ".assist", "netcap", "capture.jsonl");
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
   const dir = isAbsolute4(out) ? out : resolve18(process.cwd(), out);
-  return join66(dir, "capture.jsonl");
+  return join68(dir, "capture.jsonl");
 }
 
 // src/commands/netcap/netcap.ts
@@ -25163,7 +25308,7 @@ async function netcap(options2) {
   const port = Number(options2.port);
   const outPath = resolveNetcapOutPath(options2.out);
   const filter = options2.filter ?? "";
-  await mkdir5(dirname30(outPath), { recursive: true });
+  await mkdir5(dirname31(outPath), { recursive: true });
   const extensionPath = await prepareExtensionForLoad(port, filter);
   let count8 = 0;
   const handler = createNetcapHandler({
@@ -25202,11 +25347,11 @@ netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} t
 
 // src/commands/netcap/netcapExtract.ts
 import { writeFileSync as writeFileSync34 } from "fs";
-import { join as join67 } from "path";
+import { join as join69 } from "path";
 import chalk180 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
-import { readFileSync as readFileSync43 } from "fs";
+import { readFileSync as readFileSync44 } from "fs";
 
 // src/commands/netcap/parseRscRows.ts
 var isRscRef = (v) => typeof v === "string" && /^\$[0-9a-fL@]/.test(v);
@@ -25602,7 +25747,7 @@ function extractVoyagerPosts(body) {
 
 // src/commands/netcap/extractPostsFromCapture.ts
 function captureEntries(captureFile) {
-  const lines2 = readFileSync43(captureFile, "utf8").split("\n").filter(Boolean);
+  const lines2 = readFileSync44(captureFile, "utf8").split("\n").filter(Boolean);
   const entries = [];
   for (const line of lines2) {
     let entry;
@@ -25647,7 +25792,7 @@ function extractPostsFromCapture(captureFile) {
 function netcapExtract(file) {
   const captureFile = file ?? defaultCapturePath();
   const posts = extractPostsFromCapture(captureFile);
-  const outFile = join67(captureFile, "..", "posts.json");
+  const outFile = join69(captureFile, "..", "posts.json");
   writeFileSync34(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
@@ -25967,11 +26112,11 @@ function extractResolves(content) {
 }
 function editPrBody(body, sections) {
   const parsed = parsePrBody(body);
-  const find = (heading) => parsed.find((s) => s.heading.toLowerCase() === heading.toLowerCase());
-  const upsert = (heading, content) => {
-    const existing = find(heading);
+  const find = (heading2) => parsed.find((s) => s.heading.toLowerCase() === heading2.toLowerCase());
+  const upsert = (heading2, content) => {
+    const existing = find(heading2);
     if (existing) existing.content = content;
-    else parsed.push({ heading, content });
+    else parsed.push({ heading: heading2, content });
   };
   if (sections.what !== void 0) upsert("What", sections.what);
   const hasResolves = (sections.resolves?.length ?? 0) > 0;
@@ -26012,10 +26157,10 @@ function splitParagraphs(body) {
     }
   };
   for (const line of body.split("\n")) {
-    const heading = line.match(/^#{1,6}\s+(.*)$/);
-    if (heading) {
+    const heading2 = line.match(/^#{1,6}\s+(.*)$/);
+    if (heading2) {
       flush();
-      section3 = heading[1].trim();
+      section3 = heading2[1].trim();
     } else if (line.trim() === "") {
       flush();
     } else {
@@ -26090,17 +26235,17 @@ import { execSync as execSync46 } from "child_process";
 import { execSync as execSync45 } from "child_process";
 import { unlinkSync as unlinkSync14, writeFileSync as writeFileSync35 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join69 } from "path";
+import { join as join71 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync60, readFileSync as readFileSync44, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync61, readFileSync as readFileSync45, unlinkSync as unlinkSync13 } from "fs";
 import { parse as parse3 } from "yaml";
 
 // src/commands/prs/commentsCachePath.ts
 import { homedir as homedir22 } from "os";
-import { join as join68 } from "path";
+import { join as join70 } from "path";
 function commentsCachePath(org, repo, prNumber) {
-  return join68(
+  return join70(
     homedir22(),
     ".assist",
     "pr-comments",
@@ -26113,15 +26258,15 @@ function commentsCachePath(org, repo, prNumber) {
 // src/commands/prs/loadCommentsCache.ts
 function loadCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (!existsSync60(cachePath)) {
+  if (!existsSync61(cachePath)) {
     return null;
   }
-  const content = readFileSync44(cachePath, "utf8");
+  const content = readFileSync45(cachePath, "utf8");
   return parse3(content);
 }
 function deleteCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (existsSync60(cachePath)) {
+  if (existsSync61(cachePath)) {
     unlinkSync13(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
@@ -26149,7 +26294,7 @@ function replyToComment(org, repo, prNumber, commentId, message3) {
 // src/commands/prs/resolveCommentWithReply.ts
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join69(tmpdir7(), `gh-mutation-${Date.now()}.graphql`);
+  const queryFile = join71(tmpdir7(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync35(queryFile, mutation);
   try {
     execSync45(
@@ -26234,10 +26379,10 @@ function fixed(commentId, sha) {
 import { execSync as execSync47 } from "child_process";
 import { unlinkSync as unlinkSync15, writeFileSync as writeFileSync36 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
-import { join as join70 } from "path";
+import { join as join72 } 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 = join70(tmpdir8(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join72(tmpdir8(), `gh-query-${Date.now()}.graphql`);
   writeFileSync36(queryFile, THREAD_QUERY);
   try {
     const result = execSync47(
@@ -26307,30 +26452,30 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 
 // src/commands/prs/listComments/updateCommentsCache.ts
 import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync37 } from "fs";
-import { dirname as dirname31 } from "path";
+import { dirname as dirname32 } from "path";
 import { stringify as stringify3 } from "yaml";
 
 // src/commands/prs/removeStaleCommentsCaches.ts
-import { readdirSync as readdirSync12, unlinkSync as unlinkSync16 } from "fs";
-import { join as join71 } from "path";
+import { readdirSync as readdirSync13, unlinkSync as unlinkSync16 } from "fs";
+import { join as join73 } from "path";
 var STALE_PATTERN = /^pr-\d+-comments\.yaml$/;
 function removeStaleCommentsCaches(cwd = process.cwd()) {
-  const dir = join71(cwd, ".assist");
+  const dir = join73(cwd, ".assist");
   let entries;
   try {
-    entries = readdirSync12(dir);
+    entries = readdirSync13(dir);
   } catch {
     return;
   }
   for (const entry of entries.filter((e) => STALE_PATTERN.test(e))) {
-    unlinkSync16(join71(dir, entry));
+    unlinkSync16(join73(dir, entry));
   }
 }
 
 // src/commands/prs/listComments/updateCommentsCache.ts
 function writeCommentsCache(org, repo, prNumber, comments3) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  mkdirSync20(dirname31(cachePath), { recursive: true });
+  mkdirSync20(dirname32(cachePath), { recursive: true });
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -27161,8 +27306,22 @@ function registerPrsEdit(prsCommand) {
   ).addHelpText("after", () => editHelpText()).action(edit);
 }
 
-// src/commands/prs/raiseHelpText.ts
-var RESOLVES_WITH_PROMPT = `  --resolves <key>  Jira issue key resolved by this PR; repeatable. Each key's
+// src/commands/prs/resolvesBlurb.ts
+var RESOLVES_BOTH_PROMPT = `  --resolves <ref>  Jira issue key or GitHub issue resolved by this PR;
+                    repeatable. A Jira key is appended inline to ## Why as its
+                    browse URL; a GitHub reference (#123, owner/repo#123, or a
+                    github.com issue URL) is appended as-is so that merging
+                    closes the issue. Unless one is already known from the
+                    session, ask the user whether this PR resolves a Jira or a
+                    GitHub issue and for the key or reference before raising;
+                    omit --resolves only if they say there isn't one.`;
+var RESOLVES_GITHUB_PROMPT = `  --resolves <ref>  GitHub issue resolved by this PR; repeatable. Accepts #123,
+                    owner/repo#123, or a github.com issue URL, appended inline to
+                    ## Why so that merging closes the issue. Unless an issue is
+                    already known from the session, ask the user whether this PR
+                    resolves a GitHub issue and for the reference before raising;
+                    omit --resolves only if they say there isn't one.`;
+var RESOLVES_JIRA_PROMPT = `  --resolves <key>  Jira issue key resolved by this PR; repeatable. Each key's
                     browse URL is appended inline to ## Why. Unless a Jira key is
                     already known from the session, ask the user whether this PR
                     resolves a Jira issue and for the key before raising; omit
@@ -27171,12 +27330,20 @@ var RESOLVES_NO_PROMPT = `  --resolves <key>  Jira issue key resolved by this PR
                     browse URL is appended inline to ## Why. Pass it when a Jira
                     key is known from the session or supplied by the user; omit
                     it otherwise.`;
+function resolvesBlurb(promptJira, promptGithub) {
+  if (promptJira && promptGithub) return RESOLVES_BOTH_PROMPT;
+  if (promptGithub) return RESOLVES_GITHUB_PROMPT;
+  if (promptJira) return RESOLVES_JIRA_PROMPT;
+  return RESOLVES_NO_PROMPT;
+}
+
+// src/commands/prs/raiseGuidance.ts
 var DRAFT_DEFAULT_ON = `This repo has prs.draft set, so a raise creates a draft pull request unless
 --no-draft is passed.`;
 var DRAFT_DEFAULT_OFF = `This repo leaves prs.draft off, so a raise creates a ready-for-review pull
 request unless --draft is passed.`;
-function guidance(promptJira, draft) {
-  const resolves = promptJira ? RESOLVES_WITH_PROMPT : RESOLVES_NO_PROMPT;
+function raiseGuidance(promptJira, promptGithub, draft) {
+  const resolves = resolvesBlurb(promptJira, promptGithub);
   const draftDefault = draft ? DRAFT_DEFAULT_ON : DRAFT_DEFAULT_OFF;
   return `Raise a pull request for the current branch. Use a concise description with no
 headers, and do not reference Claude or any AI assistance in the title or body.
@@ -27223,6 +27390,8 @@ If a pull request already exists for the branch, this command errors \u2014 pass
 --force to fully overwrite its title and body, or use 'assist prs edit' to update
 only individual sections (every other section of the existing body is preserved).`;
 }
+
+// src/commands/prs/raiseHelpText.ts
 var TERMINAL_CONFIRM = `Before running this command, the user must see the full proposed title and body \u2014
 do not assume they can see your reasoning or earlier tool output. Write the
 complete title and body verbatim in your visible reply, then use the
@@ -27243,13 +27412,14 @@ is approved. The reviewer may also drop or paste screenshots or video into the
 pane; on approval these are appended to the PR body under a ## Screenshots section
 automatically (they are discarded on rejection), so you never author that section
 yourself. Just compose the sections and run the command.`;
-function raiseHelpText(promptJira, draft) {
+function raiseHelpText(promptJira, promptGithub, draft) {
   const config = loadConfig().prs;
-  const prompt = promptJira ?? config?.promptJira ?? false;
+  const jira = promptJira ?? config?.promptJira ?? false;
+  const github = promptGithub ?? config?.promptGithub ?? false;
   const draftDefault = draft ?? config?.draft ?? false;
   const confirm = process.env.ASSIST_SESSION === "1" ? WEB_CONFIRM : TERMINAL_CONFIRM;
   return `
-${guidance(prompt, draftDefault)}
+${raiseGuidance(jira, github, draftDefault)}
 
 ${confirm}
 `;
@@ -27288,7 +27458,7 @@ function registerPrsRaise(prsCommand) {
 }
 
 // src/commands/readTime/readTime.ts
-import { readFileSync as readFileSync45 } from "fs";
+import { readFileSync as readFileSync46 } from "fs";
 
 // src/commands/readTime/countReadingWords.ts
 var FENCE_PATTERN = /^\s*(```|~~~)/;
@@ -27449,7 +27619,7 @@ async function loadBody(target) {
 }
 function readDraftFile(path91) {
   try {
-    return readFileSync45(path91, "utf8");
+    return readFileSync46(path91, "utf8");
   } catch {
     console.error(`Error: Could not read \`${path91}\`.`);
     console.error(
@@ -29290,8 +29460,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename28 = path62.basename(file, path62.extname(file));
-    if (basename28 === "index") continue;
+    const basename29 = path62.basename(file, path62.extname(file));
+    if (basename29 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -29715,21 +29885,21 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 
 // src/commands/review/buildReviewPaths.ts
 import { homedir as homedir23 } from "os";
-import { basename as basename19, join as join72 } from "path";
+import { basename as basename20, join as join74 } from "path";
 function buildReviewPaths(repoRoot2, key) {
-  const reviewDir = join72(
+  const reviewDir = join74(
     homedir23(),
     ".assist",
     "reviews",
-    basename19(repoRoot2),
+    basename20(repoRoot2),
     key
   );
   return {
     reviewDir,
-    requestPath: join72(reviewDir, "request.md"),
-    claudePath: join72(reviewDir, "claude.md"),
-    codexPath: join72(reviewDir, "codex.md"),
-    synthesisPath: join72(reviewDir, "synthesis.md")
+    requestPath: join74(reviewDir, "request.md"),
+    claudePath: join74(reviewDir, "claude.md"),
+    codexPath: join74(reviewDir, "codex.md"),
+    synthesisPath: join74(reviewDir, "synthesis.md")
   };
 }
 
@@ -29871,7 +30041,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync46 } from "fs";
+import { readFileSync as readFileSync47 } from "fs";
 
 // src/commands/review/carriedUnanchoredFindings.ts
 function carriedUnanchoredFindings(unanchored) {
@@ -30322,7 +30492,7 @@ async function confirmPost(prNumber, work, options2) {
   return promptConfirm(`Post ${work} to PR #${prNumber}?`, false);
 }
 async function postFindingsToPr(prInfo, synthesisPath, options2) {
-  const markdown = readFileSync46(synthesisPath, "utf8");
+  const markdown = readFileSync47(synthesisPath, "utf8");
   const { inDiff, unanchored } = selectPostableFindings(markdown, prInfo);
   const carried = carriedUnanchoredFindings(unanchored);
   if (inDiff.length === 0 && carried.length === 0) return NOTHING_POSTED;
@@ -30458,10 +30628,10 @@ async function handlePostSynthesis(synthesisPath, prInfo, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync61, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync38 } from "fs";
+import { existsSync as existsSync62, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync38 } from "fs";
 function clearReviewFiles(paths) {
   for (const path91 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync61(path91)) unlinkSync17(path91);
+    if (existsSync62(path91)) unlinkSync17(path91);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -30523,7 +30693,7 @@ import { format } from "util";
 
 // src/commands/review/createReviewLogSink.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync22 } from "fs";
-import { join as join73 } from "path";
+import { join as join75 } from "path";
 
 // src/shared/stripAnsi.ts
 var ANSI = new RegExp(
@@ -30551,7 +30721,7 @@ function createReviewLogSink() {
     },
     attach(reviewDir) {
       mkdirSync22(reviewDir, { recursive: true });
-      logPath2 = join73(reviewDir, LOG_FILE);
+      logPath2 = join75(reviewDir, LOG_FILE);
       const lines2 = [
         "",
         `=== ${(/* @__PURE__ */ new Date()).toISOString()} ===`,
@@ -30765,7 +30935,7 @@ function printReviewerFailures(results) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync63, unlinkSync as unlinkSync19 } from "fs";
+import { existsSync as existsSync64, unlinkSync as unlinkSync19 } from "fs";
 
 // src/commands/review/buildReviewerStdin.ts
 var REVIEW_PROMPT = `You are acting as a reviewer for a proposed code change made by another engineer. The full review request \u2014 branch, base, changed files, and unified diff \u2014 is in the request file whose absolute path is given below.
@@ -31232,7 +31402,7 @@ function buildCodexModelArgs() {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync62, unlinkSync as unlinkSync18 } from "fs";
+import { existsSync as existsSync63, unlinkSync as unlinkSync18 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -31287,7 +31457,7 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner, override.model);
     }
   });
-  if (result.exitCode !== 0 && existsSync62(spec.outputPath)) {
+  if (result.exitCode !== 0 && existsSync63(spec.outputPath)) {
     unlinkSync18(spec.outputPath);
   }
   return finaliseReviewerRun(
@@ -31342,7 +31512,7 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync47 } from "fs";
+import { readFileSync as readFileSync48 } 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.
@@ -31407,7 +31577,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary2(synthesisPath) {
-  const markdown = readFileSync47(synthesisPath, "utf8");
+  const markdown = readFileSync48(synthesisPath, "utf8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -31455,7 +31625,7 @@ async function runAndSynthesise(args) {
     console.error("Both reviewers failed; skipping synthesis.");
     return { ok: false, failures };
   }
-  if (anyFresh && existsSync63(paths.synthesisPath)) {
+  if (anyFresh && existsSync64(paths.synthesisPath)) {
     unlinkSync19(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
@@ -31648,7 +31818,7 @@ function registerReview(program2) {
 }
 
 // src/commands/rules/addRule.ts
-import { existsSync as existsSync66, readFileSync as readFileSync51, writeFileSync as writeFileSync41 } from "fs";
+import { existsSync as existsSync67, readFileSync as readFileSync52, writeFileSync as writeFileSync41 } from "fs";
 import path72 from "path";
 import chalk211 from "chalk";
 
@@ -31673,15 +31843,15 @@ function insertRuleBullet(content, rule) {
 }
 
 // src/commands/rules/nextRuleCode.ts
-import { readFileSync as readFileSync48 } from "fs";
+import { readFileSync as readFileSync49 } from "fs";
 
 // src/commands/rules/findClaudeFiles.ts
-import { readdirSync as readdirSync13 } from "fs";
+import { readdirSync as readdirSync14 } from "fs";
 import path68 from "path";
 var SKIP_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage"]);
 function findClaudeFiles(dir) {
   const results = [];
-  for (const entry of readdirSync13(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync14(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".") || SKIP_DIRECTORIES.has(entry.name))
         continue;
@@ -31697,7 +31867,7 @@ function findClaudeFiles(dir) {
 var CODE_PREFIX = "R";
 function nextRuleCode(root) {
   const numbers = findClaudeFiles(root).flatMap(
-    (file) => parseRulesSection(readFileSync48(file, "utf8")).map(
+    (file) => parseRulesSection(readFileSync49(file, "utf8")).map(
       (rule) => Number(/(\d+)\s*$/.exec(rule.code)?.[1] ?? 0)
     )
   );
@@ -31705,7 +31875,7 @@ function nextRuleCode(root) {
 }
 
 // src/commands/rules/resolveRuleScope.ts
-import { existsSync as existsSync64 } from "fs";
+import { existsSync as existsSync65 } from "fs";
 import path69 from "path";
 function resolveRuleScope(target) {
   const resolved = path69.resolve(target);
@@ -31715,7 +31885,7 @@ function resolveRuleScope(target) {
   let current = startDir;
   while (true) {
     const candidate = path69.join(current, "CLAUDE.md");
-    if (existsSync64(candidate)) return candidate;
+    if (existsSync65(candidate)) return candidate;
     if (current === root || current === path69.dirname(current)) break;
     current = path69.dirname(current);
   }
@@ -31723,15 +31893,15 @@ function resolveRuleScope(target) {
 }
 
 // src/commands/rules/updateScopedRulesIndex.ts
-import { existsSync as existsSync65, readFileSync as readFileSync50, writeFileSync as writeFileSync40 } from "fs";
+import { existsSync as existsSync66, readFileSync as readFileSync51, writeFileSync as writeFileSync40 } from "fs";
 import path71 from "path";
 
 // src/commands/rules/scopedRuleDirectories.ts
-import { readFileSync as readFileSync49 } from "fs";
+import { readFileSync as readFileSync50 } from "fs";
 import path70 from "path";
 function scopedRuleDirectories(root) {
   return findClaudeFiles(root).filter(
-    (file) => path70.dirname(file) !== root && parseRulesSection(readFileSync49(file, "utf8")).length > 0
+    (file) => path70.dirname(file) !== root && parseRulesSection(readFileSync50(file, "utf8")).length > 0
   ).map(
     (file) => `${path70.relative(root, path70.dirname(file)).split(path70.sep).join("/")}/`
   ).sort();
@@ -31773,7 +31943,7 @@ function upsertScopedRulesPointer(content, directories) {
 function updateScopedRulesIndex(root) {
   const directories = scopedRuleDirectories(root);
   const rootFile = path71.join(root, "CLAUDE.md");
-  const before = existsSync65(rootFile) ? readFileSync50(rootFile, "utf8") : "";
+  const before = existsSync66(rootFile) ? readFileSync51(rootFile, "utf8") : "";
   const after = upsertScopedRulesPointer(before, directories);
   if (after !== before) writeFileSync40(rootFile, after);
   return directories;
@@ -31781,7 +31951,7 @@ function updateScopedRulesIndex(root) {
 
 // src/commands/rules/addRule.ts
 function read2(file) {
-  return existsSync66(file) ? readFileSync51(file, "utf8") : "";
+  return existsSync67(file) ? readFileSync52(file, "utf8") : "";
 }
 function addRule(text18, options2) {
   const rule = text18.trim();
@@ -32264,11 +32434,11 @@ async function reviewProposedSlackMessage(target, body, workingPath) {
 }
 
 // src/commands/slack/slackWorkingFile.ts
-import { join as join74 } from "path";
+import { join as join76 } from "path";
 function slackWorkingFile(channel) {
   const slug = channel.replace(/^[#@]/, "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "channel";
-  const dir = join74(getStoreDir(), "slack");
-  return { dir, bodyPath: join74(dir, `${slug}.md`) };
+  const dir = join76(getStoreDir(), "slack");
+  return { dir, bodyPath: join76(dir, `${slug}.md`) };
 }
 
 // src/commands/slack/postSlackMessage.ts
@@ -32595,7 +32765,7 @@ function registerSql(program2) {
 import * as fs48 from "fs";
 import * as os5 from "os";
 import * as path85 from "path";
-import { fileURLToPath as fileURLToPath8 } from "url";
+import { fileURLToPath as fileURLToPath9 } from "url";
 
 // src/commands/sync/pruneCommands.ts
 import * as path76 from "path";
@@ -32801,9 +32971,9 @@ function quoteYaml(value) {
 }
 function commandToSkill(name, content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
-  const frontmatter = match ? match[1] : "";
+  const frontmatter2 = match ? match[1] : "";
   const body = match ? content.slice(match[0].length) : content;
-  const descriptionMatch = frontmatter.match(/^description:\s*(.*)$/m);
+  const descriptionMatch = frontmatter2.match(/^description:\s*(.*)$/m);
   const description = descriptionMatch ? descriptionMatch[1].trim().replace(/^["']|["']$/g, "") : name;
   const header = `---
 name: ${name}
@@ -32886,11 +33056,11 @@ function unquote2(value) {
 }
 function commandToPrompt(name, content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
-  const frontmatter = match ? match[1] : "";
+  const frontmatter2 = match ? match[1] : "";
   const body = match ? content.slice(match[0].length) : content;
-  const descriptionMatch = frontmatter.match(/^description:\s*(.*)$/m);
+  const descriptionMatch = frontmatter2.match(/^description:\s*(.*)$/m);
   const description = descriptionMatch ? unquote2(descriptionMatch[1]) : name;
-  const argsMatch = frontmatter.match(/^allowed_args:\s*(.*)$/m);
+  const argsMatch = frontmatter2.match(/^allowed_args:\s*(.*)$/m);
   const argumentHint = argsMatch ? unquote2(argsMatch[1]) : void 0;
   const header = [
     "---",
@@ -32967,7 +33137,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
 }
 
 // src/commands/sync.ts
-var __filename4 = fileURLToPath8(import.meta.url);
+var __filename4 = fileURLToPath9(import.meta.url);
 var __dirname5 = path85.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
@@ -33024,7 +33194,7 @@ function registerSync(program2) {
 }
 
 // src/commands/transcript/clean.ts
-import { existsSync as existsSync71 } from "fs";
+import { existsSync as existsSync72 } from "fs";
 
 // src/commands/transcript/convert/formatTimestamp.ts
 function pad(value, width) {
@@ -33274,9 +33444,9 @@ function formatVttPassages(passages, notes = [], { sourceMarks = true } = {}) {
 }
 
 // src/commands/transcript/convert/readCleanedCues.ts
-import { readFileSync as readFileSync56 } from "fs";
+import { readFileSync as readFileSync57 } from "fs";
 function readCleanedCues(inputPath) {
-  return deduplicateCues(parseVtt(readFileSync56(inputPath, "utf8")));
+  return deduplicateCues(parseVtt(readFileSync57(inputPath, "utf8")));
 }
 
 // src/commands/transcript/clean.ts
@@ -33302,7 +33472,7 @@ function clean(file, options2 = {}) {
     );
     process.exit(1);
   }
-  if (!existsSync71(file)) {
+  if (!existsSync72(file)) {
     console.error(`Error: VTT file not found: ${file}`);
     process.exit(1);
   }
@@ -33385,21 +33555,21 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync72, readdirSync as readdirSync20, statSync as statSync11 } from "fs";
-import { join as join85 } from "path";
+import { existsSync as existsSync73, readdirSync as readdirSync21, statSync as statSync11 } from "fs";
+import { join as join87 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync72(vttDir)) return;
-  for (const entry of readdirSync20(vttDir)) {
+  if (!existsSync73(vttDir)) return;
+  for (const entry of readdirSync21(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync11(join85(vttDir, entry)).isDirectory()) continue;
+    if (statSync11(join87(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
 
 // src/commands/transcript/move.ts
-import { existsSync as existsSync73, mkdirSync as mkdirSync29, renameSync as renameSync2, writeFileSync as writeFileSync46 } from "fs";
-import { basename as basename22, join as join86 } from "path";
+import { existsSync as existsSync74, mkdirSync as mkdirSync29, renameSync as renameSync2, writeFileSync as writeFileSync46 } from "fs";
+import { basename as basename23, join as join88 } from "path";
 
 // src/commands/transcript/convertVttToMarkdown.ts
 function convertVttToMarkdown(inputPath) {
@@ -33409,9 +33579,9 @@ function convertVttToMarkdown(inputPath) {
 // src/commands/transcript/move.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function archiveRawVtt(vttDir, sourcePath, filename) {
-  const processedDir = join86(vttDir, "processed");
+  const processedDir = join88(vttDir, "processed");
   mkdirSync29(processedDir, { recursive: true });
-  renameSync2(sourcePath, join86(processedDir, filename));
+  renameSync2(sourcePath, join88(processedDir, filename));
 }
 function move(file, options2) {
   const { date, client } = options2;
@@ -33420,27 +33590,27 @@ function move(file, options2) {
     process.exit(1);
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
-  const filename = basename22(file);
-  const sourcePath = join86(vttDir, filename);
-  if (!existsSync73(sourcePath)) {
+  const filename = basename23(file);
+  const sourcePath = join88(vttDir, filename);
+  if (!existsSync74(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
-  const base = basename22(filename, ".vtt").replace(/ Transcription$/, "");
+  const base = basename23(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
-  const formattedDir = join86(transcriptsDir, client);
+  const formattedDir = join88(transcriptsDir, client);
   mkdirSync29(formattedDir, { recursive: true });
-  const formattedPath = join86(formattedDir, outputName);
+  const formattedPath = join88(formattedDir, outputName);
   writeFileSync46(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
-  const summaryPath = join86(summaryDir, client, outputName);
+  const summaryPath = join88(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
   console.log(`Summary target:       ${summaryPath}`);
 }
 
 // src/commands/transcript/merge.ts
-import { existsSync as existsSync74, writeFileSync as writeFileSync47 } from "fs";
-import { basename as basename23 } from "path";
+import { existsSync as existsSync75, writeFileSync as writeFileSync47 } from "fs";
+import { basename as basename24 } from "path";
 
 // src/commands/transcript/failTranscript.ts
 function failTranscript(message3) {
@@ -33583,10 +33753,10 @@ function widenAudience(passages) {
 
 // src/commands/transcript/merge.ts
 function readSource2(file) {
-  if (!existsSync74(file)) failTranscript(`VTT file not found: ${file}`);
+  if (!existsSync75(file)) failTranscript(`VTT file not found: ${file}`);
   const cues = readCleanedCues(file);
   if (cues.length === 0) failTranscript(`no cues found in: ${file}`);
-  return { path: file, name: basename23(file), cues };
+  return { path: file, name: basename24(file), cues };
 }
 function wholePassages(sources) {
   return sources.map((source) => ({
@@ -33747,50 +33917,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync9 } from "child_process";
-import { join as join88 } from "path";
+import { join as join90 } from "path";
 
 // src/commands/voice/shared.ts
 import { homedir as homedir25 } from "os";
-import { dirname as dirname36, join as join87 } from "path";
-import { fileURLToPath as fileURLToPath9 } from "url";
-var __dirname6 = dirname36(fileURLToPath9(import.meta.url));
-var VOICE_DIR = join87(homedir25(), ".assist", "voice");
+import { dirname as dirname37, join as join89 } from "path";
+import { fileURLToPath as fileURLToPath10 } from "url";
+var __dirname6 = dirname37(fileURLToPath10(import.meta.url));
+var VOICE_DIR = join89(homedir25(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join87(VOICE_DIR, "voice.pid"),
-  log: join87(VOICE_DIR, "voice.log"),
-  venv: join87(VOICE_DIR, ".venv"),
-  lock: join87(VOICE_DIR, "voice.lock")
+  pid: join89(VOICE_DIR, "voice.pid"),
+  log: join89(VOICE_DIR, "voice.log"),
+  venv: join89(VOICE_DIR, ".venv"),
+  lock: join89(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join87(__dirname6, "commands", "voice", "python");
+  return join89(__dirname6, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join87(voicePaths.venv, "Scripts", "python.exe") : join87(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join89(voicePaths.venv, "Scripts", "python.exe") : join89(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join87(getLockDir(), "voice.lock");
+  return join89(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join88(getPythonDir(), "list_devices.py");
+  const script = join90(getPythonDir(), "list_devices.py");
   spawnSync9(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync75, readFileSync as readFileSync57 } from "fs";
+import { existsSync as existsSync76, readFileSync as readFileSync58 } from "fs";
 function logs(options2) {
-  if (!existsSync75(voicePaths.log)) {
+  if (!existsSync76(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count8 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync57(voicePaths.log, "utf8").trim();
+  const content = readFileSync58(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -33813,12 +33983,12 @@ function logs(options2) {
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync10 } from "child_process";
 import { mkdirSync as mkdirSync31 } from "fs";
-import { join as join90 } from "path";
+import { join as join92 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync60 } from "child_process";
-import { existsSync as existsSync76, mkdirSync as mkdirSync30, readFileSync as readFileSync58, writeFileSync as writeFileSync48 } from "fs";
-import { join as join89 } from "path";
+import { existsSync as existsSync77, mkdirSync as mkdirSync30, readFileSync as readFileSync59, writeFileSync as writeFileSync48 } from "fs";
+import { join as join91 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -33829,9 +33999,9 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync76(lockFile)) return;
+  if (!existsSync77(lockFile)) return;
   try {
-    const lock2 = JSON.parse(readFileSync58(lockFile, "utf8"));
+    const lock2 = JSON.parse(readFileSync59(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock2.pid}, env: ${lock2.env}). Stop it first with: assist voice stop`
@@ -33842,7 +34012,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync76(getVenvPython())) return;
+  if (existsSync77(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync60(
@@ -33855,7 +34025,7 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync30(join89(lockFile, ".."), { recursive: true });
+  mkdirSync30(join91(lockFile, ".."), { recursive: true });
   writeFileSync48(
     lockFile,
     JSON.stringify({
@@ -33871,7 +34041,7 @@ function setup() {
   mkdirSync31(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join90(getPythonDir(), "setup_models.py");
+  const script = join92(getPythonDir(), "setup_models.py");
   const result = spawnSync10(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -33885,7 +34055,7 @@ function setup() {
 // src/commands/voice/start.ts
 import { spawn as spawn8 } from "child_process";
 import { mkdirSync as mkdirSync32, writeFileSync as writeFileSync49 } from "fs";
-import { join as join91 } from "path";
+import { join as join93 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -33923,7 +34093,7 @@ function start2(options2) {
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join91(getPythonDir(), "voice_daemon.py");
+  const script = join93(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -33933,7 +34103,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync77, readFileSync as readFileSync59 } from "fs";
+import { existsSync as existsSync78, readFileSync as readFileSync60 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -33943,16 +34113,16 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count8) {
-  if (!existsSync77(voicePaths.log)) return [];
-  const lines2 = readFileSync59(voicePaths.log, "utf8").trim().split("\n");
+  if (!existsSync78(voicePaths.log)) return [];
+  const lines2 = readFileSync60(voicePaths.log, "utf8").trim().split("\n");
   return lines2.slice(-count8);
 }
 function status2() {
-  if (!existsSync77(voicePaths.pid)) {
+  if (!existsSync78(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync59(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync60(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -33971,13 +34141,13 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync78, readFileSync as readFileSync60, unlinkSync as unlinkSync20 } from "fs";
+import { existsSync as existsSync79, readFileSync as readFileSync61, unlinkSync as unlinkSync20 } from "fs";
 function stop2() {
-  if (!existsSync78(voicePaths.pid)) {
+  if (!existsSync79(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync60(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync61(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -33990,7 +34160,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync78(lockFile)) unlinkSync20(lockFile);
+    if (existsSync79(lockFile)) unlinkSync20(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -34054,11 +34224,11 @@ function changedPaths(from, cwd) {
 }
 
 // src/commands/watch/readBuiltVersion.ts
-import { join as join92 } from "path";
+import { join as join94 } from "path";
 function readBuiltVersion(cwd) {
   try {
     const root = runGit3(["rev-parse", "--show-toplevel"], cwd);
-    return readPackageJson(join92(root, "package.json")).version ?? "unknown";
+    return readPackageJson(join94(root, "package.json")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -34395,7 +34565,7 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/resolveRunCwd.ts
-import { existsSync as existsSync79 } from "fs";
+import { existsSync as existsSync80 } from "fs";
 import { resolve as resolve19 } from "path";
 var MissingRunCwdError = class extends Error {
   constructor(runName, cwd) {
@@ -34408,25 +34578,25 @@ var MissingRunCwdError = class extends Error {
 function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
   if (!config.cwd) return void 0;
   const cwd = resolve19(baseDir, config.cwd);
-  if (!existsSync79(cwd)) throw new MissingRunCwdError(config.name, cwd);
+  if (!existsSync80(cwd)) throw new MissingRunCwdError(config.name, cwd);
   return cwd;
 }
 
 // src/commands/run/runCommandToCompletion.ts
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync81 } from "fs";
+import { existsSync as existsSync82 } from "fs";
 
 // src/commands/run/resolveCommand.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import { existsSync as existsSync80 } from "fs";
-import { dirname as dirname37, join as join93, resolve as resolve20 } from "path";
+import { existsSync as existsSync81 } from "fs";
+import { dirname as dirname38, join as join95, resolve as resolve20 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync18("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
-    const gitRoot = resolve20(dirname37(gitPath), "..");
-    const gitBash = join93(gitRoot, "bin", "bash.exe");
-    if (existsSync80(gitBash)) return gitBash;
+    const gitRoot = resolve20(dirname38(gitPath), "..");
+    const gitBash = join95(gitRoot, "bin", "bash.exe");
+    if (existsSync81(gitBash)) return gitBash;
   } catch {
     return command;
   }
@@ -34436,7 +34606,7 @@ function resolveCommand2(command) {
 // src/commands/run/runCommandToCompletion.ts
 function runCommandToCompletion(command, args, env, cwd, quiet) {
   return new Promise((resolveResult) => {
-    if (cwd && !existsSync81(cwd)) {
+    if (cwd && !existsSync82(cwd)) {
       resolveResult({
         kind: "failed",
         message: `Failed to execute command: cwd ${cwd} does not exist`
@@ -34852,17 +35022,17 @@ async function auth() {
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync20 } from "child_process";
-import { readdirSync as readdirSync21, readFileSync as readFileSync61, statSync as statSync12 } from "fs";
-import { join as join94 } from "path";
+import { readdirSync as readdirSync22, readFileSync as readFileSync62, statSync as statSync12 } from "fs";
+import { join as join96 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
-    entries = readdirSync21(roamDir);
+    entries = readdirSync22(roamDir);
   } catch {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path91 = join94(roamDir, name);
+    const path91 = join96(roamDir, name);
     try {
       return { path: path91, mtimeMs: statSync12(path91).mtimeMs };
     } catch {
@@ -34879,11 +35049,11 @@ var PID_BY_APP = {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join94(appData, "Roam"));
+  const portFile = findPortFile(join96(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync61(portFile, "utf8").trim();
+    port = readFileSync62(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -35015,7 +35185,7 @@ async function run3(name, args) {
 
 // src/commands/run/add.ts
 import { mkdirSync as mkdirSync33, writeFileSync as writeFileSync50 } from "fs";
-import { join as join95 } from "path";
+import { join as join97 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -35076,7 +35246,7 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join95(".claude", "commands");
+  const dir = join97(".claude", "commands");
   mkdirSync33(dir, { recursive: true });
   const content = `---
 description: Run ${name}
@@ -35084,7 +35254,7 @@ description: Run ${name}
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join95(dir, `${name}.md`);
+  const filePath = join97(dir, `${name}.md`);
   writeFileSync50(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
@@ -35140,8 +35310,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync82, unlinkSync as unlinkSync21 } from "fs";
-import { join as join96 } from "path";
+import { existsSync as existsSync83, unlinkSync as unlinkSync21 } from "fs";
+import { join as join98 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -35156,8 +35326,8 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join96(".claude", "commands", `${name}.md`);
-  if (existsSync82(filePath)) {
+  const filePath = join98(".claude", "commands", `${name}.md`);
+  if (existsSync83(filePath)) {
     unlinkSync21(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -35202,9 +35372,9 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync62 } from "child_process";
-import { existsSync as existsSync83, mkdirSync as mkdirSync34, unlinkSync as unlinkSync22, writeFileSync as writeFileSync51 } from "fs";
+import { existsSync as existsSync84, mkdirSync as mkdirSync34, unlinkSync as unlinkSync22, writeFileSync as writeFileSync51 } from "fs";
 import { tmpdir as tmpdir9 } from "os";
-import { join as join97, resolve as resolve21 } from "path";
+import { join as join99, resolve as resolve21 } from "path";
 import chalk229 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -35334,14 +35504,14 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync83(outputDir)) {
+  if (!existsSync84(outputDir)) {
     mkdirSync34(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve21(outputDir, `${processName}-${timestamp6}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join97(tmpdir9(), `assist-screenshot-${Date.now()}.ps1`);
+  const scriptPath = join99(tmpdir9(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync51(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync62(
@@ -35418,11 +35588,11 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/readDaemonPidFile.ts
-import { readFileSync as readFileSync62 } from "fs";
+import { readFileSync as readFileSync63 } from "fs";
 function readDaemonPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync62(daemonPaths.pid, "utf8").trim(),
+      readFileSync63(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -35685,12 +35855,12 @@ function toSessionRunInfo({
 }
 
 // src/commands/sessions/daemon/worktree/joinRefusal.ts
-import { existsSync as existsSync84 } from "fs";
+import { existsSync as existsSync85 } from "fs";
 function joinRefusal(session) {
   if (session.commandType === "run") return "a server run has no agent stream";
   if (session.closing === true) return "the session is closing";
   if (!session.cwd) return "the session has no working directory";
-  if (!existsSync84(session.cwd))
+  if (!existsSync85(session.cwd))
     return "the session's workspace no longer exists";
   return void 0;
 }
@@ -35854,11 +36024,11 @@ function sessionBase(id, status3) {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
-import { existsSync as existsSync86 } from "fs";
+import { existsSync as existsSync87 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync85, statSync as statSync13 } from "fs";
+import { chmodSync, existsSync as existsSync86, statSync as statSync13 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path86 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -35873,7 +36043,7 @@ function ensureSpawnHelperExecutable() {
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync85(helper)) return;
+  if (!existsSync86(helper)) return;
   const mode = statSync13(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
@@ -35909,7 +36079,7 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
   });
 }
 function refuseMissingCwd(cwd, sessionId) {
-  if (!cwd || existsSync86(cwd)) return;
+  if (!cwd || existsSync87(cwd)) return;
   daemonLog(
     `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
   );
@@ -35989,8 +36159,8 @@ function serverRunMeta(runName, cwd) {
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
 import * as fs49 from "fs";
 import * as path87 from "path";
-import { fileURLToPath as fileURLToPath10 } from "url";
-var __filename5 = fileURLToPath10(import.meta.url);
+import { fileURLToPath as fileURLToPath11 } from "url";
+var __filename5 = fileURLToPath11(import.meta.url);
 var __dirname7 = path87.dirname(__filename5);
 function readDesignSystemPrompt() {
   const promptPath = path87.join(
@@ -36091,17 +36261,17 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync88 } from "fs";
-import { basename as basename24 } from "path";
+import { existsSync as existsSync89 } from "fs";
+import { basename as basename25 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync87 } from "fs";
-import { join as join100 } from "path";
+import { existsSync as existsSync88 } from "fs";
+import { join as join102 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
 import { statSync as statSync14 } from "fs";
 import { rm as rm4 } from "fs/promises";
-import { join as join99 } from "path";
+import { join as join101 } from "path";
 async function deleteTreeDirectly(clone, worktreePath, why) {
   if (holdsAGitDirectoryRatherThanALink(worktreePath)) {
     const refusal = "it is a clone of its own, not a linked worktree";
@@ -36129,7 +36299,7 @@ async function deleteTreeDirectly(clone, worktreePath, why) {
   return { removed: true };
 }
 function holdsAGitDirectoryRatherThanALink(worktreePath) {
-  return statSync14(join99(worktreePath, ".git"), {
+  return statSync14(join101(worktreePath, ".git"), {
     throwIfNoEntry: false
   })?.isDirectory() === true;
 }
@@ -36165,7 +36335,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync87(join100(worktreePath, ".git")))
+  if (!existsSync88(join102(worktreePath, ".git")))
     return "its .git link is already gone";
   if (/not a working tree|not a git repository/i.test(reason2(cause)))
     return "git no longer recognises it as a working tree";
@@ -36217,7 +36387,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync88(worktreePath)) {
+  if (!existsSync89(worktreePath)) {
     forgetWorktree(worktreePath);
     daemonLog(
       `worktree ${worktreePath} already gone; its record was forgotten`
@@ -36235,14 +36405,14 @@ async function reapWorktree(worktreePath, force = false) {
   const clone = owningClone(worktreePath);
   const removal = await removeTree(clone, worktreePath, force);
   if (!removal.removed) return removal;
-  await deleteWorktreeBranch(clone, basename24(worktreePath));
+  await deleteWorktreeBranch(clone, basename25(worktreePath));
   forgetWorktree(worktreePath);
   daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
   return removal;
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync88(recorded)) return recorded;
+  if (recorded && existsSync89(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -36373,12 +36543,12 @@ function closeGateApplies(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync89, watch } from "fs";
+import { existsSync as existsSync90, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync89(common)) return void 0;
+  if (!common || !existsSync90(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -36869,10 +37039,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync90 } from "fs";
+import { existsSync as existsSync91 } from "fs";
 import { resolve as resolve22 } from "path";
 function exitDetail(session) {
-  if (session.cwd && !existsSync90(session.cwd))
+  if (session.cwd && !existsSync91(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
   return missingRunConfigCwd(session);
 }
@@ -36886,7 +37056,7 @@ function missingRunConfigCwd(session) {
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
   const configured = resolve22(runConfigBaseDirFrom(dir), config.cwd);
-  if (existsSync90(configured)) return void 0;
+  if (existsSync91(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
 
@@ -36923,8 +37093,8 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync91, mkdirSync as mkdirSync35, watch as watch2 } from "fs";
-import { dirname as dirname39 } from "path";
+import { existsSync as existsSync92, mkdirSync as mkdirSync35, watch as watch2 } from "fs";
+import { dirname as dirname40 } from "path";
 
 // src/commands/sessions/daemon/applyActivityToSession.ts
 function applyActivityToSession(session, activity2) {
@@ -36986,7 +37156,7 @@ var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
   const path91 = activityPath(session.id);
-  const dir = dirname39(path91);
+  const dir = dirname40(path91);
   try {
     mkdirSync35(dir, { recursive: true });
   } catch {
@@ -37009,7 +37179,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read3, DEBOUNCE_MS2);
   });
-  if (existsSync91(path91)) read3();
+  if (existsSync92(path91)) read3();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -38732,8 +38902,8 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync94 } from "fs";
-import { basename as basename26 } from "path";
+import { existsSync as existsSync95 } from "fs";
+import { basename as basename27 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
 function accountedTrees(sessions) {
@@ -38787,9 +38957,9 @@ function bindResumedWorktree(session, cwd, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync93 } from "fs";
+import { existsSync as existsSync94 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync93(clone)) {
+  if (!existsSync94(clone)) {
     for (const { path: path91 } of paths) forgetWorktree(path91);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -38875,7 +39045,7 @@ function capped(lines2) {
 }
 
 // src/commands/sessions/daemon/worktree/resurfaceOrphanedWorktree.ts
-import { basename as basename25 } from "path";
+import { basename as basename26 } from "path";
 function resurfaceOrphanedWorktree(sessions, spawnWith, recovered, notify2) {
   const { orphan, reason: reason4, held } = recovered;
   let id;
@@ -38898,7 +39068,7 @@ function orphanedSession(id, recovered) {
   const { orphan, reason: reason4, held } = recovered;
   return {
     ...sessionBase(id, "stopped"),
-    name: `recovered ${basename25(orphan.path)}`,
+    name: `recovered ${basename26(orphan.path)}`,
     subtitle: `${held.summary} in ${orphan.path}`,
     commandType: "claude",
     pty: null,
@@ -38955,11 +39125,11 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
       );
       continue;
     }
-    if (!existsSync94(path91)) {
+    if (!existsSync95(path91)) {
       logVanishedTree(sessions, path91);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
-        { path: path91, branch: basename26(path91) }
+        { path: path91, branch: basename27(path91) }
       ]);
       continue;
     }
@@ -39600,14 +39770,14 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync95, readFileSync as readFileSync64 } from "fs";
+import { existsSync as existsSync96, readFileSync as readFileSync65 } from "fs";
 import { posix as posix3 } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync95(sessionsFile)) return false;
-    const data = JSON.parse(readFileSync64(sessionsFile, "utf8"));
+    if (!existsSync96(sessionsFile)) return false;
+    const data = JSON.parse(readFileSync65(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
     const message3 = error instanceof Error ? error.message : String(error);
@@ -40341,7 +40511,7 @@ function setAutoAdvance(sessions, id, enabled) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
-import { existsSync as existsSync98 } from "fs";
+import { existsSync as existsSync99 } from "fs";
 
 // src/commands/sessions/daemon/resumeSession.ts
 function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
@@ -40372,11 +40542,11 @@ function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
-import { existsSync as existsSync97 } from "fs";
+import { existsSync as existsSync98 } from "fs";
 
 // src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
-import { copyFileSync as copyFileSync7, existsSync as existsSync96, mkdirSync as mkdirSync37 } from "fs";
-import { join as join102 } from "path";
+import { copyFileSync as copyFileSync7, existsSync as existsSync97, mkdirSync as mkdirSync37 } from "fs";
+import { join as join104 } from "path";
 function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
   const dir = projectDirForCwd(toCwd);
   if (dir === projectDirForCwd(fromCwd)) {
@@ -40385,8 +40555,8 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     );
     return;
   }
-  const dest = join102(dir, `${claudeSessionId}.jsonl`);
-  if (existsSync96(dest)) {
+  const dest = join104(dir, `${claudeSessionId}.jsonl`);
+  if (existsSync97(dest)) {
     daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
     return;
   }
@@ -40437,7 +40607,7 @@ function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name, harness
 }
 function cloneForReapedTree(missingCwd) {
   const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
-  if (!clone || !existsSync97(clone))
+  if (!clone || !existsSync98(clone))
     throw new Error(
       `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
     );
@@ -40446,7 +40616,7 @@ function cloneForReapedTree(missingCwd) {
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
 function resumeInTree(ctx, sessionId, cwd, name, harness) {
-  if (!existsSync98(cwd))
+  if (!existsSync99(cwd))
     return resumeInReplacementTree(ctx, sessionId, cwd, name, harness);
   const id = ctx.spawnWith(
     (sid) => resumeSession(sid, sessionId, cwd, name, void 0, harness)
@@ -41032,7 +41202,7 @@ function handleConnection(socket, manager) {
 import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync52 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync65 } from "fs";
+import { readFileSync as readFileSync66 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -41043,7 +41213,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync65(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync66(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -41536,10 +41706,10 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync67, statSync as statSync16 } from "fs";
-import { isAbsolute as isAbsolute5, join as join103, resolve as resolve23 } from "path";
+import { readFileSync as readFileSync68, statSync as statSync16 } from "fs";
+import { isAbsolute as isAbsolute5, join as join105, resolve as resolve23 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join103(cwd, ".git");
+  const dotGit = join105(cwd, ".git");
   let stat4;
   try {
     stat4 = statSync16(dotGit);
@@ -41551,7 +41721,7 @@ function resolveGitDir(cwd) {
   }
   let contents;
   try {
-    contents = readFileSync67(dotGit, "utf8");
+    contents = readFileSync68(dotGit, "utf8");
   } catch {
     return null;
   }
@@ -41569,7 +41739,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync67(join103(gitDir, "HEAD"), "utf8");
+    head = readFileSync68(join105(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -41727,6 +41897,7 @@ program.command("coverage").description("Print global statement coverage percent
 var screenshotCommand = program.command("screenshot").description("Capture a screenshot of a running application window").argument("<process>", "Name of the running process (e.g. notepad, code)").action(screenshot);
 configHelp(screenshotCommand, rootConfigHelp.screenshot);
 registerActivity(program);
+registerAdvise(program);
 registerBackup(program);
 registerDb(program);
 registerDbMigration(program);