@staff0rd/assist 0.523.0 → 0.525.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.523.0",
+  version: "0.525.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -521,6 +521,7 @@ var assistConfigShape = {
   }).optional(),
   worktree: z3.strictObject({
     enabled: z3.boolean().default(false),
+    watcher: z3.boolean().default(false),
     trunk: z3.boolean().default(false),
     includeDrafts: z3.boolean().default(false),
     root: z3.string().optional(),
@@ -4252,6 +4253,11 @@ var sessionsConfigHelp = [
     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.watcher",
+    setter: "assist config set worktree.watcher true -g --repo",
+    note: "a backlog run also starts one starred claude session in the clone running /watch, so the built version stays current while the run works in its worktree; requires worktree.enabled and a /watch command in the repo (default off)"
+  },
   {
     key: "worktree.trunk",
     setter: "assist config set worktree.trunk true -g --repo",
@@ -19959,15 +19965,12 @@ function cloneHead(clone) {
 }
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
-function createWorktree(clone, strategy, boundTreeRoots2) {
+function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
   const base = strategy.root ? expandTilde2(strategy.root) : dirname25(clone);
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
-  const path71 = nextWorktreePath(
-    clone,
-    base,
-    (candidate) => registered.has(candidate) || existsSync45(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename14(candidate))
-  );
+  const isTaken = (candidate) => registered.has(candidate) || existsSync45(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename14(candidate));
+  const path71 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
   const start3 = worktreeStartPoint(clone, strategy.trunk);
   gitSync(clone, [
     "worktree",
@@ -20055,6 +20058,7 @@ function wouldDisturbWorkInProgress(clone, forCheckout) {
 // src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
 var DISABLED = {
   enabled: false,
+  watcher: false,
   trunk: false,
   includeDrafts: false,
   install: true,
@@ -20069,6 +20073,15 @@ function worktreeConfigFor(cwd) {
   }
 }
 
+// src/commands/sessions/daemon/worktree/forcedSpillReason.ts
+function forcedSpillReason(clone, trunk, options2) {
+  if (options2.replacesTree)
+    return `resumed session spilled out of the clone ${clone}: its worktree ${options2.replacesTree} is gone`;
+  if (trunk === true && options2.commits === true)
+    return `committing session spilled out of the clone ${clone}: worktree.trunk is on, so a commit here would land on the local mainline`;
+  return void 0;
+}
+
 // src/commands/sessions/daemon/worktree/allocateTree.ts
 function allocateTree(requestedCwd, boundTreeRoots2, options2 = {}) {
   if (!requestedCwd)
@@ -20080,22 +20093,18 @@ function allocateTree(requestedCwd, boundTreeRoots2, options2 = {}) {
     return { cwd: requestedCwd, kind: "primary", created: false };
   const clone = mainWorktree(repoRoot2) ?? repoRoot2;
   const reuse = { ...options2, includeDrafts: cfg.includeDrafts };
-  if (mustLeaveTrunk(cfg.trunk, options2))
-    daemonLog(
-      `committing session spilled out of the clone ${clone}: worktree.trunk is on, so a commit here would land on the local mainline`
-    );
+  const forcedSpill = forcedSpillReason(clone, cfg.trunk, options2);
+  if (forcedSpill) daemonLog(forcedSpill);
   else if (reusesClone(clone, boundTreeRoots2, reuse))
     return { cwd: clone, kind: "primary", created: false, clone };
   const path71 = createWorktree(
     clone,
     { root: cfg.root, trunk: cfg.trunk },
-    boundTreeRoots2
+    boundTreeRoots2,
+    options2.replacesTree
   );
   return { cwd: path71, kind: "worktree", created: true, clone };
 }
-function mustLeaveTrunk(trunk, options2) {
-  return trunk === true && options2.commits === true;
-}
 function keptInPlace(cwd) {
   daemonLog(
     `session kept in ${cwd}: launched against work already checked out there`
@@ -20142,6 +20151,7 @@ var persistedSessionSchema = z8.object({
   assistArgs: z8.array(z8.string()).optional(),
   activity: activitySchema.optional(),
   starred: z8.boolean().optional(),
+  watcher: z8.boolean().optional(),
   autoRun: z8.boolean().optional(),
   autoAdvance: z8.boolean().optional(),
   reviewStarted: z8.boolean().optional(),
@@ -20169,6 +20179,7 @@ function toPersistedSession(session) {
     assistArgs: session.assistArgs,
     activity: session.activity,
     starred: session.starred,
+    watcher: session.watcher,
     autoRun: session.autoRun,
     autoAdvance: session.autoAdvance,
     reviewStarted: session.reviewStarted,
@@ -29594,7 +29605,7 @@ function requestDrain(socket, lines2) {
 }
 
 // src/commands/sessions/daemon/runDaemon.ts
-import { mkdirSync as mkdirSync28 } from "fs";
+import { mkdirSync as mkdirSync29 } from "fs";
 
 // src/commands/sessions/daemon/createAutoExit.ts
 var DEFAULT_GRACE_MS = 6e4;
@@ -29659,15 +29670,8 @@ function broadcast(clients, msg) {
   }
 }
 
-// src/commands/sessions/daemon/toSessionInfo.ts
-function toSessionInfo({
-  id,
-  name,
-  title,
-  generatedTitle,
-  subtitle,
-  commandType,
-  harness,
+// src/commands/sessions/daemon/toSessionRunInfo.ts
+function toSessionRunInfo({
   status: status3,
   startedAt,
   runningMs,
@@ -29680,27 +29684,12 @@ function toSessionInfo({
   serverOrigin,
   assistArgs,
   cwd,
-  claudeSessionId,
-  restored,
-  error,
   activity: activity2,
-  autoRun,
-  autoAdvance,
-  starred,
   usedPct,
-  design,
-  pendingPrPreview,
-  undurable,
+  error,
   closing
 }) {
   return {
-    id,
-    name,
-    title,
-    generatedTitle,
-    subtitle,
-    commandType,
-    harness,
     status: status3,
     startedAt,
     runningMs,
@@ -29712,20 +29701,56 @@ function toSessionInfo({
     port: serverPort,
     remoteOrigin: serverOrigin ?? originForCwd(cwd),
     assistArgs,
+    activity: activity2,
+    usedPct,
+    error,
+    closing
+  };
+}
+
+// src/commands/sessions/daemon/toSessionInfo.ts
+function toSessionInfo(session) {
+  const {
+    id,
+    name,
+    title,
+    generatedTitle,
+    subtitle,
+    commandType,
+    harness,
+    cwd,
+    launchedFrom,
+    claudeSessionId,
+    restored,
+    autoRun,
+    autoAdvance,
+    starred,
+    watcher,
+    design,
+    pendingPrPreview,
+    undurable
+  } = session;
+  return {
+    ...toSessionRunInfo(session),
+    id,
+    name,
+    title,
+    generatedTitle,
+    subtitle,
+    commandType,
+    harness,
     cwd,
+    launchedFrom,
     claudeSessionId,
     repoGroup: repoGroupForCwd(cwd),
     restored,
-    error,
-    activity: activity2,
     autoRun,
     autoAdvance,
     starred,
-    usedPct,
+    watcher,
     design,
     pendingPrPreview,
-    undurable,
-    closing
+    undurable
   };
 }
 
@@ -29926,6 +29951,8 @@ function buildArgs3(opts) {
   if (opts.design) {
     base.push("--append-system-prompt", readDesignSystemPrompt());
     base.push("--permission-mode", "auto");
+  } else if (opts.auto) {
+    base.push("--permission-mode", "auto");
   }
   if (opts.resumeSessionId) {
     return opts.prompt ? [...base, "--resume", opts.resumeSessionId, opts.prompt] : [...base, "--resume", opts.resumeSessionId];
@@ -29998,7 +30025,8 @@ function createPiSession(id, prompt, cwd, holdPty) {
     initialPrompt: prompt
   };
 }
-function createRunSession(id, runName, runArgs, cwd, meta = serverRunMeta(runName, cwd)) {
+function createRunSession(id, { runName, runArgs, cwd, meta, launchedFrom }) {
+  const serverMeta = meta ?? serverRunMeta(runName, cwd);
   return {
     ...sessionBase(id, "running"),
     name: `run: ${runName}`,
@@ -30007,9 +30035,10 @@ function createRunSession(id, runName, runArgs, cwd, meta = serverRunMeta(runNam
     runName,
     runArgs,
     cwd,
-    server: meta.server || void 0,
-    serverPort: meta.port,
-    serverOrigin: meta.origin
+    launchedFrom,
+    server: serverMeta.server || void 0,
+    serverPort: serverMeta.port,
+    serverOrigin: serverMeta.origin
   };
 }
 
@@ -30614,8 +30643,9 @@ var PrPreviewCoordinator = class {
 
 // src/commands/sessions/daemon/logSpawnedSession.ts
 function logSpawnedSession(session) {
+  const launchedFrom = session.launchedFrom ? ` launched from ${session.launchedFrom}` : "";
   daemonLog(
-    `session ${session.id} spawned: ${session.name} [${session.commandType}] ${session.cwd ?? ""}`
+    `session ${session.id} spawned: ${session.name} [${session.commandType}] ${session.cwd ?? ""}${launchedFrom}`
   );
 }
 
@@ -31915,6 +31945,7 @@ function restoreBase(id, persisted) {
     assistArgs: persisted.assistArgs,
     initialPrompt: persisted.initialPrompt,
     starred: persisted.starred,
+    watcher: persisted.watcher,
     autoRun: persisted.autoRun,
     autoAdvance: restoredAutoAdvance(id, persisted),
     reviewStarted: persisted.reviewStarted
@@ -32562,6 +32593,14 @@ function startReusedRunPty(session, assistArgs, itemId2, hold, clients, onStatus
   return true;
 }
 
+// src/commands/sessions/daemon/worktree/isBacklogRunArgs.ts
+var ITEM_ID = /^a?\d+$/;
+function isBacklogRunArgs(args) {
+  const [command, subcommand, ...rest] = args;
+  if (command !== "backlog" || subcommand !== "run") return false;
+  return rest.some((arg) => ITEM_ID.test(arg));
+}
+
 // src/commands/sessions/daemon/worktree/isPrCheckoutArgs.ts
 var CHECKOUT_COMMANDS = /* @__PURE__ */ new Set(["review", "review-pr-comments"]);
 function isPrCheckoutArgs(args) {
@@ -32571,12 +32610,8 @@ function isPrCheckoutArgs(args) {
 }
 
 // src/commands/sessions/daemon/worktree/isCommittingArgs.ts
-var ITEM_ID = /^a?\d+$/;
 function isCommittingArgs(args) {
-  if (isPrCheckoutArgs(args)) return true;
-  const [command, subcommand, ...rest] = args;
-  if (command !== "backlog" || subcommand !== "run") return false;
-  return rest.some((arg) => ITEM_ID.test(arg));
+  return isPrCheckoutArgs(args) || isBacklogRunArgs(args);
 }
 
 // src/commands/sessions/daemon/worktree/boundTreeRoots.ts
@@ -33459,6 +33494,9 @@ function addAgentToStream(ctx, targetId, prompt, harness) {
   return spawnIntoStream(ctx, joinable.session, prompt, harness);
 }
 
+// src/commands/sessions/daemon/worktree/spawnInTree.ts
+import { existsSync as existsSync77 } from "fs";
+
 // src/commands/sessions/daemon/createAssistSession.ts
 function createAssistSession(id, assistArgs, cwd, meta, holdPty) {
   const startedAt = Date.now();
@@ -33484,7 +33522,7 @@ function createAssistSession(id, assistArgs, cwd, meta, holdPty) {
 }
 
 // src/commands/sessions/daemon/resumeSession.ts
-function resumeSession(id, sessionId, cwd, name) {
+function resumeSession(id, sessionId, cwd, name, holdPty) {
   const startedAt = Date.now();
   return {
     id,
@@ -33495,7 +33533,10 @@ function resumeSession(id, sessionId, cwd, name) {
     runningMs: 0,
     runningSince: null,
     waitingSince: startedAt,
-    pty: spawnClaude2({ resumeSessionId: sessionId, cwd, sessionId: id }),
+    ...startOrHoldPty(
+      () => spawnClaude2({ resumeSessionId: sessionId, cwd, sessionId: id }),
+      holdPty
+    ),
     scrollback: "",
     cwd,
     /* why: bind the card to the conversation it is resuming so a daemon restart
@@ -33514,6 +33555,128 @@ function allocateAndBind(ctx, cwd, create, options2 = {}) {
   return id;
 }
 
+// src/commands/sessions/daemon/createWatcherSession.ts
+import { randomUUID as randomUUID11 } from "crypto";
+var WATCH_PROMPT = "/watch";
+function createWatcherSession(id, cwd) {
+  const claudeSessionId = randomUUID11();
+  return {
+    ...sessionBase(id, "running"),
+    name: `Session ${id}`,
+    commandType: "claude",
+    pty: spawnClaude2({
+      prompt: WATCH_PROMPT,
+      cwd,
+      sessionId: id,
+      claudeSessionId,
+      auto: true
+    }),
+    cwd,
+    claudeSessionId,
+    initialPrompt: WATCH_PROMPT,
+    starred: true,
+    watcher: true
+  };
+}
+
+// src/commands/sessions/daemon/worktree/ensureWatcher.ts
+function ensureWatcher(ctx, cwd) {
+  if (!cwd) return void 0;
+  const repoRoot2 = findRepoRoot(cwd) ?? cwd;
+  const cfg = worktreeConfigFor(repoRoot2);
+  if (!cfg.enabled || cfg.watcher !== true) return void 0;
+  const clone = mainWorktree(repoRoot2) ?? repoRoot2;
+  const live = liveWatcherFor(ctx.sessions, clone);
+  if (live) {
+    daemonLog(
+      `no watcher spawned for the clone ${clone}: session ${live.id} is already watching it (${live.status})`
+    );
+    return void 0;
+  }
+  const id = allocateAndBind(
+    ctx,
+    clone,
+    (sid, resolvedCwd) => createWatcherSession(sid, resolvedCwd ?? clone),
+    { inPlace: true }
+  );
+  daemonLog(
+    `spawned watcher session ${id} running /watch in the clone ${clone}`
+  );
+  return id;
+}
+function liveWatcherFor(sessions, clone) {
+  for (const session of sessions.values())
+    if (session.watcher === true && session.cwd === clone && session.status !== "stopped" && session.status !== "error")
+      return session;
+  return void 0;
+}
+
+// src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
+import { existsSync as existsSync76 } from "fs";
+
+// src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
+import { copyFileSync as copyFileSync2, existsSync as existsSync75, mkdirSync as mkdirSync28 } from "fs";
+import { join as join78 } from "path";
+function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
+  const dir = projectDirForCwd(toCwd);
+  if (dir === projectDirForCwd(fromCwd)) {
+    daemonLog(
+      `transcript ${claudeSessionId} already lives in ${dir}: resuming in the original worktree path`
+    );
+    return;
+  }
+  const dest = join78(dir, `${claudeSessionId}.jsonl`);
+  if (existsSync75(dest)) {
+    daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
+    return;
+  }
+  const source = findTranscriptPathSync(fromCwd, claudeSessionId);
+  if (!source) {
+    daemonLog(
+      `transcript ${claudeSessionId} not found under ${projectDirForCwd(fromCwd)}: resuming in ${toCwd} without it`
+    );
+    return;
+  }
+  try {
+    mkdirSync28(dir, { recursive: true });
+    copyFileSync2(source, dest);
+    daemonLog(
+      `transcript ${source} copied to ${dest} so ${toCwd} can resume it`
+    );
+  } catch (error) {
+    daemonLog(
+      `transcript ${claudeSessionId} could not be copied to ${dir}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
+function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name) {
+  const clone = cloneForReapedTree(missingCwd);
+  daemonLog(
+    `resuming ${claudeSessionId}: its tree ${missingCwd} is gone, allocating from clone ${clone}`
+  );
+  return allocateAndBind(
+    ctx,
+    clone,
+    (id, resolvedCwd, holdUntilSeeded) => {
+      const cwd = resolvedCwd ?? clone;
+      carryTranscriptToTree(claudeSessionId, missingCwd, cwd);
+      daemonLog(`session ${id} resuming ${claudeSessionId} in ${cwd}`);
+      return resumeSession(id, claudeSessionId, cwd, name, holdUntilSeeded);
+    },
+    { replacesTree: missingCwd }
+  );
+}
+function cloneForReapedTree(missingCwd) {
+  const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
+  if (!clone || !existsSync76(clone))
+    throw new Error(
+      `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
+    );
+  return clone;
+}
+
 // src/commands/sessions/daemon/worktree/spawnInTree.ts
 function spawnInTree(ctx, prompt, cwd, design, harness, inPlace) {
   return allocateAndBind(
@@ -33524,7 +33687,7 @@ function spawnInTree(ctx, prompt, cwd, design, harness, inPlace) {
   );
 }
 function spawnAssistInTree(ctx, assistArgs, cwd, meta) {
-  return allocateAndBind(
+  const id = allocateAndBind(
     ctx,
     cwd,
     (sid, resolvedCwd, holdUntilSeeded) => createAssistSession(sid, assistArgs, resolvedCwd, meta, holdUntilSeeded),
@@ -33535,9 +33698,14 @@ function spawnAssistInTree(ctx, assistArgs, cwd, meta) {
       inPlace: meta?.inPlace
     }
   );
+  if (isBacklogRunArgs(assistArgs)) ensureWatcher(ctx, cwd);
+  return id;
 }
 function resumeInTree(ctx, sessionId, cwd, name) {
+  if (!existsSync77(cwd))
+    return resumeInReplacementTree(ctx, sessionId, cwd, name);
   const id = ctx.spawnWith((sid) => resumeSession(sid, sessionId, cwd, name));
+  daemonLog(`session ${id} resuming ${sessionId} in ${cwd}`);
   bindResumedWorktree(ctx.sessions.get(id), cwd, ctx.notify);
   return id;
 }
@@ -33667,10 +33835,8 @@ var SessionManager = class {
   addAgent(targetId, prompt, harness) {
     return addAgentToStream(this.treeCtx(), targetId, prompt, harness);
   }
-  spawnRun(runName, runArgs, cwd, meta) {
-    return this.spawnWith(
-      (id) => createRunSession(id, runName, runArgs, cwd, meta)
-    );
+  spawnRun(request) {
+    return this.spawnWith((id) => createRunSession(id, request));
   }
   liveServerRun(origin, excludeId) {
     return liveServerRun(this.sessions, origin, excludeId);
@@ -33783,6 +33949,7 @@ function handleCreateRun(client, m, d) {
   const runName = d.runName;
   const cwd = d.cwd;
   const runArgs = d.runArgs ?? [];
+  const launchedFrom = d.launchedFrom;
   const meta = serverRunMeta(runName, cwd);
   if (meta.server && meta.origin) {
     const existing = m.liveServerRun(meta.origin);
@@ -33794,6 +33961,7 @@ function handleCreateRun(client, m, d) {
         type: "run-conflict",
         runName,
         cwd,
+        launchedFrom,
         existing: serverConflictInfo(existing)
       });
       return;
@@ -33807,7 +33975,7 @@ function handleCreateRun(client, m, d) {
   }
   sendTo(client, {
     type: "created",
-    sessionId: m.spawnRun(runName, runArgs, cwd, meta),
+    sessionId: m.spawnRun({ runName, runArgs, cwd, meta, launchedFrom }),
     isNew: true
   });
 }
@@ -33856,9 +34024,9 @@ function safeParse2(line) {
 }
 
 // src/commands/sessions/daemon/repoDirExists.ts
-import { existsSync as existsSync75 } from "fs";
+import { existsSync as existsSync78 } from "fs";
 function repoDirExists(cwd) {
-  return existsSync75(toGitCwd(cwd));
+  return existsSync78(toGitCwd(cwd));
 }
 
 // src/commands/sessions/daemon/withRepoGroups.ts
@@ -34159,7 +34327,7 @@ async function recoverFromAddrInUse(server, manager, checkAutoExit) {
 
 // src/commands/sessions/daemon/runDaemon.ts
 async function runDaemon() {
-  mkdirSync28(daemonPaths.dir, { recursive: true });
+  mkdirSync29(daemonPaths.dir, { recursive: true });
   daemonLog(
     `starting (reason: ${process.env.ASSIST_DAEMON_SPAWN_REASON ?? "manual"})`
   );
@@ -34418,9 +34586,9 @@ function buildLimitsSegment(rateLimits) {
 
 // src/commands/readGitBranch.ts
 import { readFileSync as readFileSync54, statSync as statSync14 } from "fs";
-import { isAbsolute as isAbsolute4, join as join78, resolve as resolve21 } from "path";
+import { isAbsolute as isAbsolute4, join as join79, resolve as resolve21 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join78(cwd, ".git");
+  const dotGit = join79(cwd, ".git");
   let stat4;
   try {
     stat4 = statSync14(dotGit);
@@ -34450,7 +34618,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync54(join78(gitDir, "HEAD"), "utf8");
+    head = readFileSync54(join79(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.523.0",
+	"version": "0.525.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {