@staff0rd/assist 0.757.1 → 0.759.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.757.1",
+  version: "0.759.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -13058,7 +13058,7 @@ var sessionsConfigHelp = [
   {
     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, a /watch command in the repo and an auto-build run entry (default off)"
+    note: "a backlog run also starts one starred console session in the clone running assist watch loop (no claude, relaunched after a daemon restart), so the built version stays current while the run works in its worktree; requires worktree.enabled and an auto-build run entry (default off)"
   },
   {
     key: "worktree.trunk",
@@ -39103,6 +39103,49 @@ function registerVerify(program2) {
   configHelp(verifyCommand, verifyConfigHelp);
 }
 
+// src/commands/watch/decideLap.ts
+var RELAUNCH_CODES = /* @__PURE__ */ new Set([0, 2, 4]);
+function decideLap(end, interrupted) {
+  if (interrupted) return { kind: "exit", code: 130 };
+  if (end.code === null) return { kind: "relaunch" };
+  if (RELAUNCH_CODES.has(end.code)) return { kind: "relaunch" };
+  return { kind: "exit", code: end.code };
+}
+
+// src/commands/watch/runWatchLap.ts
+import { spawn as spawn9 } from "child_process";
+var WATCH_LAP_ARGS = ["watch", "wait", "--pull", "--build"];
+function runWatchLap() {
+  return new Promise((resolve26, reject) => {
+    const assistFromPath = spawn9("assist", WATCH_LAP_ARGS, {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    assistFromPath.on("close", (code, signal) => resolve26({ code, signal }));
+    assistFromPath.on("error", reject);
+  });
+}
+
+// src/commands/watch/watchLoop.ts
+async function watchLoop() {
+  let interrupted = false;
+  const recordInterruptAndLetLapFinish = () => {
+    interrupted = true;
+  };
+  process.on("SIGINT", recordInterruptAndLetLapFinish);
+  for (let lap = 1; ; lap++) {
+    console.log(`lap ${lap}: assist ${WATCH_LAP_ARGS.join(" ")}`);
+    const end = await runWatchLap();
+    const decision = decideLap(end, interrupted);
+    const how = end.signal ? `killed by ${end.signal}` : `exited ${end.code}`;
+    if (decision.kind === "exit") {
+      console.error(`lap ${lap} ${how} \u2014 stopping`);
+      return process.exit(decision.code);
+    }
+    console.log(`lap ${lap} ${how} \u2014 relaunching`);
+  }
+}
+
 // src/commands/watch/resolveUpstream.ts
 import { execFileSync as execFileSync21 } from "child_process";
 function runGit3(args, cwd) {
@@ -39717,6 +39760,9 @@ function registerWatch(program2) {
   ).action(
     (options2) => watchWait(options2)
   );
+  watchCommand.command("loop").description(
+    "Run assist watch wait --pull --build as a fresh child per lap, relaunching after exit 0, 2 or 4 or a signal kill, and exit with the child's code on 1, 3 or 130"
+  ).action(() => watchLoop());
   watchCommand.command("report").description(
     "Print the built version, the last 10 commits as a markdown table, the restarts the new commits make necessary, and whether ~/.claude needs a sync"
   ).option(
@@ -41296,6 +41342,7 @@ function dismissSession(sessions, id) {
   s.activityWatcher?.close();
   s.transcriptWatcher?.close();
   s.gitWatcher?.close();
+  s.closeGrace?.cancel();
   removeActivity(s.id);
   if (s.activity?.itemId != null) releaseLock(s.activity.itemId);
   sessions.delete(id);
@@ -41368,6 +41415,28 @@ function processCwd(link3) {
   }
 }
 
+// src/commands/sessions/daemon/worktree/awaitTreeVacated.ts
+var POLL_MS = 500;
+var GRACE_MS = 5e3;
+function awaitTreeVacated(session, treePath) {
+  return new Promise((resolve26) => {
+    let ticks = GRACE_MS / POLL_MS;
+    const settle = (outcome) => {
+      clearTimeout(timer);
+      session.closeGrace = void 0;
+      resolve26(outcome);
+    };
+    const tick = () => {
+      if (liveProcessesInTree(treePath).length === 0) settle("vacated");
+      else if (--ticks <= 0) settle("occupied");
+      else timer = setTimeout(tick, POLL_MS);
+    };
+    let timer = setTimeout(tick, POLL_MS);
+    session.closeGrace?.cancel();
+    session.closeGrace = { cancel: () => settle("cancelled") };
+  });
+}
+
 // src/commands/sessions/daemon/worktree/liveOccupantReason.ts
 function liveOccupantReason(treePath) {
   stopInstall(treePath);
@@ -41379,20 +41448,21 @@ function liveOccupantReason(treePath) {
 // src/commands/sessions/daemon/worktree/closeBlockReason.ts
 async function closeBlockReason(sessionId, tree) {
   const durability = await checkDurability(tree.path);
-  if (!durability.durable) return durability.reason;
+  if (!durability.durable) return { reason: durability.reason, live: false };
   if (durability.gone) {
     daemonLog(
       `session ${sessionId} closing: worktree ${tree.path} is gone from disk \u2014 released with nothing to land, not landed work`
     );
     return void 0;
   }
-  return tree.removable ? liveOccupantReason(tree.path) : void 0;
+  const occupied = tree.removable ? liveOccupantReason(tree.path) : void 0;
+  return occupied ? { reason: occupied, live: true } : void 0;
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
 import { existsSync as existsSync87, watch } from "fs";
 var DEBOUNCE_MS = 500;
-var POLL_MS = 3e4;
+var POLL_MS2 = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
   if (!common || !existsSync87(common)) return void 0;
@@ -41423,22 +41493,59 @@ function watchGitDir(common, onChange) {
   }
 }
 function pollGitState(cwd, onChange) {
-  const timer = setInterval(onChange, POLL_MS);
+  const timer = setInterval(onChange, POLL_MS2);
   timer.unref?.();
-  daemonLog(`git-state polled every ${POLL_MS / 1e3}s for ${cwd}`);
+  daemonLog(`git-state polled every ${POLL_MS2 / 1e3}s for ${cwd}`);
   return { close: () => clearInterval(timer) };
 }
 
+// src/commands/sessions/daemon/worktree/holdStopped.ts
+function holdStopped(session, tree, reason4, recheck, notify2) {
+  if (session.undurable?.reason !== reason4)
+    daemonLog(
+      `session ${session.id} stopped; ${tree.removable ? "reap" : "close"} blocked in ${tree.path}: ${reason4}`
+    );
+  session.undurable = { reason: reason4, removesTree: tree.removable };
+  session.closing = void 0;
+  setStatus2(session, "stopped");
+  if (!session.gitWatcher) {
+    let rechecking = false;
+    session.gitWatcher = watchGitState(tree.path, () => {
+      if (session.status !== "stopped" || rechecking) return;
+      rechecking = true;
+      void recheck().finally(() => {
+        rechecking = false;
+      });
+    });
+  }
+  notify2();
+}
+
 // src/commands/sessions/daemon/worktree/resolveCloseDurability.ts
-async function resolveCloseDurability(session, finalize, notify2) {
+async function resolveCloseDurability(session, finalize, notify2, graceSpent = false) {
   const tree = treeUnderClose(session);
   if (!tree) {
     finalize();
     return;
   }
   const blocked = await closeBlockReason(session.id, tree);
+  if (blocked?.live && session.closing && !graceSpent) {
+    daemonLog(
+      `session ${session.id} closing: waiting for live processes to leave ${tree.path} (${blocked.reason})`
+    );
+    const outcome = await awaitTreeVacated(session, tree.path);
+    daemonLog(`session ${session.id} closing: live-process wait ${outcome}`);
+    if (outcome === "cancelled") return;
+    return resolveCloseDurability(session, finalize, notify2, true);
+  }
   if (blocked) {
-    holdStopped(session, tree, blocked, finalize, notify2);
+    holdStopped(
+      session,
+      tree,
+      blocked.reason,
+      () => resolveCloseDurability(session, finalize, notify2),
+      notify2
+    );
     return;
   }
   if (tree.removable) await reapWorktree(tree.path);
@@ -41450,26 +41557,6 @@ async function resolveCloseDurability(session, finalize, notify2) {
   session.gitWatcher = void 0;
   finalize();
 }
-function holdStopped(session, tree, reason4, finalize, notify2) {
-  if (session.undurable?.reason !== reason4)
-    daemonLog(
-      `session ${session.id} stopped; ${tree.removable ? "reap" : "close"} blocked in ${tree.path}: ${reason4}`
-    );
-  session.undurable = { reason: reason4, removesTree: tree.removable };
-  session.closing = void 0;
-  setStatus2(session, "stopped");
-  if (!session.gitWatcher) {
-    let rechecking = false;
-    session.gitWatcher = watchGitState(tree.path, () => {
-      if (session.status !== "stopped" || rechecking) return;
-      rechecking = true;
-      void resolveCloseDurability(session, finalize, notify2).finally(() => {
-        rechecking = false;
-      });
-    });
-  }
-  notify2();
-}
 
 // src/commands/sessions/daemon/dismissSessionGated.ts
 function dismissSessionGated(sessions, id, notify2, discard = false) {
@@ -41483,6 +41570,7 @@ function dismissSessionGated(sessions, id, notify2, discard = false) {
     if (dismissSession(sessions, id)) notify2();
   };
   const settle = discard ? () => void discardTree(s, removeCard, notify2) : () => void resolveCloseDurability(s, removeCard, notify2);
+  s.closeGrace?.cancel();
   s.closing = true;
   daemonLog(
     `session ${id} closing: ${discard ? "discarding" : "checking durability of"} ${tree.path}`
@@ -42191,7 +42279,7 @@ async function touchedSince(file, sinceMs) {
 }
 
 // src/commands/sessions/daemon/bindCodexSession.ts
-var POLL_MS2 = 1e3;
+var POLL_MS3 = 1e3;
 var MAX_ATTEMPTS = 120;
 var START_SLACK_MS = 5e3;
 function bindCodexSession(session, notify2) {
@@ -42199,7 +42287,7 @@ function bindCodexSession(session, notify2) {
   if (session.harness !== "codex" || !cwd || session.harnessSessionId) return;
   const since = session.startedAt - START_SLACK_MS;
   let attemptsLeft = MAX_ATTEMPTS;
-  const schedule = () => setTimeout(() => void poll(), POLL_MS2).unref();
+  const schedule = () => setTimeout(() => void poll(), POLL_MS3).unref();
   const poll = async () => {
     if (session.harnessSessionId) return;
     const sessionId = await resolveCodexSessionId(cwd, since);
@@ -43171,6 +43259,7 @@ function respawnSession(session, respawn, status2, clients, onStatusChange) {
   session.gitWatcher = void 0;
   session.undurable = void 0;
   session.pendingDismiss = void 0;
+  session.closeGrace?.cancel();
   session.closing = void 0;
   session.scrollback = "";
   session.startedAt = Date.now();
@@ -43796,11 +43885,25 @@ function isOnceLaunch(persisted) {
   return persisted.commandType === "assist" && !!persisted.assistArgs && LAUNCH_COMMANDS.includes(persisted.assistArgs[0]) && persisted.assistArgs.includes("--once");
 }
 
+// src/commands/sessions/daemon/relaunchConsoleWatcher.ts
+function isConsoleWatcher(persisted) {
+  return persisted.watcher === true && persisted.commandType === "assist" && !!persisted.assistArgs;
+}
+function relaunchConsoleWatcher(id, persisted, base) {
+  const command = ["assist", ...persisted.assistArgs];
+  daemonLog(
+    `relaunching watcher session ${id} running ${command.join(" ")} in ${persisted.cwd ?? "(no cwd)"}`
+  );
+  return runningSession(base, persisted, spawnPty(command, persisted.cwd, id));
+}
+
 // src/commands/sessions/daemon/restoreSession.ts
 function restoreSession(id, persisted) {
   const base = restoreBase(id, persisted);
   if (persisted.status === "stopped") return stoppedSession(base, persisted);
   if (isUpdate(persisted)) return updatedSession(id, persisted);
+  if (isConsoleWatcher(persisted))
+    return relaunchConsoleWatcher(id, persisted, base);
   const status2 = deriveRestoreStatus(persisted);
   if (needsWrapperRelaunch(persisted)) {
     const resumesWrittenConversation = hasTranscriptOnDisk(persisted);
@@ -44144,10 +44247,10 @@ function restoreAllSessions(spawner, sessions, notify2) {
 
 // src/commands/sessions/daemon/retrySession.ts
 function retrySession(session, clients, onStatusChange) {
-  const spawn10 = respawnThunk(session);
-  if (!spawn10) return false;
+  const spawn11 = respawnThunk(session);
+  if (!spawn11) return false;
   const respawn = () => {
-    respawnSession(session, spawn10, "running", clients, onStatusChange);
+    respawnSession(session, spawn11, "running", clients, onStatusChange);
     daemonLog(`session ${session.id} retried: ${session.name}`);
   };
   const pty2 = session.pty;
@@ -44291,26 +44394,35 @@ function startReusedRunPty(session, assistArgs, itemId2, hold, clients, onStatus
   return true;
 }
 
+// src/commands/sessions/daemon/createAssistSession.ts
+function createAssistSession(id, assistArgs, cwd, meta, holdPty) {
+  const startedAt = Date.now();
+  return {
+    id,
+    name: `assist ${assistArgs.join(" ")}`,
+    title: meta?.title,
+    subtitle: meta?.subtitle,
+    commandType: "assist",
+    status: "running",
+    startedAt,
+    runningMs: 0,
+    runningSince: startedAt,
+    waitingSince: null,
+    ...startOrHoldPty(
+      () => spawnPty(["assist", ...assistArgs], cwd, id),
+      holdPty
+    ),
+    scrollback: "",
+    assistArgs,
+    cwd
+  };
+}
+
 // src/commands/sessions/daemon/createWatcherSession.ts
-import { randomUUID as randomUUID24 } from "crypto";
-var WATCH_PROMPT = "/watch";
+var WATCHER_ARGS = ["watch", "loop"];
 function createWatcherSession(id, cwd) {
-  const claudeSessionId = randomUUID24();
   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,
-    auto: true,
+    ...createAssistSession(id, WATCHER_ARGS, cwd),
     watcher: true
   };
 }
@@ -44378,7 +44490,7 @@ function ensureWatcher(ctx, cwd) {
     { inPlace: true }
   );
   daemonLog(
-    `spawned watcher session ${id} running /watch in the clone ${clone}`
+    `spawned watcher session ${id} running assist ${WATCHER_ARGS.join(" ")} in the clone ${clone}`
   );
   return id;
 }
@@ -45448,30 +45560,6 @@ function addAgentToStream(ctx, targetId, request) {
   };
 }
 
-// src/commands/sessions/daemon/createAssistSession.ts
-function createAssistSession(id, assistArgs, cwd, meta, holdPty) {
-  const startedAt = Date.now();
-  return {
-    id,
-    name: `assist ${assistArgs.join(" ")}`,
-    title: meta?.title,
-    subtitle: meta?.subtitle,
-    commandType: "assist",
-    status: "running",
-    startedAt,
-    runningMs: 0,
-    runningSince: startedAt,
-    waitingSince: null,
-    ...startOrHoldPty(
-      () => spawnPty(["assist", ...assistArgs], cwd, id),
-      holdPty
-    ),
-    scrollback: "",
-    assistArgs,
-    cwd
-  };
-}
-
 // src/commands/sessions/daemon/worktree/spawnInTree.ts
 function spawnInTree(ctx, { prompt, cwd, design, auto, harness, inPlace }, context) {
   return allocateAndBind(
@@ -45875,10 +45963,10 @@ var handleHelloRequest = (client, m, d) => {
 };
 
 // src/commands/sessions/daemon/creator.ts
-function creator(isNew, spawn10) {
+function creator(isNew, spawn11) {
   return (client, m, d) => {
     if (m.links.route(client, d)) return;
-    const result = spawn10(m, d);
+    const result = spawn11(m, d);
     if (typeof result !== "string") {
       sendTo(client, { type: "error", message: result.error });
       return;

package/package.json

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