@saadnvd1/agent-os 0.3.639 → 0.3.646

package/lib/orchestrator/review.ts

@@ -24,7 +24,8 @@ import { runClaude, type ClaudeRunner } from "./claude-cli";
 import { changedFiles, fullDiff } from "./diff";
 import { diffParts } from "./diff-parts";
 import { countFailure, escalate } from "./escalate";
-import { checkGate, holdingEscalations } from "./gates";
+import { checkGate, holdingEscalations, recordPass } from "./gates";
+import { reasonSignature, reviewSignature } from "./loop-guard";
 import { reviewWanted } from "./held-review";
 import { mergeApprovalsOn, mergeApprovalsSetting } from "./merge-approvals";
 import {
@@ -222,10 +223,19 @@ function countVerdicts(
   const escalated: string[] = [];
   for (const gate of ["review", "scope"] as const) {
     if (gate === "scope" && !target.task?.lh_card_id) continue;
-    const o = checkGate(gate, getCheck(target.id, sha, gate), sha);
+    const row = getCheck(target.id, sha, gate);
+    const o = checkGate(gate, row, sha);
+    if (o.state === "pass") recordPass(target.id, gate);
     if (o.state !== "fail") continue;
     try {
-      if (countFailure(workspaceId, target, o, target.pr.url, sha).escalated)
+      const signature =
+        gate === "review"
+          ? reviewSignature(row?.detail ?? null)
+          : reasonSignature(row?.detail);
+      if (
+        countFailure(workspaceId, target, o, target.pr.url, sha, { signature })
+          .escalated
+      )
         escalated.push(gate);
     } catch (e) {
       // The verdict's event still goes out; sign_off counts it again.
@@ -233,7 +243,7 @@ function countVerdicts(
     }
   }
   return escalated.length
-    ? `; the ${escalated.join(" and ")} gate failed twice, so it's with Saad now`
+    ? `; the ${escalated.join(" and ")} gate is stuck in a loop (the loop guard), so it's with Saad now`
     : "";
 }
 

package/lib/orchestrator/signoff.test-helpers.ts

@@ -0,0 +1,322 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execFileSync } from "child_process";
+import { beforeAll, beforeEach, expect, vi } from "vitest";
+import type { TaskPR } from "@/lib/tasks/state";
+import type { ClaudeRun } from "./claude-cli";
+import type { SessionFacts } from "./facts";
+
+// Shared fixtures for the signoff*.test.ts files: a real repository with a
+// local bare remote, gh faked around it. Import this before anything it mocks.
+// Tests change the fake world through S.
+export const S: {
+  pr: TaskPR | null;
+  prError: Error | null;
+  pane: string;
+  refuseMerge: string | null;
+  probeOut: string | Error;
+  ciLog: string;
+  commitDate: string | undefined;
+} = {
+  pr: null,
+  prError: null,
+  pane: "",
+  refuseMerge: null,
+  probeOut: "0",
+  ciLog:
+    "Test 1\tRun tests\t2026-01-01T00:00:00.0Z  FAIL  src/a.test.ts > adds\n",
+  commitDate: "2026-01-01T00:00:00Z",
+};
+export const ATTRIBUTED = "a Co-Authored-By trailer naming Claude" as const;
+export const merges: string[][] = [];
+export const JOB_URL = "https://github.com/o/r/actions/runs/1/job/2";
+// CI failing on the head, with a log the loop guard can read.
+export const failingCI = (failing = "unit") =>
+  ({ ...S.pr!, checks: "fail", failing, failingUrl: JOB_URL }) as TaskPR;
+export const isProbe = (args: string[]) =>
+  args[0] === "api" ||
+  (args[0] === "pr" &&
+    args[1] === "list" &&
+    args.includes("statusCheckRollup"));
+
+vi.mock("@/lib/tasks/gh", async (importOriginal) => {
+  const real = await importOriginal<typeof import("@/lib/tasks/gh")>();
+  return {
+    ...real,
+    run: async (cmd: string, args: string[], cwd: string, t?: number) => {
+      if (cmd === "gh" && args[0] === "run" && args[1] === "view")
+        return S.ciLog;
+      if (cmd === "gh" && isProbe(args)) {
+        if (S.probeOut instanceof Error) throw S.probeOut;
+        return S.probeOut;
+      }
+      if (cmd === "gh") {
+        if (S.refuseMerge) throw new Error(S.refuseMerge);
+        merges.push(args);
+        if (S.pr) S.pr = { ...S.pr, state: "MERGED" };
+        return "";
+      }
+      if (cmd === "tmux") throw new Error("no tmux in tests");
+      return real.run(cmd, args, cwd, t);
+    },
+    findPR: async () => S.pr,
+    findPRStrict: async () => {
+      if (S.prError) throw S.prError;
+      return S.pr;
+    },
+  };
+});
+// The test clones have a local origin; the CI probes need a GitHub name.
+vi.mock("./repo-slug", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("./repo-slug")>()),
+  repoSlug: async () => "o/r",
+}));
+vi.mock("@/lib/status-detector", () => ({
+  checkWaitingPatterns: (t: string) => /Allow\?/.test(t),
+  statusDetector: {
+    refreshCache: async () => {},
+    sessionExists: () => S.pane !== "",
+    getStatus: async () => "idle",
+    titleFor: () => "",
+    getTimestamp: () => 0,
+    hostFor: () => "local",
+    capturePane: async () => S.pane,
+  },
+}));
+
+export const { db, stackQueries, updateSessionRow } = await import("@/lib/db");
+export const { createProject } = await import("@/lib/projects");
+export const { createWorkspace, setProjectWorkspace } =
+  await import("@/lib/workspaces");
+export const { ensureOrchestrator } = await import("./home");
+export const { runTool } = await import("./serve");
+export const { judge, landDeps, mergeJudged, refundIfRefused } =
+  await import("./signoff");
+export const { armTask, mergeArmed } = await import("./armed");
+export const { resumeReviews, review } = await import("./review");
+export const { getCheck, putCheck } = await import("./checks");
+export const { failureOf, recordFailure } = await import("./gates");
+export const { LOOP_GUARD_COMMITS } = await import("./loop-guard");
+export const { clearRepoCI } = await import("./repo-ci");
+export const { listNotes } = await import("./notes");
+export const { listItems } = await import("@/lib/chat/store");
+export const { claudeArgs } = await import("./claude-cli");
+export const { seedSession } = await import("./testing");
+export const { answerAsk, getAsk, openAsks, raiseAsk, BRAKE_SUBJECT } =
+  await import("./asks");
+export const { setMergeApprovals } = await import("./merge-approvals");
+export const { releaseInterruptedClaims, spendApproval } =
+  await import("./ask-approvals");
+export const { amendBrief } = await import("./amendments");
+export const { fetchRefs } = await import("./repo");
+export const { getTaskSession } = await import("@/lib/tasks/session");
+export const { changedFiles } = await import("./diff");
+export const { followAskHeads } = await import("./ask-heads");
+export const { followAskVerdicts } = await import("./ask-verdict");
+export const { raiseHeldAsks, HOLD_MIN_MS, HOLD_MAX_MS } =
+  await import("./held-asks");
+
+// The one ask a task's escalation leaves on Saad's list.
+export function oneGateAsk(w: string, task: string, sha: string) {
+  const asks = openAsks(w);
+  expect(asks).toHaveLength(1);
+  expect(asks[0]).toMatchObject({
+    subject: `task:${task}`,
+    kind: "gate",
+    title: "Merge add-a?",
+    link: "https://github.com/o/r/pull/7",
+    sha,
+  });
+  return asks[0];
+}
+
+// The loop guard's last strike: the gate already failed on the commits
+// before this one.
+export const failedBefore = (w: string, task: string, gate: string) => {
+  for (let i = 1; i < LOOP_GUARD_COMMITS; i++)
+    recordFailure(w, task, gate, `earlier ${i}`, String(i).repeat(40));
+};
+
+// Facts for the task: its agent idle, or busy.
+export const taskFacts = (task: string, status: "idle" | "running" = "idle") =>
+  [
+    { id: task, name: "add-a", status, task: { state: "review", pr: S.pr } },
+  ] as unknown as SessionFacts[];
+
+// A failed-twice escalation's ask goes up once the agent is idle and CI
+// has settled; `after` ms from now.
+// The first look at a head's checks starts CI's settle clock, so it looks
+// twice, the second a settle period later.
+export const askUp = async (
+  w: string,
+  task: string,
+  after = HOLD_MIN_MS + 1000,
+  status: "idle" | "running" = "idle"
+) => {
+  await raiseHeldAsks(w, taskFacts(task, status), Date.now() + after);
+  await raiseHeldAsks(w, taskFacts(task, status), Date.now() + after + 200_000);
+};
+
+// Poll for the condition, generously: a loaded machine is slow, not wrong.
+export const POLL = { timeout: 20000, interval: 20 };
+
+beforeAll(() => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "aos-orch-signoff-"));
+  vi.spyOn(os, "homedir").mockReturnValue(home);
+});
+beforeEach(() => {
+  merges.length = 0;
+  S.refuseMerge = null;
+  S.probeOut = "0";
+  S.ciLog =
+    "Test 1\tRun tests\t2026-01-01T00:00:00.0Z  FAIL  src/a.test.ts > adds\n";
+  clearRepoCI();
+  // A live terminal at its prompt, nothing waiting.
+  S.pane = "❯ ";
+});
+
+export const git = (cwd: string, ...args: string[]) =>
+  execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: "pipe",
+    env: {
+      ...process.env,
+      ...(S.commitDate ? { GIT_COMMITTER_DATE: S.commitDate } : {}),
+    },
+  }).trim();
+
+export function commit(
+  repo: string,
+  file: string,
+  text: string,
+  link?: string
+): string {
+  fs.mkdirSync(path.dirname(path.join(repo, file)), { recursive: true });
+  if (link) fs.symlinkSync(link, path.join(repo, file));
+  else fs.writeFileSync(path.join(repo, file), text);
+  git(repo, "add", "-A");
+  git(repo, "commit", "-qm", `change ${file}`);
+  git(repo, "push", "-q", "origin", "HEAD");
+  return git(repo, "rev-parse", "HEAD");
+}
+
+// A workspace whose project is a real clone, with a task on its branch
+// and its PR open at the branch's head.
+export function setup(
+  opts: {
+    card?: boolean;
+    onMain?: Array<[string, string]>;
+    approvals?: boolean;
+  } = {}
+) {
+  setMergeApprovals(opts.approvals ?? false);
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "aos-orch-repo-"));
+  const remote = path.join(root, "remote.git");
+  const repo = path.join(root, "repo");
+  git(root, "init", "-q", "--bare", "-b", "main", remote);
+  git(root, "clone", "-q", remote, repo);
+  git(repo, "config", "user.email", "t@example.com");
+  git(repo, "config", "user.name", "T");
+  commit(repo, "README.md", "hello\n");
+  for (const file of opts.onMain ?? []) commit(repo, ...file);
+  git(repo, "checkout", "-qb", "feature/t");
+  const sha = commit(repo, "src/a.ts", "export const a = 1;\n");
+
+  const workspace = createWorkspace(`ws-${path.basename(root)}`);
+  const project = createProject({
+    name: `app-${path.basename(root)}`,
+    workingDirectory: repo,
+  });
+  setProjectWorkspace(project.id, workspace.id);
+  ensureOrchestrator(workspace.id);
+  const task = seedSession({
+    projectId: project.id,
+    name: "add-a",
+    task: true,
+    branch: "feature/t",
+  });
+  updateSessionRow(db, task, {
+    base_branch: "main",
+    task_prompt: "Add a",
+    lh_card_id: opts.card ? "card-1" : null,
+    pr_number: 7,
+  });
+  S.pr = {
+    number: 7,
+    url: "https://github.com/o/r/pull/7",
+    state: "OPEN",
+    checks: "pass",
+    head: sha,
+    failing: null,
+    checkCount: 1,
+    attribution: null,
+  };
+  const w = workspace.id;
+  // CI has looked settled on every head for a while.
+  const settled = () =>
+    putCheck({
+      workspaceId: w,
+      sessionId: task,
+      sha: S.pr!.head!,
+      kind: "ci",
+      status: "pass",
+      detail: JSON.stringify({ count: S.pr!.checkCount, at: 0 }),
+    });
+  return {
+    w,
+    repo,
+    task,
+    sha,
+    signOff: (settle = true) => {
+      if (settle) settled();
+      return runTool(w, "sign_off", { task: "add-a" });
+    },
+    push: (file: string, text: string, link?: string) => {
+      const next = commit(repo, file, text, link);
+      S.pr = { ...S.pr!, head: next };
+      return next;
+    },
+  };
+}
+
+// A reviewer that answers without a model, and remembers how it was run.
+export function reviewer(verdict: "pass" | "block", within = true) {
+  const runs: ClaudeRun[] = [];
+  const claude = async (run: ClaudeRun) => {
+    runs.push(run);
+    if (!run.tools.length)
+      return {
+        within,
+        reason: within ? "matches the card" : "adds billing, not on the card",
+      };
+    return verdict === "pass"
+      ? { verdict, summary: "Looks right.", findings: [] }
+      : {
+          verdict,
+          summary: "One bug.",
+          findings: [
+            {
+              severity: "blocking",
+              file: "src/a.ts",
+              line: 1,
+              summary: "off by one",
+            },
+          ],
+        };
+  };
+  return { claude, runs };
+}
+
+export const reviewNow = (
+  w: string,
+  verdict: "pass" | "block" = "pass",
+  within = true
+) => {
+  const r = reviewer(verdict, within);
+  return review(w, "add-a", { wait: true, claude: r.claude }).then((text) => ({
+    text,
+    runs: r.runs,
+  }));
+};

package/lib/orchestrator/signoff.ts

@@ -4,8 +4,9 @@
  * anything touching CI config, build and hook scripts, agent config, deploys
  * or secrets handling goes to Saad whatever the gates say. A repository with
  * no CI (decided from the repository, never from one head with no checks)
- * and a gate failing on two different commits go to him either way. Once a
- * task is with Saad the orchestrator doesn't merge it; he signs it off or drops it.
+ * and a task the loop guard finds stuck (loop-guard.ts) go to him either
+ * way. Once a task is with Saad the orchestrator doesn't merge it; he signs
+ * it off or drops it.
  */
 
 import { MERGED_AS, type MergeMethod } from "../tasks/merge-policy";
@@ -28,9 +29,17 @@ import { countFailure, escalate } from "./escalate";
 import {
   ciGate,
   evaluateGates,
+  failureCounted,
   holdingEscalations,
+  recordPass,
   type GateInput,
+  type GateOutcome,
 } from "./gates";
+import {
+  readCiSignature,
+  reasonSignature,
+  reviewSignature,
+} from "./loop-guard";
 import { addNote } from "./notes";
 import { latestApproval, refundApproval, spendApproval } from "./ask-approvals";
 import { workSubject } from "./asks";
@@ -121,6 +130,7 @@ export async function judge(
     async () => ({
       checks: pr.checks,
       failing: pr.failing,
+      failingUrl: pr.failingUrl,
       settleIn: ciSettleIn({
         workspaceId,
         taskId: task.id,
@@ -257,17 +267,43 @@ export async function gateVerdict(
   const waiting = outcomes.filter((o) => o.state === "wait");
   if (!failed.length && !waiting.length)
     return { ok: true, sha, pr: pr.number };
-  const lines = [
-    ...failed.map((o) =>
-      opts.count === false
-        ? `- ${o.gate} failed: ${o.reason}`
-        : countFailure(workspaceId, work, o, pr.url, sha).line
-    ),
-    ...waiting.map((o) => `- ${o.gate}: not yet, ${o.reason}`),
-  ];
+  const lines: string[] = [];
+  if (opts.count === false)
+    lines.push(...failed.map((o) => `- ${o.gate} failed: ${o.reason}`));
+  else {
+    for (const o of outcomes)
+      if (o.state === "pass") recordPass(work.id, o.gate);
+    for (const o of failed) {
+      const signature = await failureSignature(work, o, live);
+      lines.push(
+        countFailure(workspaceId, work, o, pr.url, sha, { signature }).line
+      );
+    }
+  }
+  lines.push(...waiting.map((o) => `- ${o.gate}: not yet, ${o.reason}`));
   return no(`${head}\n${lines.join("\n")}`, !failed.length);
 }
 
+// What the loop guard compares between this failure and the one before.
+// The CI log is read once per head: a head already counted needs none.
+async function failureSignature(
+  work: GateWork,
+  o: GateOutcome,
+  i: Omit<GateInput, "sha" | "ruleBreaks">
+): Promise<string | null> {
+  if (o.gate === "review") return reviewSignature(i.review?.detail ?? null);
+  if (o.gate === "scope" && i.scope?.status === "block")
+    return reasonSignature(i.scope.detail);
+  if (o.gate !== "ci" || i.checks !== "fail") return reasonSignature(o.reason);
+  if (failureCounted(work.id, "ci", work.sha)) return null;
+  return readCiSignature({
+    repo: work.repo,
+    prUrl: work.pr.url,
+    failing: i.failing,
+    failingUrl: i.failingUrl,
+  });
+}
+
 // Asked only when it can change the answer: a head with no checks that
 // isn't settling or conflicting.
 async function repoCIFor(

package/lib/orchestrator/testing.ts

@@ -2,7 +2,7 @@
 // test database.
 
 import { randomUUID } from "crypto";
-import { db } from "../db";
+import { db, insertSessionRow } from "../db";
 import { saveItem } from "../chat/store";
 import { createProject } from "../projects";
 import { createWorkspace, setProjectWorkspace } from "../workspaces";
@@ -16,20 +16,17 @@ export function seedSession(opts: {
   updatedAt?: string;
 }): string {
   const id = randomUUID();
-  db.prepare(
-    `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id, view,
-       task_status, branch_name, updated_at)
-     VALUES (?, ?, ?, '/tmp', ?, ?, ?, ?, COALESCE(?, datetime('now')))`
-  ).run(
+  insertSessionRow(db, {
     id,
-    opts.name,
-    `claude-${id}`,
-    opts.projectId,
-    opts.view ?? "terminal",
-    opts.task ? "running" : null,
-    opts.branch ?? null,
-    opts.updatedAt ?? null
-  );
+    name: opts.name,
+    tmux_name: `claude-${id}`,
+    working_directory: "/tmp",
+    project_id: opts.projectId,
+    view: opts.view ?? "terminal",
+    task_status: opts.task ? "running" : null,
+    branch_name: opts.branch ?? null,
+    updated_at: opts.updatedAt,
+  });
   return id;
 }
 

package/lib/orchestrator/watcher.ts

@@ -18,6 +18,7 @@ import { settleStaleAsks } from "./ask-settle";
 import { brakesOn, liftBrake } from "./brakes";
 import { anyArmed, mergeArmed } from "./armed";
 import { followAskHeads } from "./ask-heads";
+import { followAskVerdicts } from "./ask-verdict";
 import { raiseHeldAsks } from "./held-asks";
 import { rebaseConflicting } from "./rebase";
 import { wakeTasks } from "./pr-wake";
@@ -91,6 +92,9 @@ function mergePipeline(workspaceId: string, facts: SessionFacts[]): void {
     await raiseHeldAsks(workspaceId, facts).catch((error) =>
       console.error(`Raising held asks in ${workspaceId}:`, error)
     );
+    await followAskVerdicts(workspaceId, facts).catch((error) =>
+      console.error(`Judging asked commits in ${workspaceId}:`, error)
+    );
     await rebaseConflicting(workspaceId, facts);
     await mergeArmed(workspaceId, facts);
   })()

package/lib/recipes/test-fixtures.ts

@@ -2,7 +2,7 @@
 // them, and a session standing in for a run's.
 
 import { randomUUID } from "crypto";
-import { db } from "../db";
+import { db, updateSessionRow } from "../db";
 import { createProject } from "../projects";
 import { createWorkspace, setProjectWorkspace } from "../workspaces";
 import { createRecipe } from "./store";
@@ -43,7 +43,6 @@ export function makeSession(
   db.prepare(
     `INSERT INTO sessions (id, name, tmux_name, working_directory, view) VALUES (?, 's', ?, '/tmp', 'chat')`
   ).run(id, `claude-${id}`);
-  for (const [k, v] of Object.entries(fields))
-    db.prepare(`UPDATE sessions SET ${k} = ? WHERE id = ?`).run(v, id);
+  updateSessionRow(db, id, fields);
   return id;
 }

package/lib/resurrect/index.ts

@@ -44,6 +44,8 @@ import { launchClaude } from "../agents/launch";
 import { PLAN_FILE, preparePlanDir } from "../models/plan-step";
 import { planFromTranscript } from "./plan";
 import { dropSnapshot, restoreWorktree, type RestoredAs } from "./snapshot";
+import { restoreSwept, sweptNote } from "./swept";
+import { forgetSwept } from "../worktree-sweep/store";
 import { setPr, setTask } from "../db/session-parts";
 
 export interface ResurrectOptions {
@@ -69,6 +71,7 @@ const ENDED_TASK = new Set(["dropped", "done"]);
 // Restores in flight here, so two clicks can't both build a worktree.
 const g = globalThis as unknown as { __agentosResurrecting?: Set<string> };
 const inFlight = (g.__agentosResurrecting ??= new Set());
+export const restoring = (id: string) => inFlight.has(id);
 
 interface PrInfo {
   number: number;
@@ -124,12 +127,22 @@ export async function resurrectSession(
   // restoring it is the whole of it.
   if (!endedTask || (s.archived_at && s.task_status !== "dropped")) {
     if (s.archived_at) {
+      const swept = await restoreSwept(s);
       unarchiveSession(id);
-      return outcome(s, "unarchived", `${s.name} is back in the sidebar.`);
+      return outcome(
+        s,
+        "unarchived",
+        `${s.name} is back in the sidebar${swept ? `; ${swept}` : ""}.`
+      );
     }
     if (s.settled_at) {
+      const swept = await restoreSwept(s);
       reopenSession(id);
-      return outcome(s, "reopened", `${s.name} reopened.`);
+      return outcome(
+        s,
+        "reopened",
+        `${s.name} reopened${swept ? `; ${swept}` : ""}.`
+      );
     }
     throw new Error(`${s.name} isn't dropped, done or archived.`);
   }
@@ -357,6 +370,11 @@ async function bringBack(
   if (restored && after.view !== "chat") await relaunch(after, restored.path);
   syncTaskCardInBackground(after, "working", null);
   void dropSnapshot(repo, s.id);
+  const swept = sweptNote(s.id);
+  if (swept) {
+    notes.unshift(swept);
+    forgetSwept(s.id);
+  }
   const text = `${s.name} is back${restored ? ` in ${restored.path}` : ""}${reopened ? `, PR #${reopened} reopened` : ""}${notes.length ? `; ${notes.join("; ")}` : ""}.`;
   return outcome(s, "task", text, {
     worktree: restored?.mode ?? "chat-only",

package/lib/resurrect/swept.ts

@@ -0,0 +1,61 @@
+/**
+ * A session whose worktree the age clean-up removed: bringing it back
+ * recreates the worktree from its branch, or says plainly that it's gone.
+ */
+
+import fs from "fs";
+import { db, type Session } from "../db";
+import { getProject } from "../projects";
+import { expandHome, projectPathFor } from "../tasks/session";
+import { forgetSwept, sweptAt } from "../worktree-sweep/store";
+import { restoreWorktree } from "./snapshot";
+
+const day = (t: string) => t.slice(0, 10);
+
+// "its worktree was cleaned up on 2026-10-15" for a session the sweep removed
+// the worktree of; null for any other.
+export function sweptNote(id: string): string | null {
+  const at = sweptAt(id);
+  return at ? `its worktree was cleaned up on ${day(at)}` : null;
+}
+
+/**
+ * For a session coming back without a task restore (unarchive, reopen):
+ * rebuild a swept worktree. The note says what happened; null when the
+ * session wasn't swept or its worktree is still there.
+ */
+export async function restoreSwept(s: Session): Promise<string | null> {
+  const note = sweptNote(s.id);
+  if (!note || !s.worktree_path) return null;
+  const old = expandHome(s.worktree_path);
+  if (fs.existsSync(old)) {
+    forgetSwept(s.id);
+    return null;
+  }
+  const project = s.project_id ? getProject(s.project_id) : null;
+  const repo = project ? projectPathFor(s) : null;
+  const restored =
+    repo && s.branch_name && fs.existsSync(repo)
+      ? await restoreWorktree({
+          sessionId: s.id,
+          repo,
+          branch: s.branch_name,
+          base: s.base_branch,
+          oldPath: old,
+          allowFresh: false,
+        }).catch(() => null)
+      : null;
+  if (restored) {
+    db.prepare(
+      `UPDATE sessions SET worktree_path = ?, working_directory = ? WHERE id = ?`
+    ).run(restored.path, restored.path, s.id);
+    forgetSwept(s.id);
+    return `${note} and recreated from ${s.branch_name}`;
+  }
+  // No branch to build from: the conversation alone, in the project folder.
+  db.prepare(
+    `UPDATE sessions SET worktree_path = NULL, working_directory = ? WHERE id = ?`
+  ).run(repo ?? s.working_directory, s.id);
+  forgetSwept(s.id);
+  return `${note} and its branch is gone, so only the conversation came back`;
+}