@staff0rd/assist 0.618.1 → 0.620.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.618.1",
+  version: "0.620.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -11341,8 +11341,8 @@ function subsequenceScore(text18, query) {
 function scoreFilePath(path90, query) {
   const needle = query.trim().toLowerCase();
   if (!needle) return 0;
-  const basename26 = path90.slice(path90.lastIndexOf("/") + 1);
-  const inBasename = subsequenceScore(basename26, needle);
+  const basename27 = path90.slice(path90.lastIndexOf("/") + 1);
+  const inBasename = subsequenceScore(basename27, needle);
   if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
   return subsequenceScore(path90, needle);
 }
@@ -18132,11 +18132,11 @@ function pushTargetForRenamedUpstream(trunkMode) {
   const remote = gitOrNull2(
     `git config --get branch.${shellQuote(branch2)}.remote`
   );
-  const merge = gitOrNull2(
+  const merge2 = gitOrNull2(
     `git config --get branch.${shellQuote(branch2)}.merge`
   );
-  if (!remote || !merge) return null;
-  const upstream = merge.startsWith(HEADS_PREFIX) ? merge.slice(HEADS_PREFIX.length) : merge;
+  if (!remote || !merge2) return null;
+  const upstream = merge2.startsWith(HEADS_PREFIX) ? merge2.slice(HEADS_PREFIX.length) : merge2;
   if (upstream === branch2) return null;
   return trunkMode ? landOnTrackedMainline(remote, upstream) : raiseOwnRemoteBranch(remote, branch2);
 }
@@ -28625,8 +28625,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename26 = path61.basename(file, path61.extname(file));
-    if (basename26 === "index") continue;
+    const basename27 = path61.basename(file, path61.extname(file));
+    if (basename27 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -32437,9 +32437,28 @@ function formatCue(cue) {
   return `${timing}
 ${text18}`;
 }
+function formatClock(ms) {
+  return formatTimestamp2(ms).slice(0, 8);
+}
+function formatNoteBlock(lines2) {
+  return lines2.length ? [lines2.map((line) => `NOTE ${line}`).join("\n")] : [];
+}
+function formatPassage(passage) {
+  return [
+    `NOTE source: ${passage.source} @ ${formatClock(passage.sourceStartMs)}`,
+    ...passage.cues.map(formatCue)
+  ];
+}
 function formatVtt(cues) {
   return ["WEBVTT", ...cues.map(formatCue)].join("\n\n");
 }
+function formatVttPassages(passages, notes = []) {
+  return [
+    "WEBVTT",
+    ...formatNoteBlock(notes),
+    ...passages.flatMap(formatPassage)
+  ].join("\n\n");
+}
 
 // src/commands/transcript/convert/readCleanedCues.ts
 import { readFileSync as readFileSync55 } from "fs";
@@ -32558,9 +32577,169 @@ function list4() {
   }
 }
 
+// src/commands/transcript/merge.ts
+import { existsSync as existsSync73, writeFileSync as writeFileSync46 } from "fs";
+import { basename as basename21 } from "path";
+
+// src/commands/transcript/failTranscript.ts
+function failTranscript(message3) {
+  console.error(`Error: ${message3}`);
+  process.exit(1);
+}
+
+// src/commands/transcript/headerNotes.ts
+function removedNote(removed) {
+  if (removed.length === 0) return [];
+  const distinct = [...new Set(removed)];
+  const noun = removed.length === 1 ? "passage" : "passages";
+  return [`${removed.length} ${noun} removed: ${distinct.join(", ")}`];
+}
+function headerNotes(sources, removed) {
+  return [
+    `Collapsed ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)} from:`,
+    ...sources.map((source) => `  ${source.name}`),
+    ...removedNote(removed)
+  ];
+}
+
+// src/commands/transcript/rebasePassages.ts
+var JOIN_GAP_MS = 1e3;
+function rebasePassages(passages) {
+  let cursorMs = 0;
+  return passages.map((passage) => {
+    const cues = shift(passage.cues, cursorMs - passage.sourceStartMs);
+    cursorMs = lastEndMs(cues) + JOIN_GAP_MS;
+    return { ...passage, cues };
+  });
+}
+function shift(cues, offsetMs) {
+  return cues.map((cue) => ({
+    ...cue,
+    startMs: cue.startMs + offsetMs,
+    endMs: cue.endMs + offsetMs
+  }));
+}
+function lastEndMs(cues) {
+  return Math.max(...cues.map((cue) => cue.endMs));
+}
+
+// src/commands/transcript/selectPassages.ts
+var CLOCK = /^(?:(\d{1,3}):)?(\d{1,2}):(\d{1,2})(?:\.(\d{1,3}))?$/;
+function describeRange(range) {
+  return `${range.from} --> ${range.to} in ${range.file}`;
+}
+function parseClock(value, range) {
+  const match = value.match(CLOCK);
+  if (!match) {
+    failTranscript(
+      `malformed timestamp "${value}" in selection range ${describeRange(range)}`
+    );
+  }
+  const [, hours, minutes, seconds, millis] = match;
+  return (Number(hours ?? 0) * 3600 + Number(minutes) * 60 + Number(seconds)) * 1e3 + Number((millis ?? "").padEnd(3, "0"));
+}
+function findSource(sources, range) {
+  const match = sources.find(
+    (source) => source.path === range.file || source.name === range.file
+  );
+  return match ?? failTranscript(`selection names a file that was not given: ${range.file}`);
+}
+function spanOf(source) {
+  return {
+    startMs: source.cues[0].startMs,
+    endMs: Math.max(...source.cues.map((cue) => cue.endMs))
+  };
+}
+function boundsOf(source, range) {
+  const fromMs = parseClock(range.from, range);
+  const toMs = parseClock(range.to, range);
+  if (toMs < fromMs) {
+    failTranscript(
+      `selection range ${describeRange(range)} ends before it starts`
+    );
+  }
+  const span = spanOf(source);
+  if (fromMs > span.endMs || toMs < span.startMs) {
+    failTranscript(
+      `selection range ${describeRange(range)} lies outside that file's cues`
+    );
+  }
+  return { fromMs, toMs };
+}
+function cuesInRange(source, range) {
+  const { fromMs, toMs } = boundsOf(source, range);
+  return source.cues.filter(
+    (cue) => cue.startMs >= fromMs && cue.startMs <= toMs
+  );
+}
+function toPassage(source, cues) {
+  return { source: source.name, sourceStartMs: cues[0].startMs, cues };
+}
+function selectPassages(sources, selection) {
+  const passages = selection.keep.flatMap((range) => {
+    const source = findSource(sources, range);
+    const cues = cuesInRange(source, range);
+    return cues.length ? [toPassage(source, cues)] : [];
+  });
+  if (passages.length === 0) {
+    failTranscript("selection kept no cues from any source");
+  }
+  return passages;
+}
+
+// src/commands/transcript/selectionSchema.ts
+import { z as z9 } from "zod";
+var selectionSchema = z9.strictObject({
+  keep: z9.array(
+    z9.strictObject({
+      file: z9.string().trim().min(1, "file is required"),
+      from: z9.string().trim().min(1, "from is required"),
+      to: z9.string().trim().min(1, "to is required")
+    })
+  ).min(1, "a selection needs at least one keep range"),
+  removed: z9.array(z9.string().trim().min(1)).default([])
+});
+
+// src/commands/transcript/merge.ts
+function readSource2(file) {
+  if (!existsSync73(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: basename21(file), cues };
+}
+function wholePassages(sources) {
+  return sources.map((source) => ({
+    source: source.name,
+    sourceStartMs: source.cues[0].startMs,
+    cues: source.cues
+  }));
+}
+async function readSelection(source) {
+  if (!source) return void 0;
+  return readJsonPayload(source, selectionSchema, "transcript selection");
+}
+async function merge(files, options2 = {}) {
+  const sources = files.map(readSource2);
+  const selection = await readSelection(options2.select);
+  const passages = rebasePassages(
+    selection ? selectPassages(sources, selection) : wholePassages(sources)
+  );
+  const document = formatVttPassages(
+    passages,
+    headerNotes(sources, selection?.removed ?? [])
+  );
+  if (!options2.out) {
+    console.log(document);
+    return;
+  }
+  writeFileSync46(options2.out, `${document}
+`, "utf8");
+  console.log(`Merged transcript: ${options2.out}`);
+}
+
 // src/commands/transcript/move.ts
-import { existsSync as existsSync73, mkdirSync as mkdirSync28, renameSync as renameSync2, writeFileSync as writeFileSync46 } from "fs";
-import { basename as basename21, join as join85 } from "path";
+import { existsSync as existsSync74, mkdirSync as mkdirSync28, renameSync as renameSync2, writeFileSync as writeFileSync47 } from "fs";
+import { basename as basename22, join as join85 } from "path";
 
 // src/commands/transcript/convertVttToMarkdown.ts
 function convertVttToMarkdown(inputPath) {
@@ -32581,18 +32760,18 @@ function move(file, options2) {
     process.exit(1);
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
-  const filename = basename21(file);
+  const filename = basename22(file);
   const sourcePath = join85(vttDir, filename);
-  if (!existsSync73(sourcePath)) {
+  if (!existsSync74(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
-  const base = basename21(filename, ".vtt").replace(/ Transcription$/, "");
+  const base = basename22(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
   const formattedDir = join85(transcriptsDir, client);
   mkdirSync28(formattedDir, { recursive: true });
   const formattedPath = join85(formattedDir, outputName);
-  writeFileSync46(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
+  writeFileSync47(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
   const summaryPath = join85(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
@@ -32606,6 +32785,12 @@ function registerTranscript(program2) {
   transcriptCommand.command("configure").description("Configure transcript directories").action(configure);
   transcriptCommand.command("list").description("List raw .vtt filenames waiting in the pick-up directory").action(list4);
   transcriptCommand.command("clean <path>").description("Clean any .vtt file and write the result to stdout").option("--format <md|vtt>", "output format", "md").action(clean);
+  transcriptCommand.command("merge <path...>").description(
+    "Collapse several .vtt files into one transcript with NOTE provenance"
+  ).option("--out <path>", "write the merged transcript to this path").option(
+    "--select <file|->",
+    "keep/removed JSON naming the passages to keep (- for stdin)"
+  ).action(merge);
   transcriptCommand.command("move <file>").description(
     "Convert a raw .vtt to a dated markdown transcript and archive the original"
   ).requiredOption("--date <YYYY-MM-DD>", "meeting date").requiredOption("--client <name>", "client name").action(move);
@@ -32713,9 +32898,9 @@ function devices() {
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync74, readFileSync as readFileSync56 } from "fs";
+import { existsSync as existsSync75, readFileSync as readFileSync56 } from "fs";
 function logs(options2) {
-  if (!existsSync74(voicePaths.log)) {
+  if (!existsSync75(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
@@ -32747,7 +32932,7 @@ import { join as join89 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync59 } from "child_process";
-import { existsSync as existsSync75, mkdirSync as mkdirSync29, readFileSync as readFileSync57, writeFileSync as writeFileSync47 } from "fs";
+import { existsSync as existsSync76, mkdirSync as mkdirSync29, readFileSync as readFileSync57, writeFileSync as writeFileSync48 } from "fs";
 import { join as join88 } from "path";
 function isProcessAlive2(pid) {
   try {
@@ -32759,7 +32944,7 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync75(lockFile)) return;
+  if (!existsSync76(lockFile)) return;
   try {
     const lock2 = JSON.parse(readFileSync57(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
@@ -32772,7 +32957,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync75(getVenvPython())) return;
+  if (existsSync76(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync59(
@@ -32786,7 +32971,7 @@ function bootstrapVenv() {
 function writeLockFile(pid) {
   const lockFile = getLockFile();
   mkdirSync29(join88(lockFile, ".."), { recursive: true });
-  writeFileSync47(
+  writeFileSync48(
     lockFile,
     JSON.stringify({
       pid,
@@ -32814,7 +32999,7 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdirSync as mkdirSync31, writeFileSync as writeFileSync48 } from "fs";
+import { mkdirSync as mkdirSync31, writeFileSync as writeFileSync49 } from "fs";
 import { join as join90 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
@@ -32843,7 +33028,7 @@ function spawnBackground(python, script, env) {
     console.error("Failed to start voice daemon");
     process.exit(1);
   }
-  writeFileSync48(voicePaths.pid, String(pid));
+  writeFileSync49(voicePaths.pid, String(pid));
   writeLockFile(pid);
   console.log(`Voice daemon started (PID ${pid})`);
 }
@@ -32863,7 +33048,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync76, readFileSync as readFileSync58 } from "fs";
+import { existsSync as existsSync77, readFileSync as readFileSync58 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -32873,12 +33058,12 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count8) {
-  if (!existsSync76(voicePaths.log)) return [];
+  if (!existsSync77(voicePaths.log)) return [];
   const lines2 = readFileSync58(voicePaths.log, "utf8").trim().split("\n");
   return lines2.slice(-count8);
 }
 function status2() {
-  if (!existsSync76(voicePaths.pid)) {
+  if (!existsSync77(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
@@ -32901,9 +33086,9 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync77, readFileSync as readFileSync59, unlinkSync as unlinkSync20 } from "fs";
+import { existsSync as existsSync78, readFileSync as readFileSync59, unlinkSync as unlinkSync20 } from "fs";
 function stop2() {
-  if (!existsSync77(voicePaths.pid)) {
+  if (!existsSync78(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
@@ -32920,7 +33105,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync77(lockFile)) unlinkSync20(lockFile);
+    if (existsSync78(lockFile)) unlinkSync20(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -33239,9 +33424,9 @@ function stashDirtyTree(cwd) {
 function mergeBehindBranch(cwd) {
   const stash = stashDirtyTree(cwd);
   if (!stash.ok) return { kind: "blocked", reason: stash.reason };
-  const merge = attemptGit(["merge", "--ff-only", "@{u}"], cwd);
+  const merge2 = attemptGit(["merge", "--ff-only", "@{u}"], cwd);
   const restore2 = stash.stashed ? attemptGit(["stash", "pop"], cwd) : { ok: true };
-  if (!merge.ok) return { kind: "blocked", reason: merge.reason };
+  if (!merge2.ok) return { kind: "blocked", reason: merge2.reason };
   if (!restore2.ok) return { kind: "blocked", reason: restore2.reason };
   return fastForwarded(cwd);
 }
@@ -33325,7 +33510,7 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/resolveRunCwd.ts
-import { existsSync as existsSync78 } from "fs";
+import { existsSync as existsSync79 } from "fs";
 import { resolve as resolve19 } from "path";
 var MissingRunCwdError = class extends Error {
   constructor(runName, cwd) {
@@ -33338,17 +33523,17 @@ var MissingRunCwdError = class extends Error {
 function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
   if (!config.cwd) return void 0;
   const cwd = resolve19(baseDir, config.cwd);
-  if (!existsSync78(cwd)) throw new MissingRunCwdError(config.name, cwd);
+  if (!existsSync79(cwd)) throw new MissingRunCwdError(config.name, cwd);
   return cwd;
 }
 
 // src/commands/run/runCommandToCompletion.ts
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync80 } from "fs";
+import { existsSync as existsSync81 } from "fs";
 
 // src/commands/run/resolveCommand.ts
 import { execFileSync as execFileSync17 } from "child_process";
-import { existsSync as existsSync79 } from "fs";
+import { existsSync as existsSync80 } from "fs";
 import { dirname as dirname37, join as join92, resolve as resolve20 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
@@ -33356,7 +33541,7 @@ function resolveCommand2(command) {
     const gitPath = execFileSync17("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve20(dirname37(gitPath), "..");
     const gitBash = join92(gitRoot, "bin", "bash.exe");
-    if (existsSync79(gitBash)) return gitBash;
+    if (existsSync80(gitBash)) return gitBash;
   } catch {
     return command;
   }
@@ -33366,7 +33551,7 @@ function resolveCommand2(command) {
 // src/commands/run/runCommandToCompletion.ts
 function runCommandToCompletion(command, args, env, cwd, quiet) {
   return new Promise((resolveResult) => {
-    if (cwd && !existsSync80(cwd)) {
+    if (cwd && !existsSync81(cwd)) {
       resolveResult({
         kind: "failed",
         message: `Failed to execute command: cwd ${cwd} does not exist`
@@ -33944,7 +34129,7 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync32, writeFileSync as writeFileSync49 } from "fs";
+import { mkdirSync as mkdirSync32, writeFileSync as writeFileSync50 } from "fs";
 import { join as join94 } from "path";
 
 // src/commands/run/extractOption.ts
@@ -34015,7 +34200,7 @@ description: Run ${name}
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
   const filePath = join94(dir, `${name}.md`);
-  writeFileSync49(filePath, content);
+  writeFileSync50(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add3() {
@@ -34070,7 +34255,7 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync81, unlinkSync as unlinkSync21 } from "fs";
+import { existsSync as existsSync82, unlinkSync as unlinkSync21 } from "fs";
 import { join as join95 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
@@ -34087,7 +34272,7 @@ function parseRemoveName() {
 }
 function deleteCommandFile(name) {
   const filePath = join95(".claude", "commands", `${name}.md`);
-  if (existsSync81(filePath)) {
+  if (existsSync82(filePath)) {
     unlinkSync21(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -34132,7 +34317,7 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync61 } from "child_process";
-import { existsSync as existsSync82, mkdirSync as mkdirSync33, unlinkSync as unlinkSync22, writeFileSync as writeFileSync50 } from "fs";
+import { existsSync as existsSync83, mkdirSync as mkdirSync33, unlinkSync as unlinkSync22, writeFileSync as writeFileSync51 } from "fs";
 import { tmpdir as tmpdir9 } from "os";
 import { join as join96, resolve as resolve21 } from "path";
 import chalk227 from "chalk";
@@ -34264,7 +34449,7 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync82(outputDir)) {
+  if (!existsSync83(outputDir)) {
     mkdirSync33(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -34272,7 +34457,7 @@ function buildOutputPath(outputDir, processName) {
 }
 function runPowerShellScript(processName, outputPath) {
   const scriptPath = join96(tmpdir9(), `assist-screenshot-${Date.now()}.ps1`);
-  writeFileSync50(scriptPath, captureWindowPs1, "utf8");
+  writeFileSync51(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync61(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
@@ -34522,9 +34707,9 @@ function createAutoExit(exit, graceMs = DEFAULT_GRACE_MS) {
 }
 
 // src/commands/sessions/daemon/loadActiveSelection.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var ACTIVE_FILE = "active.json";
-var activeSelectionSchema = z9.record(z9.string(), z9.string());
+var activeSelectionSchema = z10.record(z10.string(), z10.string());
 function loadActiveSelection() {
   const parsed = activeSelectionSchema.safeParse(
     loadJson(ACTIVE_FILE)
@@ -34609,12 +34794,12 @@ function toSessionRunInfo({
 }
 
 // src/commands/sessions/daemon/worktree/joinRefusal.ts
-import { existsSync as existsSync83 } from "fs";
+import { existsSync as existsSync84 } 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 (!existsSync83(session.cwd))
+  if (!existsSync84(session.cwd))
     return "the session's workspace no longer exists";
   return void 0;
 }
@@ -34778,11 +34963,11 @@ function sessionBase(id, status3) {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
-import { existsSync as existsSync85 } from "fs";
+import { existsSync as existsSync86 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync84, statSync as statSync13 } from "fs";
+import { chmodSync, existsSync as existsSync85, statSync as statSync13 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path85 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -34797,7 +34982,7 @@ function ensureSpawnHelperExecutable() {
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync84(helper)) return;
+  if (!existsSync85(helper)) return;
   const mode = statSync13(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
@@ -34833,7 +35018,7 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
   });
 }
 function refuseMissingCwd(cwd, sessionId) {
-  if (!cwd || existsSync85(cwd)) return;
+  if (!cwd || existsSync86(cwd)) return;
   daemonLog(
     `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
   );
@@ -35015,11 +35200,11 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync87 } from "fs";
-import { basename as basename22 } from "path";
+import { existsSync as existsSync88 } from "fs";
+import { basename as basename23 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync86 } from "fs";
+import { existsSync as existsSync87 } from "fs";
 import { join as join99 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
@@ -35089,7 +35274,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync86(join99(worktreePath, ".git")))
+  if (!existsSync87(join99(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";
@@ -35141,7 +35326,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync87(worktreePath)) {
+  if (!existsSync88(worktreePath)) {
     forgetWorktree(worktreePath);
     daemonLog(
       `worktree ${worktreePath} already gone; its record was forgotten`
@@ -35159,14 +35344,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, basename22(worktreePath));
+  await deleteWorktreeBranch(clone, basename23(worktreePath));
   forgetWorktree(worktreePath);
   daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
   return removal;
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync87(recorded)) return recorded;
+  if (recorded && existsSync88(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -35297,12 +35482,12 @@ function closeGateApplies(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync88, watch } from "fs";
+import { existsSync as existsSync89, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync88(common)) return void 0;
+  if (!common || !existsSync89(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -35792,10 +35977,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync89 } from "fs";
+import { existsSync as existsSync90 } from "fs";
 import { resolve as resolve22 } from "path";
 function exitDetail(session) {
-  if (session.cwd && !existsSync89(session.cwd))
+  if (session.cwd && !existsSync90(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
   return missingRunConfigCwd(session);
 }
@@ -35809,7 +35994,7 @@ function missingRunConfigCwd(session) {
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
   const configured = resolve22(runConfigBaseDirFrom(dir), config.cwd);
-  if (existsSync89(configured)) return void 0;
+  if (existsSync90(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
 
@@ -35850,7 +36035,7 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync90, mkdirSync as mkdirSync34, watch as watch2 } from "fs";
+import { existsSync as existsSync91, mkdirSync as mkdirSync34, watch as watch2 } from "fs";
 import { dirname as dirname39 } from "path";
 
 // src/commands/sessions/daemon/applyActivityToSession.ts
@@ -35936,7 +36121,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read3, DEBOUNCE_MS2);
   });
-  if (existsSync90(path90)) read3();
+  if (existsSync91(path90)) read3();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -37659,8 +37844,8 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync93 } from "fs";
-import { basename as basename24 } from "path";
+import { existsSync as existsSync94 } from "fs";
+import { basename as basename25 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
 function accountedTrees(sessions) {
@@ -37714,9 +37899,9 @@ function bindResumedWorktree(session, cwd, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync92 } from "fs";
+import { existsSync as existsSync93 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync92(clone)) {
+  if (!existsSync93(clone)) {
     for (const { path: path90 } of paths) forgetWorktree(path90);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -37802,7 +37987,7 @@ function capped(lines2) {
 }
 
 // src/commands/sessions/daemon/worktree/resurfaceOrphanedWorktree.ts
-import { basename as basename23 } from "path";
+import { basename as basename24 } from "path";
 function resurfaceOrphanedWorktree(sessions, spawnWith, recovered, notify2) {
   const { orphan, reason: reason4, held } = recovered;
   let id;
@@ -37825,7 +38010,7 @@ function orphanedSession(id, recovered) {
   const { orphan, reason: reason4, held } = recovered;
   return {
     ...sessionBase(id, "stopped"),
-    name: `recovered ${basename23(orphan.path)}`,
+    name: `recovered ${basename24(orphan.path)}`,
     subtitle: `${held.summary} in ${orphan.path}`,
     commandType: "claude",
     pty: null,
@@ -37882,11 +38067,11 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
       );
       continue;
     }
-    if (!existsSync93(path90)) {
+    if (!existsSync94(path90)) {
       logVanishedTree(sessions, path90);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
-        { path: path90, branch: basename24(path90) }
+        { path: path90, branch: basename25(path90) }
       ]);
       continue;
     }
@@ -38527,13 +38712,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync94, readFileSync as readFileSync63 } from "fs";
+import { existsSync as existsSync95, readFileSync as readFileSync63 } from "fs";
 import { posix as posix3 } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync94(sessionsFile)) return false;
+    if (!existsSync95(sessionsFile)) return false;
     const data = JSON.parse(readFileSync63(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -39268,7 +39453,7 @@ function setAutoAdvance(sessions, id, enabled) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
-import { existsSync as existsSync97 } from "fs";
+import { existsSync as existsSync98 } from "fs";
 
 // src/commands/sessions/daemon/resumeSession.ts
 function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
@@ -39299,10 +39484,10 @@ function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
-import { existsSync as existsSync96 } from "fs";
+import { existsSync as existsSync97 } from "fs";
 
 // src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
-import { copyFileSync as copyFileSync7, existsSync as existsSync95, mkdirSync as mkdirSync36 } from "fs";
+import { copyFileSync as copyFileSync7, existsSync as existsSync96, mkdirSync as mkdirSync36 } from "fs";
 import { join as join101 } from "path";
 function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
   const dir = projectDirForCwd(toCwd);
@@ -39313,7 +39498,7 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     return;
   }
   const dest = join101(dir, `${claudeSessionId}.jsonl`);
-  if (existsSync95(dest)) {
+  if (existsSync96(dest)) {
     daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
     return;
   }
@@ -39364,7 +39549,7 @@ function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name, harness
 }
 function cloneForReapedTree(missingCwd) {
   const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
-  if (!clone || !existsSync96(clone))
+  if (!clone || !existsSync97(clone))
     throw new Error(
       `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
     );
@@ -39373,7 +39558,7 @@ function cloneForReapedTree(missingCwd) {
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
 function resumeInTree(ctx, sessionId, cwd, name, harness) {
-  if (!existsSync97(cwd))
+  if (!existsSync98(cwd))
     return resumeInReplacementTree(ctx, sessionId, cwd, name, harness);
   const id = ctx.spawnWith(
     (sid) => resumeSession(sid, sessionId, cwd, name, void 0, harness)
@@ -39956,7 +40141,7 @@ function handleConnection(socket, manager) {
 }
 
 // src/commands/sessions/daemon/onListening.ts
-import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync51 } from "fs";
+import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync52 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
 import { readFileSync as readFileSync64 } from "fs";
@@ -39978,7 +40163,7 @@ function ownsPidFile() {
 
 // src/commands/sessions/daemon/onListening.ts
 function onListening(manager, checkAutoExit) {
-  writeFileSync51(daemonPaths.pid, String(process.pid));
+  writeFileSync52(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
     void manager.flushActiveMs().finally(() => {