@staff0rd/assist 0.432.0 → 0.433.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.432.0",
+  version: "0.433.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -8070,17 +8070,18 @@ function delay(ms) {
 
 // src/shared/createBundleHandler.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync18, statSync as statSync2 } from "fs";
 import { dirname as dirname19, join as join22 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function createBundleHandler(importMetaUrl, bundlePath, contentType = "application/javascript") {
-  const dir = dirname19(fileURLToPath4(importMetaUrl));
+  const file = join22(dirname19(fileURLToPath4(importMetaUrl)), bundlePath);
   let cache2;
   return (req, res) => {
-    if (!cache2) {
-      const body = readFileSync18(join22(dir, bundlePath), "utf8");
+    const mtimeMs = statSync2(file).mtimeMs;
+    if (cache2?.mtimeMs !== mtimeMs) {
+      const body = readFileSync18(file, "utf8");
       const etag = `"${createHash("sha256").update(body).digest("hex").slice(0, 16)}"`;
-      cache2 = { body, etag };
+      cache2 = { body, etag, mtimeMs };
     }
     const headers = {
       ETag: cache2.etag,
@@ -8700,14 +8701,14 @@ import { basename as basename6, join as join25 } from "path";
 import { promisify as promisify3 } from "util";
 
 // src/commands/sessions/web/findSynthesisForBranch.ts
-import { existsSync as existsSync26, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
 import { basename as basename5, dirname as dirname20, join as join24 } from "path";
 function findSynthesisForBranch(repoReviewsDir, branch2) {
   const branchKeyPath = join24(repoReviewsDir, `${branch2}-`);
   const parent = dirname20(branchKeyPath);
   const branchPrefix = basename5(branchKeyPath);
   if (!existsSync26(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join24(parent, name, "synthesis.md")).filter((path71) => existsSync26(path71)).map((path71) => ({ path: path71, mtime: statSync2(path71).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join24(parent, name, "synthesis.md")).filter((path71) => existsSync26(path71)).map((path71) => ({ path: path71, mtime: statSync3(path71).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -13295,7 +13296,7 @@ function getPinStatePath(pin) {
 }
 
 // src/commands/codeComment/sweepRestrictedDir.ts
-import { readdirSync as readdirSync3, statSync as statSync3, unlinkSync as unlinkSync7 } from "fs";
+import { readdirSync as readdirSync3, statSync as statSync4, unlinkSync as unlinkSync7 } from "fs";
 import { join as join34 } from "path";
 var STALE_AFTER_MS = 30 * 60 * 1e3;
 function sweepRestrictedDir(dir = getRestrictedDir()) {
@@ -13309,7 +13310,7 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   for (const entry of entries) {
     const path71 = join34(dir, entry);
     try {
-      if (statSync3(path71).mtimeMs < cutoff) unlinkSync7(path71);
+      if (statSync4(path71).mtimeMs < cutoff) unlinkSync7(path71);
     } catch {
       continue;
     }
@@ -14373,8 +14374,10 @@ function resolveRepoTarget(key, value, repo) {
 
 // src/commands/config/configSet.ts
 function configSet(key, value, options2 = {}) {
-  if (options2.repo !== void 0 && options2.global) {
-    console.error(chalk127.red("Use either --repo or --global, not both"));
+  if (options2.repo !== void 0 && !options2.global) {
+    console.error(
+      chalk127.red("--repo writes to the global config; add -g (e.g. -g --repo)")
+    );
     process.exit(1);
   }
   const resolved = resolveRepoTarget(key, value, options2.repo);
@@ -14399,7 +14402,7 @@ function registerConfig(program2) {
   const configCommand = program2.command("config").description("View and modify assist.yml configuration");
   configCommand.command("set <key> [value]").description("Set a config value (e.g. commit.push true)").option("-g, --global", "Write to global ~/.assist.yml").option(
     "-r, --repo [name]",
-    "Write to ~/.assist.yml under a repo's identity (defaults to the current repo)"
+    "Requires -g: scope the global write to a repo's identity (defaults to the current repo)"
   ).action((key, value, options2) => configSet(key, value, options2));
   configCommand.command("get <key>").description("Get a config value").action(configGet);
   configCommand.command("list").description("List all config values").action(configList);
@@ -15280,7 +15283,7 @@ function collectAllDeps(node) {
 }
 
 // src/commands/dotnet/findContainingSolutions.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync33, statSync as statSync4 } from "fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync33, statSync as statSync5 } from "fs";
 import path32 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
@@ -15296,7 +15299,7 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
       continue;
     const full = path32.join(dir, entry);
     try {
-      const stat2 = statSync4(full);
+      const stat2 = statSync5(full);
       if (stat2.isFile() && entry.endsWith(".sln")) {
         results.push(full);
       } else if (stat2.isDirectory()) {
@@ -16267,7 +16270,7 @@ import {
   readdirSync as readdirSync8,
   readFileSync as readFileSync35,
   rmSync as rmSync3,
-  statSync as statSync5
+  statSync as statSync6
 } from "fs";
 import { basename as basename10, join as join45 } from "path";
 
@@ -16340,13 +16343,13 @@ 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(basename10(file)) ?? statSync5(file).mtime;
+    const createdAt = parseArchiveTimestamp(basename10(file)) ?? statSync6(file).mtime;
     await migrateFile(orm, origin, file, createdAt);
     migrated++;
   }
   const handoverPath = getHandoverPath(cwd);
   if (existsSync42(handoverPath)) {
-    await migrateFile(orm, origin, handoverPath, statSync5(handoverPath).mtime);
+    await migrateFile(orm, origin, handoverPath, statSync6(handoverPath).mtime);
     migrated++;
   }
   return migrated;
@@ -21806,11 +21809,11 @@ async function runBacklogSession(synthesisPath) {
 }
 
 // src/commands/review/cachedReviewerResult.ts
-import { statSync as statSync6 } from "fs";
+import { statSync as statSync7 } from "fs";
 function cachedReviewerResult(name, outputPath) {
   let size;
   try {
-    size = statSync6(outputPath).size;
+    size = statSync7(outputPath).size;
   } catch {
     return null;
   }
@@ -23521,14 +23524,14 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync48, readdirSync as readdirSync10, statSync as statSync7 } from "fs";
+import { existsSync as existsSync48, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
 import { join as join56 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
   if (!existsSync48(vttDir)) return;
   for (const entry of readdirSync10(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync7(join56(vttDir, entry)).isDirectory()) continue;
+    if (statSync8(join56(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
@@ -24364,7 +24367,7 @@ async function auth() {
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import { readdirSync as readdirSync11, readFileSync as readFileSync46, statSync as statSync8 } from "fs";
+import { readdirSync as readdirSync11, readFileSync as readFileSync46, statSync as statSync9 } from "fs";
 import { join as join63 } from "path";
 function findPortFile(roamDir) {
   let entries;
@@ -24376,7 +24379,7 @@ function findPortFile(roamDir) {
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
     const path71 = join63(roamDir, name);
     try {
-      return { path: path71, mtimeMs: statSync8(path71).mtimeMs };
+      return { path: path71, mtimeMs: statSync9(path71).mtimeMs };
     } catch {
       return void 0;
     }
@@ -25570,7 +25573,7 @@ function readDesignSystemPrompt() {
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync57, statSync as statSync9 } from "fs";
+import { chmodSync, existsSync as existsSync57, statSync as statSync10 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path59 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -25586,7 +25589,7 @@ function ensureSpawnHelperExecutable() {
     "spawn-helper"
   );
   if (!existsSync57(helper)) return;
-  const mode = statSync9(helper).mode;
+  const mode = statSync10(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
 
@@ -25646,7 +25649,13 @@ function spawnRun(opts) {
   return spawnPty(["assist", "run", opts.name, ...opts.args ?? []], opts.cwd);
 }
 
-// src/commands/sessions/daemon/createSession.ts
+// src/commands/sessions/daemon/startOrHoldPty.ts
+function startOrHoldPty(start3, hold) {
+  if (hold) return { pty: null, pendingStart: start3 };
+  return { pty: start3() };
+}
+
+// src/commands/sessions/daemon/sessionBase.ts
 function sessionBase(id, status3) {
   const startedAt = Date.now();
   return {
@@ -25660,27 +25669,32 @@ function sessionBase(id, status3) {
     scrollback: ""
   };
 }
-function createSession(id, prompt, cwd, design, harness) {
-  if (harness === "pi") return createPiSession(id, prompt, cwd);
+
+// src/commands/sessions/daemon/createSession.ts
+function createSession(id, prompt, cwd, design, harness, holdPty) {
+  if (harness === "pi") return createPiSession(id, prompt, cwd, holdPty);
   const claudeSessionId = randomUUID5();
   return {
     ...sessionBase(id, prompt ? "running" : "waiting"),
     name: prompt?.slice(0, 40) || `Session ${id}`,
     commandType: "claude",
-    pty: spawnClaude2({ prompt, cwd, sessionId: id, claudeSessionId, design }),
+    ...startOrHoldPty(
+      () => spawnClaude2({ prompt, cwd, sessionId: id, claudeSessionId, design }),
+      holdPty
+    ),
     cwd,
     claudeSessionId,
     initialPrompt: prompt,
     design
   };
 }
-function createPiSession(id, prompt, cwd) {
+function createPiSession(id, prompt, cwd, holdPty) {
   return {
     ...sessionBase(id, prompt ? "running" : "waiting"),
     name: prompt?.slice(0, 40) || `Session ${id}`,
     commandType: "claude",
     harness: "pi",
-    pty: spawnPi2({ prompt, cwd, sessionId: id }),
+    ...startOrHoldPty(() => spawnPi2({ prompt, cwd, sessionId: id }), holdPty),
     cwd,
     initialPrompt: prompt
   };
@@ -26371,12 +26385,12 @@ function shouldAutoDismiss(session, exitCode) {
 }
 
 // src/commands/sessions/daemon/shouldAutoRun.ts
-function shouldAutoRun(session) {
+function shouldAutoRun(session, status3 = session.status) {
   if (!session.autoRun) return { run: false, reason: null };
-  if (session.status !== "done")
+  if (status3 !== "done")
     return {
       run: false,
-      reason: `session status is "${session.status}", not "done"`
+      reason: `session status is "${status3}", not "done"`
     };
   if (session.commandType !== "assist")
     return {
@@ -26402,7 +26416,8 @@ function shouldAutoRun(session) {
 function applyStatusChange(session, status3, exitCode, dismiss, notify2, reuseForRun) {
   if (session.status === status3) return;
   const deps2 = { dismiss, notify: notify2, reuseForRun };
-  if (status3 === "done" && session.worktree) {
+  const chainsToNextRun = shouldAutoRun(session, status3).run;
+  if (status3 === "done" && session.worktree && !chainsToNextRun) {
     void resolveDoneDurability(
       session,
       () => finishStatusChange(session, "done", exitCode, deps2),
@@ -26437,6 +26452,25 @@ function makeStatusChangeHandler(dismiss, notify2, reuseForRun) {
   return (s, status3, exitCode) => applyStatusChange(s, status3, exitCode, dismiss, notify2, reuseForRun);
 }
 
+// src/commands/sessions/daemon/emitSessionOutput.ts
+var MAX_SCROLLBACK = 256 * 1024;
+function emitSessionOutput(session, clients, data) {
+  session.scrollback += data;
+  if (session.scrollback.length > MAX_SCROLLBACK) {
+    session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK);
+  }
+  broadcast(clients, { type: "output", sessionId: session.id, data });
+}
+
+// src/commands/sessions/daemon/exitReason.ts
+import { existsSync as existsSync60 } from "fs";
+function exitReason(session, exitCode) {
+  const base = `process exited with code ${exitCode}`;
+  if (session.cwd && !existsSync60(session.cwd))
+    return `${base}: working directory ${session.cwd} no longer exists`;
+  return base;
+}
+
 // src/commands/sessions/daemon/handleFailedResume.ts
 function handleFailedResume(session, exitCode, onStatusChange) {
   const failed2 = session.restored === true && exitCode !== 0 && session.scrollback.length === 0;
@@ -26450,7 +26484,7 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync60, mkdirSync as mkdirSync25, watch as watch2 } from "fs";
+import { existsSync as existsSync61, mkdirSync as mkdirSync25, watch as watch2 } from "fs";
 import { dirname as dirname29 } from "path";
 
 // src/commands/sessions/daemon/applyReviewPause.ts
@@ -26531,7 +26565,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS2);
   });
-  if (existsSync60(path71)) read();
+  if (existsSync61(path71)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -26580,7 +26614,7 @@ function handlePtyExit(session, exitCode, onStatusChange) {
   if (handleFailedResume(session, exitCode, onStatusChange)) return;
   const priorStatus = session.status;
   if (exitCode !== 0) {
-    session.error = `process exited with code ${exitCode}`;
+    session.error = exitReason(session, exitCode);
     daemonLog(
       `session ${session.id} ("${session.name}") pty exited with code ${exitCode} from status "${priorStatus}" \u2014 unexpected exit, marking error`
     );
@@ -26595,21 +26629,23 @@ function handlePtyExit(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/wirePtyEvents.ts
-var MAX_SCROLLBACK = 256 * 1024;
-function appendScrollback(session, data) {
-  session.scrollback += data;
-  if (session.scrollback.length > MAX_SCROLLBACK) {
-    session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK);
-  }
-}
 function wirePtyEvents(session, clients, onStatusChange) {
   if (!session.pty) return;
-  session.pty.onData((data) => {
-    appendScrollback(session, data);
-    broadcast(clients, { type: "output", sessionId: session.id, data });
+  session.pty.onData((data) => emitSessionOutput(session, clients, data));
+  session.pty.onExit(({ exitCode }) => {
+    handlePtyExit(session, exitCode, onStatusChange);
+    reportSilentFailure(session, clients);
   });
-  session.pty.onExit(
-    ({ exitCode }) => handlePtyExit(session, exitCode, onStatusChange)
+}
+function reportSilentFailure(session, clients) {
+  if (session.status !== "error" || !session.error) return;
+  if (session.scrollback.length > 0) return;
+  emitSessionOutput(
+    session,
+    clients,
+    `\r
+\x1B[31m${session.error}\x1B[0m\r
+`
   );
 }
 
@@ -27162,6 +27198,207 @@ function restoreAll(spawn12, sessions) {
   });
 }
 
+// src/commands/sessions/daemon/worktree/rearmStoppedSessions.ts
+function rearmStoppedSessions(sessions, notify2) {
+  for (const s of sessions.values()) {
+    if (s.status !== "stopped" || !s.worktree) continue;
+    void resolveDoneDurability(
+      s,
+      () => {
+        if (dismissSession(sessions, s.id)) notify2();
+      },
+      notify2
+    );
+  }
+}
+
+// src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
+import { existsSync as existsSync65 } from "fs";
+import { basename as basename14 } from "path";
+
+// src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
+var DISABLED = {
+  enabled: false,
+  install: true,
+  copy: [".env", "settings.local.json", ".claude/settings.local.json"]
+};
+function worktreeConfigFor(cwd) {
+  try {
+    return loadConfigFrom(cwd).worktree ?? DISABLED;
+  } catch {
+    return DISABLED;
+  }
+}
+
+// src/commands/sessions/daemon/worktree/detectExistingWorktree.ts
+function detectExistingWorktree(cwd) {
+  const repoRoot = findRepoRoot(cwd) ?? cwd;
+  if (!worktreeConfigFor(repoRoot).enabled) return void 0;
+  const clone = mainWorktree(repoRoot);
+  if (clone && clone !== repoRoot) return { path: repoRoot, clone };
+  return void 0;
+}
+
+// src/commands/sessions/daemon/worktree/seedWorktree.ts
+import { execFile as execFile8 } from "child_process";
+import { copyFileSync, existsSync as existsSync64, mkdirSync as mkdirSync26 } from "fs";
+import { dirname as dirname30, join as join71 } from "path";
+
+// src/commands/sessions/daemon/worktree/resolveInstallCommand.ts
+import { existsSync as existsSync63 } from "fs";
+import { join as join70 } from "path";
+function detectInstallCommand(repoRoot) {
+  if (!existsSync63(join70(repoRoot, "package.json"))) return null;
+  if (existsSync63(join70(repoRoot, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync63(join70(repoRoot, "yarn.lock"))) return "yarn install";
+  if (existsSync63(join70(repoRoot, "bun.lockb"))) return "bun install";
+  return "npm install";
+}
+function resolveInstallCommand(repoRoot, install) {
+  if (install === false) return null;
+  if (typeof install === "string") return install;
+  return detectInstallCommand(repoRoot);
+}
+
+// src/commands/sessions/daemon/worktree/seedWorktree.ts
+function seedWorktree(worktreePath, clone, onSeeded = () => {
+}) {
+  const cfg = worktreeConfigFor(clone);
+  copyConfigFiles(worktreePath, clone, cfg.copy);
+  runInstall(worktreePath, clone, cfg.install, onSeeded);
+}
+function copyConfigFiles(worktreePath, clone, copy) {
+  for (const rel of copy) {
+    const src = join71(clone, rel);
+    if (!existsSync64(src)) continue;
+    const dest = join71(worktreePath, rel);
+    try {
+      mkdirSync26(dirname30(dest), { recursive: true });
+      copyFileSync(src, dest);
+      daemonLog(`worktree ${worktreePath} seeded ${rel}`);
+    } catch (error) {
+      daemonLog(
+        `worktree ${worktreePath} failed to seed ${rel}: ${message(error)}`
+      );
+    }
+  }
+}
+function runInstall(worktreePath, clone, install, onSeeded) {
+  const command = resolveInstallCommand(clone, install);
+  if (!command) {
+    onSeeded();
+    return;
+  }
+  const windows = /^[A-Za-z]:[\\/]/.test(worktreePath);
+  const shell = windows ? "cmd.exe" : process.env.SHELL ?? "bash";
+  const shellArgs = windows ? ["/c", command] : ["-l", "-c", command];
+  daemonLog(`worktree ${worktreePath} installing deps: ${command}`);
+  execFile8(shell, shellArgs, { cwd: worktreePath }, (error) => {
+    daemonLog(
+      error ? `worktree ${worktreePath} install failed: ${error.message}` : `worktree ${worktreePath} install complete`
+    );
+    onSeeded();
+  });
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/sessions/daemon/worktree/bindNewWorktree.ts
+function boundTreeRoots(sessions) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const session of sessions.values())
+    if (session.cwd) roots.add(findRepoRoot(session.cwd) ?? session.cwd);
+  return roots;
+}
+function bindNewWorktree(session, alloc, notify2, startHeld = () => {
+}) {
+  if (alloc.kind !== "worktree" || !alloc.cwd || !alloc.clone || !session)
+    return;
+  session.worktree = { path: alloc.cwd, clone: alloc.clone };
+  if (alloc.created)
+    seedWorktree(alloc.cwd, alloc.clone, () => startHeld(session));
+  notify2();
+}
+function bindRestoredWorktrees(sessions) {
+  for (const session of sessions.values()) {
+    if (session.worktree || !session.cwd) continue;
+    const worktree = detectExistingWorktree(session.cwd);
+    if (worktree) session.worktree = worktree;
+  }
+}
+function bindResumedWorktree(session, cwd, notify2) {
+  if (!session) return;
+  const worktree = detectExistingWorktree(cwd);
+  if (!worktree) return;
+  session.worktree = worktree;
+  notify2();
+}
+
+// src/commands/sessions/daemon/worktree/readWorktreeRegistry.ts
+var REGISTRY_FILE = "worktrees.json";
+function readWorktreeRegistry() {
+  const data = loadJson(REGISTRY_FILE);
+  return Object.entries(data).map(([path71, record]) => ({ path: path71, ...record }));
+}
+function recordWorktree(path71, clone, origin) {
+  const data = loadJson(REGISTRY_FILE);
+  data[path71] = { clone, origin };
+  saveJson(REGISTRY_FILE, data);
+}
+
+// src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
+function reconcileWorktreesOnRestore(sessions) {
+  bindRestoredWorktrees(sessions);
+  void pruneWorktrees([...sessions.values()].map((s) => s.cwd));
+}
+async function pruneWorktrees(liveCwds) {
+  const accounted = /* @__PURE__ */ new Set();
+  for (const cwd of liveCwds) if (cwd) accounted.add(cwd);
+  for (const s of loadPersistedSessions()) accounted.add(s.cwd);
+  const clonesToPrune = /* @__PURE__ */ new Set();
+  const orphanBranches = [];
+  for (const { path: path71, clone } of readWorktreeRegistry()) {
+    if (accounted.has(path71)) continue;
+    if (!existsSync65(path71)) {
+      clonesToPrune.add(clone);
+      orphanBranches.push({ clone, branch: basename14(path71) });
+      continue;
+    }
+    daemonLog(`worktree ${path71} orphaned across restart; reconciling`);
+    await reapWorktree(path71);
+  }
+  for (const clone of clonesToPrune) {
+    if (!existsSync65(clone)) continue;
+    try {
+      await git3(clone, ["worktree", "prune"]);
+      daemonLog(`worktree bookkeeping pruned for clone ${clone}`);
+    } catch {
+    }
+  }
+  for (const { clone, branch: branch2 } of orphanBranches)
+    if (existsSync65(clone)) await pruneStaleWorktreeBranch(clone, branch2);
+}
+async function pruneStaleWorktreeBranch(clone, branch2) {
+  if (!listLocalBranches(clone).includes(branch2)) return;
+  try {
+    await git3(clone, ["branch", "-d", branch2]);
+    daemonLog(`stale worktree branch ${branch2} pruned from clone ${clone}`);
+  } catch {
+    daemonLog(
+      `stale worktree branch ${branch2} retained (unmerged; surfaced not destroyed) in clone ${clone}`
+    );
+  }
+}
+
+// src/commands/sessions/daemon/restoreAllSessions.ts
+function restoreAllSessions(spawnWith, sessions, notify2) {
+  const names = restoreAll(spawnWith, sessions);
+  reconcileWorktreesOnRestore(sessions);
+  rearmStoppedSessions(sessions, notify2);
+  return names;
+}
+
 // src/commands/sessions/daemon/retrySession.ts
 function retrySession(session, clients, onStatusChange) {
   const respawn = respawnThunk(session);
@@ -27268,8 +27505,44 @@ function shutdownSessions(sessions) {
   }
 }
 
+// src/commands/sessions/daemon/startHeldSession.ts
+function startHeldSession(session, sessions, clients, onStatusChange, notify2) {
+  const start3 = session.pendingStart;
+  if (!start3) return;
+  session.pendingStart = void 0;
+  if (sessions.get(session.id) !== session) {
+    daemonLog(
+      `session ${session.id} not started after seeding: card is gone (${session.worktree?.path ?? "no worktree"})`
+    );
+    return;
+  }
+  session.startedAt = Date.now();
+  if (session.status === "running") session.runningSince = session.startedAt;
+  session.pty = start3();
+  if (session.cols && session.rows)
+    try {
+      session.pty?.resize(session.cols, session.rows);
+    } catch {
+    }
+  wirePtyEvents(session, clients, onStatusChange);
+  daemonLog(
+    `session ${session.id} started once worktree ${session.worktree?.path ?? session.cwd} finished seeding`
+  );
+  notify2();
+}
+
+// src/commands/sessions/daemon/treeSpawnContext.ts
+function treeSpawnContext(sessions, spawnWith, notify2, clients, onStatusChange) {
+  return {
+    sessions,
+    spawnWith,
+    notify: notify2,
+    startHeld: (session) => startHeldSession(session, sessions, clients, onStatusChange, notify2)
+  };
+}
+
 // src/commands/sessions/daemon/watchTranscript.ts
-import { existsSync as existsSync62, watch as watch3 } from "fs";
+import { existsSync as existsSync66, watch as watch3 } from "fs";
 
 // src/commands/sessions/daemon/reconcileTranscriptStatus.ts
 async function resolveTranscriptPath(session) {
@@ -27304,7 +27577,7 @@ function watchTranscript(session, onStatusChange) {
   if (!session.cwd || !session.claudeSessionId) return;
   if (session.watchedTranscriptId === session.claudeSessionId) return;
   const dir = projectDirForCwd(session.cwd);
-  if (!existsSync62(dir)) return;
+  if (!existsSync66(dir)) return;
   if (session.transcriptWatcher) {
     session.transcriptWatcher.close();
     session.transcriptWatcher = void 0;
@@ -27455,13 +27728,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync63, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync67, readFileSync as readFileSync49 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync63(sessionsFile)) return false;
+    if (!existsSync67(sessionsFile)) return false;
     const data = JSON.parse(readFileSync49(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -27588,7 +27861,7 @@ function replayScrollback2(state, client) {
         data: stripReplayQueries(data)
       });
 }
-function appendScrollback2(state, sessionId, data) {
+function appendScrollback(state, sessionId, data) {
   const next3 = (state.scrollback.get(sessionId) ?? "") + data;
   state.scrollback.set(
     sessionId,
@@ -27688,7 +27961,7 @@ function handleCreated(state, msg) {
 function handleOutput(state, msg) {
   const sessionId = nsId(msg);
   const data = msg.data;
-  appendScrollback2(state, sessionId, data);
+  appendScrollback(state, sessionId, data);
   state.broadcast({ type: "output", sessionId, data });
 }
 function relayWithSessionId(state, msg) {
@@ -28004,194 +28277,8 @@ var WindowsProxy = class {
   }
 };
 
-// src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync66 } from "fs";
-import { basename as basename14 } from "path";
-
-// src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
-var DISABLED = {
-  enabled: false,
-  install: true,
-  copy: [".env", "settings.local.json", ".claude/settings.local.json"]
-};
-function worktreeConfigFor(cwd) {
-  try {
-    return loadConfigFrom(cwd).worktree ?? DISABLED;
-  } catch {
-    return DISABLED;
-  }
-}
-
-// src/commands/sessions/daemon/worktree/detectExistingWorktree.ts
-function detectExistingWorktree(cwd) {
-  const repoRoot = findRepoRoot(cwd) ?? cwd;
-  if (!worktreeConfigFor(repoRoot).enabled) return void 0;
-  const clone = mainWorktree(repoRoot);
-  if (clone && clone !== repoRoot) return { path: repoRoot, clone };
-  return void 0;
-}
-
-// src/commands/sessions/daemon/worktree/seedWorktree.ts
-import { execFile as execFile8 } from "child_process";
-import { copyFileSync, existsSync as existsSync65, mkdirSync as mkdirSync26 } from "fs";
-import { dirname as dirname30, join as join71 } from "path";
-
-// src/commands/sessions/daemon/worktree/resolveInstallCommand.ts
-import { existsSync as existsSync64 } from "fs";
-import { join as join70 } from "path";
-function detectInstallCommand(repoRoot) {
-  if (!existsSync64(join70(repoRoot, "package.json"))) return null;
-  if (existsSync64(join70(repoRoot, "pnpm-lock.yaml"))) return "pnpm install";
-  if (existsSync64(join70(repoRoot, "yarn.lock"))) return "yarn install";
-  if (existsSync64(join70(repoRoot, "bun.lockb"))) return "bun install";
-  return "npm install";
-}
-function resolveInstallCommand(repoRoot, install) {
-  if (install === false) return null;
-  if (typeof install === "string") return install;
-  return detectInstallCommand(repoRoot);
-}
-
-// src/commands/sessions/daemon/worktree/seedWorktree.ts
-function seedWorktree(worktreePath, clone) {
-  const cfg = worktreeConfigFor(clone);
-  copyConfigFiles(worktreePath, clone, cfg.copy);
-  runInstall(worktreePath, clone, cfg.install);
-}
-function copyConfigFiles(worktreePath, clone, copy) {
-  for (const rel of copy) {
-    const src = join71(clone, rel);
-    if (!existsSync65(src)) continue;
-    const dest = join71(worktreePath, rel);
-    try {
-      mkdirSync26(dirname30(dest), { recursive: true });
-      copyFileSync(src, dest);
-      daemonLog(`worktree ${worktreePath} seeded ${rel}`);
-    } catch (error) {
-      daemonLog(
-        `worktree ${worktreePath} failed to seed ${rel}: ${message(error)}`
-      );
-    }
-  }
-}
-function runInstall(worktreePath, clone, install) {
-  const command = resolveInstallCommand(clone, install);
-  if (!command) return;
-  const windows = /^[A-Za-z]:[\\/]/.test(worktreePath);
-  const shell = windows ? "cmd.exe" : process.env.SHELL ?? "bash";
-  const shellArgs = windows ? ["/c", command] : ["-l", "-c", command];
-  daemonLog(`worktree ${worktreePath} installing deps: ${command}`);
-  execFile8(shell, shellArgs, { cwd: worktreePath }, (error) => {
-    daemonLog(
-      error ? `worktree ${worktreePath} install failed: ${error.message}` : `worktree ${worktreePath} install complete`
-    );
-  });
-}
-function message(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/commands/sessions/daemon/worktree/bindNewWorktree.ts
-function boundTreeRoots(sessions) {
-  const roots = /* @__PURE__ */ new Set();
-  for (const session of sessions.values())
-    if (session.cwd) roots.add(findRepoRoot(session.cwd) ?? session.cwd);
-  return roots;
-}
-function bindNewWorktree(session, alloc, notify2) {
-  if (alloc.kind !== "worktree" || !alloc.cwd || !alloc.clone || !session)
-    return;
-  session.worktree = { path: alloc.cwd, clone: alloc.clone };
-  if (alloc.created) seedWorktree(alloc.cwd, alloc.clone);
-  notify2();
-}
-function bindRestoredWorktrees(sessions) {
-  for (const session of sessions.values()) {
-    if (session.worktree || !session.cwd) continue;
-    const worktree = detectExistingWorktree(session.cwd);
-    if (worktree) session.worktree = worktree;
-  }
-}
-function bindResumedWorktree(session, cwd, notify2) {
-  if (!session) return;
-  const worktree = detectExistingWorktree(cwd);
-  if (!worktree) return;
-  session.worktree = worktree;
-  notify2();
-}
-
-// src/commands/sessions/daemon/worktree/readWorktreeRegistry.ts
-var REGISTRY_FILE = "worktrees.json";
-function readWorktreeRegistry() {
-  const data = loadJson(REGISTRY_FILE);
-  return Object.entries(data).map(([path71, record]) => ({ path: path71, ...record }));
-}
-function recordWorktree(path71, clone, origin) {
-  const data = loadJson(REGISTRY_FILE);
-  data[path71] = { clone, origin };
-  saveJson(REGISTRY_FILE, data);
-}
-
-// src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-function reconcileWorktreesOnRestore(sessions) {
-  bindRestoredWorktrees(sessions);
-  void pruneWorktrees([...sessions.values()].map((s) => s.cwd));
-}
-async function pruneWorktrees(liveCwds) {
-  const accounted = /* @__PURE__ */ new Set();
-  for (const cwd of liveCwds) if (cwd) accounted.add(cwd);
-  for (const s of loadPersistedSessions()) accounted.add(s.cwd);
-  const clonesToPrune = /* @__PURE__ */ new Set();
-  const orphanBranches = [];
-  for (const { path: path71, clone } of readWorktreeRegistry()) {
-    if (accounted.has(path71)) continue;
-    if (!existsSync66(path71)) {
-      clonesToPrune.add(clone);
-      orphanBranches.push({ clone, branch: basename14(path71) });
-      continue;
-    }
-    daemonLog(`worktree ${path71} orphaned across restart; reconciling`);
-    await reapWorktree(path71);
-  }
-  for (const clone of clonesToPrune) {
-    if (!existsSync66(clone)) continue;
-    try {
-      await git3(clone, ["worktree", "prune"]);
-      daemonLog(`worktree bookkeeping pruned for clone ${clone}`);
-    } catch {
-    }
-  }
-  for (const { clone, branch: branch2 } of orphanBranches)
-    if (existsSync66(clone)) await pruneStaleWorktreeBranch(clone, branch2);
-}
-async function pruneStaleWorktreeBranch(clone, branch2) {
-  if (!listLocalBranches(clone).includes(branch2)) return;
-  try {
-    await git3(clone, ["branch", "-d", branch2]);
-    daemonLog(`stale worktree branch ${branch2} pruned from clone ${clone}`);
-  } catch {
-    daemonLog(
-      `stale worktree branch ${branch2} retained (unmerged; surfaced not destroyed) in clone ${clone}`
-    );
-  }
-}
-
-// src/commands/sessions/daemon/worktree/rearmStoppedSessions.ts
-function rearmStoppedSessions(sessions, notify2) {
-  for (const s of sessions.values()) {
-    if (s.status !== "stopped" || !s.worktree) continue;
-    void resolveDoneDurability(
-      s,
-      () => {
-        if (dismissSession(sessions, s.id)) notify2();
-      },
-      notify2
-    );
-  }
-}
-
 // src/commands/sessions/daemon/createAssistSession.ts
-function createAssistSession(id, assistArgs, cwd, meta) {
+function createAssistSession(id, assistArgs, cwd, meta, holdPty) {
   const startedAt = Date.now();
   return {
     id,
@@ -28203,7 +28290,10 @@ function createAssistSession(id, assistArgs, cwd, meta) {
     startedAt,
     runningMs: 0,
     runningSince: startedAt,
-    pty: spawnPty(["assist", ...assistArgs], cwd, id),
+    ...startOrHoldPty(
+      () => spawnPty(["assist", ...assistArgs], cwd, id),
+      holdPty
+    ),
     scrollback: "",
     assistArgs,
     cwd
@@ -28232,7 +28322,7 @@ function resumeSession(id, sessionId, cwd, name) {
 }
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
-import { existsSync as existsSync67 } from "fs";
+import { existsSync as existsSync68 } from "fs";
 import { basename as basename16, dirname as dirname31 } from "path";
 
 // src/commands/sessions/daemon/worktree/planAllocation.ts
@@ -28257,7 +28347,7 @@ function createWorktree(clone, root, boundTreeRoots2) {
   const path71 = nextWorktreePath(
     clone,
     base,
-    (candidate) => registered.has(candidate) || existsSync67(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate))
+    (candidate) => registered.has(candidate) || existsSync68(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate))
   );
   const trunk = cloneTrunkBranch(clone);
   gitSync(clone, ["config", "push.default", "upstream"]);
@@ -28309,22 +28399,23 @@ function allocateTree(requestedCwd, boundTreeRoots2) {
 // src/commands/sessions/daemon/worktree/spawnInTree.ts
 function allocateAndBind(ctx, cwd, create) {
   const alloc = allocateTree(cwd, boundTreeRoots(ctx.sessions));
-  const id = ctx.spawnWith((sid) => create(sid, alloc.cwd));
-  bindNewWorktree(ctx.sessions.get(id), alloc, ctx.notify);
+  const needsSeeding = alloc.kind === "worktree" && alloc.created === true;
+  const id = ctx.spawnWith((sid) => create(sid, alloc.cwd, needsSeeding));
+  bindNewWorktree(ctx.sessions.get(id), alloc, ctx.notify, ctx.startHeld);
   return id;
 }
 function spawnInTree(ctx, prompt, cwd, design, harness) {
   return allocateAndBind(
     ctx,
     cwd,
-    (sid, resolvedCwd) => createSession(sid, prompt, resolvedCwd, design, harness)
+    (sid, resolvedCwd, holdUntilSeeded) => createSession(sid, prompt, resolvedCwd, design, harness, holdUntilSeeded)
   );
 }
 function spawnAssistInTree(ctx, assistArgs, cwd, meta) {
   return allocateAndBind(
     ctx,
     cwd,
-    (sid, resolvedCwd) => createAssistSession(sid, assistArgs, resolvedCwd, meta)
+    (sid, resolvedCwd, holdUntilSeeded) => createAssistSession(sid, assistArgs, resolvedCwd, meta, holdUntilSeeded)
   );
 }
 function resumeInTree(ctx, sessionId, cwd, name) {
@@ -28432,10 +28523,7 @@ var SessionManager = class {
     );
   }
   restore() {
-    const names = restoreAll(this.spawnWith, this.sessions);
-    reconcileWorktreesOnRestore(this.sessions);
-    rearmStoppedSessions(this.sessions, this.notify);
-    return names;
+    return restoreAllSessions(this.spawnWith, this.sessions, this.notify);
   }
   drain = () => drainSessions(this.sessions, this.notify);
   add(session) {
@@ -28446,11 +28534,13 @@ var SessionManager = class {
   }
   spawnWith = (create) => this.add(create(sessionLimits.nextId(this.sessions.size, this.idCounter)));
   treeCtx() {
-    return {
-      sessions: this.sessions,
-      spawnWith: this.spawnWith,
-      notify: this.notify
-    };
+    return treeSpawnContext(
+      this.sessions,
+      this.spawnWith,
+      this.notify,
+      this.clients,
+      this.onStatusChange
+    );
   }
   spawn(prompt, cwd, design, harness) {
     return spawnInTree(this.treeCtx(), prompt, cwd, design, harness);
@@ -29027,22 +29117,22 @@ var sessionsConfigHelp = [
   },
   {
     key: "worktree.enabled",
-    setter: "assist config set worktree.enabled true --repo",
+    setter: "assist config set worktree.enabled true -g --repo",
     note: "opt in per repo: spill concurrent sessions into adjacent <clone>-N worktrees (default off)"
   },
   {
     key: "worktree.root",
-    setter: "assist config set worktree.root ~/git --repo",
+    setter: "assist config set worktree.root ~/git -g --repo",
     note: "optional; parent dir for <clone>-N worktrees (default: the clone's parent)"
   },
   {
     key: "worktree.install",
-    setter: "assist config set worktree.install true --repo",
+    setter: "assist config set worktree.install true -g --repo",
     note: "per-worktree dep install: true auto-detects the package manager, or give an explicit command; false to skip"
   },
   {
     key: "worktree.copy",
-    setter: "assist config set worktree.copy .env,.claude/settings.local.json --repo",
+    setter: "assist config set worktree.copy .env,.claude/settings.local.json -g --repo",
     note: "gitignored files copied into a new worktree so it can build/run"
   }
 ];
@@ -29262,13 +29352,13 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync52, statSync as statSync11 } from "fs";
+import { readFileSync as readFileSync52, statSync as statSync12 } from "fs";
 import { isAbsolute as isAbsolute2, join as join73, resolve as resolve17 } from "path";
 function resolveGitDir(cwd) {
   const dotGit = join73(cwd, ".git");
   let stat2;
   try {
-    stat2 = statSync11(dotGit);
+    stat2 = statSync12(dotGit);
   } catch {
     return null;
   }