@staff0rd/assist 0.764.0 → 0.765.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.764.0",
+  version: "0.765.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -39717,6 +39717,9 @@ function watchReport(options2) {
   }
 }
 
+// src/commands/watch/simulatedDivergenceNote.ts
+var simulatedDivergenceNote = "requested by assist watch simulate-divergence; nothing has actually diverged";
+
 // src/commands/watch/describeOutcome.ts
 var short = (sha) => sha.slice(0, 7);
 function describeOutcome(outcome) {
@@ -39734,7 +39737,7 @@ function describeOutcome(outcome) {
     case "simulated-divergence":
       return {
         exitCode: 3,
-        message: `simulated divergence from ${outcome.upstream} (requested by assist watch simulate-divergence; nothing has actually diverged)`
+        message: `simulated divergence from ${outcome.upstream} (${simulatedDivergenceNote})`
       };
     case "unavailable":
       return { exitCode: 1, message: `cannot wait: ${outcome.reason}` };
@@ -42204,6 +42207,39 @@ function dismissSessionGated(sessions, id, notify2, discard = false) {
   settle();
 }
 
+// src/commands/sessions/daemon/worktree/resumeWatcherAfterEscalation.ts
+var ENDED = ["done", "error"];
+function resumeWatcherAfterEscalation(sessions, escalation, restart) {
+  if (escalation.divergenceEscalation !== true || !escalation.cwd) return;
+  const clone = canonicalTreePath(escalation.cwd);
+  const watcher = [...sessions.values()].find(
+    (s) => s.watcher === true && s.cwd !== void 0 && canonicalTreePath(s.cwd) === clone
+  );
+  if (!watcher) {
+    daemonLog(
+      `escalation session ${escalation.id} ended (${escalation.status}): no watcher left in the clone ${clone} to restart`
+    );
+    return;
+  }
+  if (!ENDED.includes(watcher.status)) {
+    daemonLog(
+      `escalation session ${escalation.id} ended (${escalation.status}): watcher session ${watcher.id} in the clone ${clone} is already ${watcher.status}`
+    );
+    return;
+  }
+  daemonLog(
+    `escalation session ${escalation.id} ended (${escalation.status}): restarting watcher session ${watcher.id} in the clone ${clone}`
+  );
+  restart(watcher.id);
+}
+
+// src/commands/sessions/daemon/dismissAndResumeWatcher.ts
+function dismissAndResumeWatcher(sessions, id, notify2, restart) {
+  const session = sessions.get(id);
+  dismissSessionGated(sessions, id, notify2);
+  if (session) resumeWatcherAfterEscalation(sessions, session, restart);
+}
+
 // src/commands/sessions/daemon/drainSessions.ts
 function drainSessions(sessions, notify2) {
   const drained = [...sessions.values()].map((s) => ({
@@ -43755,6 +43791,7 @@ function finishStatusChange(session, status2, exitCode, deps2) {
   if (status2 !== "stopped") session.undurable = void 0;
   if (session.watcher === true && exitCode === DIVERGED_EXIT_CODE)
     deps2.escalateDivergence?.(session);
+  if (status2 === "done" || status2 === "error") deps2.resumeWatcher?.(session);
   const autoRun = shouldAutoRun(session);
   if (autoRun.run) {
     deps2.reuseForRun(session, autoRun.itemId);
@@ -44105,112 +44142,6 @@ function reuseSessionForRun(session, itemId2, clients, onStatusChange, tree) {
   );
 }
 
-// src/commands/sessions/daemon/worktree/divergencePrompt.ts
-var MAX_REASON_LINES = 20;
-var MAX_REASON_CHARS = 2e3;
-function divergencePrompt(clone, scrollback) {
-  const reason4 = stripAnsi(scrollback).split(/\r?\n|\r/).map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).slice(-MAX_REASON_LINES).join("\n").slice(-MAX_REASON_CHARS);
-  return [
-    `The watcher in ${clone} stopped because \`assist watch wait --pull --build\` could not fast-forward the branch (exit 3). The tail of its output:`,
-    "",
-    "```",
-    reason4 || "(no output captured)",
-    "```",
-    "",
-    "Diagnose why the local branch has diverged from its upstream and report what you find and the options for reconciling it. Do not force-push, `git reset`, or otherwise discard commits on either side \u2014 leave the decision to the user."
-  ].join("\n");
-}
-
-// src/commands/sessions/daemon/worktree/escalateDivergence.ts
-var ENDED = ["done", "error", "stopped"];
-function escalateDivergence(ctx, watcher) {
-  if (!watcher.cwd) return void 0;
-  const clone = canonicalTreePath(watcher.cwd);
-  const live = [...ctx.sessions.values()].find(
-    (s) => s.divergenceEscalation === true && s.cwd !== void 0 && canonicalTreePath(s.cwd) === clone && !ENDED.includes(s.status)
-  );
-  if (live) {
-    daemonLog(
-      `watcher session ${watcher.id} exited 3 (divergence) in the clone ${clone}: no escalation spawned, session ${live.id} is already diagnosing it (${live.status})`
-    );
-    return void 0;
-  }
-  const prompt = divergencePrompt(clone, watcher.scrollback);
-  const id = allocateAndBind(
-    ctx,
-    clone,
-    (sid, resolvedCwd) => ({
-      ...createSession(sid, { prompt, cwd: resolvedCwd ?? clone }),
-      divergenceEscalation: true
-    }),
-    { inPlace: true }
-  );
-  daemonLog(
-    `watcher session ${watcher.id} exited 3 (divergence) in the clone ${clone}: spawned escalation session ${id} to diagnose it`
-  );
-  return id;
-}
-
-// src/commands/sessions/daemon/managerStatusChangeHandler.ts
-function managerStatusChangeHandler(sessions, clients, dismiss, notify2, treeCtx) {
-  const handler = makeStatusChangeHandler(sessions, {
-    dismiss,
-    notify: notify2,
-    reuseForRun: (session, itemId2) => reuseSessionForRun(session, itemId2, clients, handler, treeCtx()),
-    escalateDivergence: (watcher) => escalateDivergence(treeCtx(), watcher)
-  });
-  return handler;
-}
-
-// src/commands/sessions/daemon/applySetStatus.ts
-function applySetStatus(sessions, id, status2, source, onStatusChange, rebind) {
-  const session = sessions.get(id);
-  if (!session) {
-    daemonLog(
-      `set-status for unknown session id=${id} status=${status2} (no live session; ignoring)`
-    );
-    return;
-  }
-  if (session.status === "stopped") {
-    daemonLog(
-      `set-status for stopped session id=${id} status=${status2} (held pending durable close; ignoring)`
-    );
-    return;
-  }
-  rebind?.(session);
-  if (source === "permission") session.permissionActive = true;
-  if (status2 === "running") session.permissionActive = false;
-  onStatusChange(session, status2);
-}
-
-// src/commands/sessions/daemon/rebindClaudeSession.ts
-function rebindClaudeSession(session, claudeSessionId, notify2, onStatusChange) {
-  if (!claudeSessionId) return;
-  if (session.claudeSessionId === claudeSessionId) return;
-  daemonLog(
-    `session ${session.id} claude session moved: ${session.claudeSessionId ?? "none"} -> ${claudeSessionId}`
-  );
-  session.claudeSessionId = claudeSessionId;
-  watchTranscript(session, notify2, onStatusChange);
-}
-
-// src/commands/sessions/daemon/setStatusFromHook.ts
-function setStatusFromHook(sessions, report, notify2, onStatusChange) {
-  applySetStatus(
-    sessions,
-    report.id,
-    report.status,
-    report.source,
-    onStatusChange,
-    (session) => rebindClaudeSession(
-      session,
-      report.claudeSessionId,
-      notify2,
-      onStatusChange
-    )
-  );
-}
-
 // src/commands/sessions/daemon/respawnSession.ts
 function respawnSession(session, respawn, status2, clients, onStatusChange) {
   session.gitWatcher?.close();
@@ -44407,6 +44338,134 @@ function restartManagedSession(sessions, id, clients, onStatusChange) {
   return { ok: true };
 }
 
+// src/commands/sessions/daemon/worktree/divergencePrompt.ts
+var MAX_REASON_LINES = 20;
+var MAX_REASON_CHARS = 2e3;
+var RECONCILE_STEPS = [
+  "Reconcile it yourself, without discarding any commits on either side:",
+  "",
+  "1. Inspect `git status`, `git log --oneline @{u}..@` and `git log --oneline @..@{u}`.",
+  '2. Stash any uncommitted work with `git stash push -u -m "assist divergence"`, and restore it with `git stash pop` once the branch is reconciled.',
+  "3. Rebase the local commits onto the upstream with `git rebase @{u}`, resolving conflicts so both sides' changes survive. If the rebase cannot be resolved cleanly, `git rebase --abort` and `git merge @{u}` instead.",
+  "4. Push the result with a plain `git push` so the branch matches its upstream again.",
+  "5. Build the clone with `assist run auto-build`.",
+  "6. Run /close. The daemon restarts the watcher once this session closes.",
+  "",
+  "Never force-push, `git reset`, or otherwise discard commits. If you cannot reconcile the branch without doing so, explain what is blocking it and leave this session open for the user instead of closing it."
+];
+var SIMULATED_STEPS = [
+  "This divergence was simulated to test the escalation; there is nothing to reconcile. Run /close now. The daemon restarts the watcher once this session closes."
+];
+function divergenceReason(scrollback) {
+  return stripAnsi(scrollback).split(/\r?\n|\r/).map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).slice(-MAX_REASON_LINES).join("\n").slice(-MAX_REASON_CHARS);
+}
+function divergencePrompt(clone, scrollback) {
+  const reason4 = divergenceReason(scrollback);
+  return [
+    `The watcher in ${clone} stopped because \`assist watch wait --pull --build\` could not fast-forward the branch (exit 3). The tail of its output:`,
+    "",
+    "```",
+    reason4 || "(no output captured)",
+    "```",
+    "",
+    ...reason4.includes(simulatedDivergenceNote) ? SIMULATED_STEPS : RECONCILE_STEPS
+  ].join("\n");
+}
+
+// src/commands/sessions/daemon/worktree/escalateDivergence.ts
+var ENDED2 = ["done", "error", "stopped"];
+function escalateDivergence(ctx, watcher) {
+  if (!watcher.cwd) return void 0;
+  const clone = canonicalTreePath(watcher.cwd);
+  const live = [...ctx.sessions.values()].find(
+    (s) => s.divergenceEscalation === true && s.cwd !== void 0 && canonicalTreePath(s.cwd) === clone && !ENDED2.includes(s.status)
+  );
+  if (live) {
+    daemonLog(
+      `watcher session ${watcher.id} exited 3 (divergence) in the clone ${clone}: no escalation spawned, session ${live.id} is already diagnosing it (${live.status})`
+    );
+    return void 0;
+  }
+  const prompt = divergencePrompt(clone, watcher.scrollback);
+  const id = allocateAndBind(
+    ctx,
+    clone,
+    (sid, resolvedCwd) => ({
+      ...createSession(sid, { prompt, cwd: resolvedCwd ?? clone }),
+      divergenceEscalation: true
+    }),
+    { inPlace: true }
+  );
+  daemonLog(
+    `watcher session ${watcher.id} exited 3 (divergence) in the clone ${clone}: spawned escalation session ${id} to diagnose it`
+  );
+  return id;
+}
+
+// src/commands/sessions/daemon/managerStatusChangeHandler.ts
+function managerStatusChangeHandler(sessions, clients, dismiss, notify2, treeCtx) {
+  const handler = makeStatusChangeHandler(sessions, {
+    dismiss,
+    notify: notify2,
+    reuseForRun: (session, itemId2) => reuseSessionForRun(session, itemId2, clients, handler, treeCtx()),
+    escalateDivergence: (watcher) => escalateDivergence(treeCtx(), watcher),
+    resumeWatcher: (escalation) => resumeWatcherAfterEscalation(sessions, escalation, (watcherId) => {
+      if (restartManagedSession(sessions, watcherId, clients, handler).ok)
+        notify2();
+    })
+  });
+  return handler;
+}
+
+// src/commands/sessions/daemon/applySetStatus.ts
+function applySetStatus(sessions, id, status2, source, onStatusChange, rebind) {
+  const session = sessions.get(id);
+  if (!session) {
+    daemonLog(
+      `set-status for unknown session id=${id} status=${status2} (no live session; ignoring)`
+    );
+    return;
+  }
+  if (session.status === "stopped") {
+    daemonLog(
+      `set-status for stopped session id=${id} status=${status2} (held pending durable close; ignoring)`
+    );
+    return;
+  }
+  rebind?.(session);
+  if (source === "permission") session.permissionActive = true;
+  if (status2 === "running") session.permissionActive = false;
+  onStatusChange(session, status2);
+}
+
+// src/commands/sessions/daemon/rebindClaudeSession.ts
+function rebindClaudeSession(session, claudeSessionId, notify2, onStatusChange) {
+  if (!claudeSessionId) return;
+  if (session.claudeSessionId === claudeSessionId) return;
+  daemonLog(
+    `session ${session.id} claude session moved: ${session.claudeSessionId ?? "none"} -> ${claudeSessionId}`
+  );
+  session.claudeSessionId = claudeSessionId;
+  watchTranscript(session, notify2, onStatusChange);
+}
+
+// src/commands/sessions/daemon/setStatusFromHook.ts
+function setStatusFromHook(sessions, report, notify2, onStatusChange) {
+  applySetStatus(
+    sessions,
+    report.id,
+    report.status,
+    report.source,
+    onStatusChange,
+    (session) => rebindClaudeSession(
+      session,
+      report.claudeSessionId,
+      notify2,
+      onStatusChange
+    )
+  );
+}
+
 // src/commands/sessions/daemon/restartAndNotify.ts
 function restartAndNotify(sessions, id, clients, onStatusChange, notify2) {
   const result = restartManagedSession(sessions, id, clients, onStatusChange);
@@ -46487,7 +46546,12 @@ var SessionManager = class {
     );
   }
   dismissSession = (id) => {
-    dismissSessionGated(this.sessions, id, this.notify);
+    dismissAndResumeWatcher(
+      this.sessions,
+      id,
+      this.notify,
+      (watcherId) => this.restart(watcherId)
+    );
   };
   discardSession = (id) => {
     dismissSessionGated(this.sessions, id, this.notify, true);

package/package.json

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