@saadnvd1/agent-os 0.3.637 → 0.3.644

package/lib/resurrect/index.ts

@@ -17,7 +17,11 @@ import { unarchiveSession } from "../done/archive";
 import { reopenSession } from "../sidebar/shelf-state";
 import { peerSessionLink } from "../hosts/peer-actions";
 import { hostApi, hostLink } from "../hosts/remote-api";
-import { forgetHostTasks, isMirror, unknownOutcome } from "../tasks/remote";
+import {
+  forget as forgetHostTasks,
+  unknownOutcome,
+} from "../tasks/contract/client";
+import { isMirror } from "../tasks/contract/start";
 import { heldRefusal } from "../tasks/held";
 import { expandHome, projectPathFor } from "../tasks/session";
 import { run } from "../tasks/gh";
@@ -40,6 +44,9 @@ 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 {
   // The paired device asking: a task held for another machine's orchestrator
@@ -64,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;
@@ -119,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.`);
   }
@@ -157,9 +175,12 @@ async function onItsMachine(s: Session): Promise<ResurrectOutcome> {
         `/api/sessions/${encodeURIComponent(s.id)}/resurrect`,
         { body: {}, timeout: 120_000 }
       );
-      db.prepare(
-        `UPDATE sessions SET task_status = 'running' WHERE id = ? AND task_status IN ('dropped', 'done')`
-      ).run(s.id);
+      setTask(
+        db,
+        s.id,
+        { task_status: "running" },
+        { task_status: ["dropped", "done"] }
+      );
       forgetHostTasks(link.hostId);
       return outcome(
         s,
@@ -172,7 +193,7 @@ async function onItsMachine(s: Session): Promise<ResurrectOutcome> {
   }
   const before = db
     .prepare(
-      `SELECT * FROM sessions WHERE host_id = 'local' AND task_status = 'moved'
+      `SELECT * FROM session_rows WHERE host_id = 'local' AND task_status = 'moved'
          AND project_id IS ? AND branch_name IS ? ORDER BY updated_at DESC LIMIT 1`
     )
     .get(s.project_id, s.branch_name) as Session | undefined;
@@ -217,7 +238,7 @@ async function restoreTask(
   if (s.branch_name) {
     const busy = db
       .prepare(
-        `SELECT name FROM sessions WHERE project_id = ? AND branch_name = ? AND id != ?
+        `SELECT name FROM session_rows WHERE project_id = ? AND branch_name = ? AND id != ?
            AND task_status IN ('running', 'moving') AND host_id = 'local'`
       )
       .get(project.id, s.branch_name, s.id) as { name: string } | undefined;
@@ -238,11 +259,12 @@ async function restoreTask(
   if (inFlight.has(s.id))
     throw new Error(`${s.name} is being restored already.`);
   inFlight.add(s.id);
-  const claimed = db
-    .prepare(
-      `UPDATE sessions SET task_status = 'running', task_ended_at = NULL WHERE id = ? AND task_status = ?`
-    )
-    .run(s.id, prev).changes;
+  const claimed = setTask(
+    db,
+    s.id,
+    { task_status: "running", task_ended_at: null },
+    { task_status: prev }
+  );
   if (!claimed) {
     inFlight.delete(s.id);
     throw new Error(`${s.name} is being restored already.`);
@@ -250,9 +272,7 @@ async function restoreTask(
   try {
     return await bringBack(s, prev, repo, oldCwd, pr);
   } catch (err) {
-    db.prepare(
-      `UPDATE sessions SET task_status = ? WHERE id = ? AND task_status = 'running'`
-    ).run(prev, s.id);
+    setTask(db, s.id, { task_status: prev }, { task_status: "running" });
     throw err;
   } finally {
     inFlight.delete(s.id);
@@ -310,10 +330,11 @@ async function bringBack(
   if (!restored) {
     // Nothing to make a worktree from: the conversation alone, in the project.
     db.prepare(
-      `UPDATE sessions SET task_status = NULL, task_ended_at = NULL, worktree_path = NULL,
+      `UPDATE sessions SET worktree_path = NULL,
          working_directory = ?, settled_at = NULL, snoozed_until = NULL, snoozed_at = NULL,
          archived_at = NULL, active_at = datetime('now') WHERE id = ?`
     ).run(cwd, s.id);
+    setTask(db, s.id, { task_status: null, task_ended_at: null });
     notes.push(
       "its branch and worktree were gone, so only the conversation came back, in the project folder"
     );
@@ -335,9 +356,7 @@ async function bringBack(
     try {
       await gitPush(restored.path, ["-u", "origin", s.branch_name!]);
       await run("gh", ["pr", "reopen", String(pr.number)], repo);
-      db.prepare(`UPDATE sessions SET pr_status = 'open' WHERE id = ?`).run(
-        s.id
-      );
+      setPr(db, s.id, { pr_status: "open" });
       reopened = pr.number;
     } catch (err) {
       notes.push(
@@ -351,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`;
+}

package/lib/schedules/store.ts

@@ -163,7 +163,7 @@ export function findSchedule(ref: string): Schedule {
 
 export function getSessionRow(id: string): Session | null {
   return (
-    (db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    (db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
       | Session
       | undefined) ?? null
   );

package/lib/session-audit/sources.ts

@@ -81,7 +81,7 @@ export function loadSessions(
       `SELECT s.id, s.name, s.created_at, s.role, s.view, s.task_prompt,
               length(s.task_brief) AS task_brief_chars, s.working_directory,
               s.worktree_path, s.claude_session_id, s.workspace_id, p.name AS project
-         FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
+         FROM session_rows s LEFT JOIN projects p ON p.id = s.project_id
         WHERE coalesce(s.host_id, 'local') = 'local'`
     )
     .all() as SessionRow[];
@@ -297,8 +297,8 @@ export function loadSignals(
   }>(
     `SELECT m.from_id, m.to_id, m.body, f.role AS from_role, (t.task_prompt IS NOT NULL) AS to_task
        FROM bus_messages m
-       LEFT JOIN sessions f ON f.id = m.from_id
-       LEFT JOIN sessions t ON t.id = m.to_id
+       LEFT JOIN session_rows f ON f.id = m.from_id
+       LEFT JOIN session_rows t ON t.id = m.to_id
       WHERE m.created_at >= ? AND m.created_at < ?`,
     a,
     b

package/lib/session-logs/index.ts

@@ -120,7 +120,7 @@ export async function writeLog(
   id: string,
   opts: CaptureOpts & { plan?: string | null } = {}
 ): Promise<boolean> {
-  const row = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  const row = db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
   const existing = getLog(id);

package/lib/session-titles.ts

@@ -283,7 +283,7 @@ export function titleChatFromMessage(
 ): Promise<void> | void {
   const s = db
     .prepare(
-      `SELECT name, name_source, working_directory, task_prompt FROM sessions WHERE id = ?`
+      `SELECT name, name_source, working_directory, task_prompt FROM session_rows WHERE id = ?`
     )
     .get(sessionId) as
     | {

package/lib/sessions/setup-progress.ts

@@ -110,7 +110,7 @@ export function getSetup(sessionId: string): SetupView | null {
 function savedSetup(sessionId: string): string | null {
   const row = db
     .prepare(
-      `SELECT setup_status FROM sessions WHERE id = ? AND task_status IS NULL`
+      `SELECT setup_status FROM session_rows WHERE id = ? AND task_status IS NULL`
     )
     .get(sessionId) as { setup_status: string | null } | undefined;
   return row?.setup_status ?? null;

package/lib/sessions/stop.ts

@@ -2,7 +2,7 @@ import { endTmuxSession } from "../tmux/end";
 import { hostLink } from "../hosts/remote-api";
 import { stopChatTurn } from "../chat/stop";
 import type { Session } from "../db";
-import { isHeldRemote, stopHeldTask } from "../tasks/held-remote";
+import { isHeldRemote, stopHeldTask } from "../tasks/contract/held-calls";
 import { releaseOnEnd } from "../simulator";
 import { forgetPlanWait } from "../models/plan-step";
 

package/lib/sessions/worktree-setup.ts

@@ -175,7 +175,8 @@ export function failInterruptedSetups(): number {
            THEN COALESCE((SELECT working_directory FROM projects WHERE id = sessions.project_id), working_directory)
            ELSE working_directory END,
          setup_error = 'AgentOS restarted before setup finished. Your message is still queued: send it when you are ready.'
-       WHERE setup_status = 'running' AND task_status IS NULL`
+       WHERE setup_status = 'running'
+         AND id IN (SELECT id FROM session_rows WHERE task_status IS NULL)`
     )
     .run().changes;
 }

package/lib/simulator/index.ts

@@ -70,7 +70,7 @@ export { simulatorAvailable };
 export { shutTaskSimulators, shutFinishedTaskSimulators } from "./task-devices";
 
 const session = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
 

package/lib/simulator/task-devices.ts

@@ -148,7 +148,7 @@ export async function shutFinishedTaskSimulators(): Promise<number> {
       db
         .prepare(
           `SELECT id, branch_name, worktree_path, task_status, host_id
-           FROM sessions WHERE task_status IS NOT NULL`
+           FROM session_rows WHERE task_status IS NOT NULL`
         )
         .all() as (TaskRef & { host_id: string })[]
     ).filter((t) => !isRemoteHost(t.host_id));

package/lib/stacks/board.ts

@@ -44,7 +44,7 @@ export function toPlanCards(
 function runningTasks(boardId: string): Map<string, string> {
   const rows = db
     .prepare(
-      `SELECT id, lh_card_id FROM sessions
+      `SELECT id, lh_card_id FROM session_rows
        WHERE lh_board_id = ? AND lh_card_id IS NOT NULL AND task_status = 'running'`
     )
     .all(boardId) as Array<{ id: string; lh_card_id: string }>;

package/lib/stacks/land.ts

@@ -67,7 +67,7 @@ export const LAND_DEFAULTS: LandDeps = {
 
 const sessionOf = (id: string | null) =>
   (id
-    ? db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id)
+    ? db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id)
     : undefined) as Session | undefined;
 
 class Stop extends Error {}

package/lib/stacks/restack.ts

@@ -109,7 +109,7 @@ const defaults: RestackDeps = {
 
 const sessionOf = (id: string | null) =>
   id
-    ? ((db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    ? ((db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
         | Session
         | undefined) ?? null)
     : null;

package/lib/stacks/start.ts

@@ -25,7 +25,7 @@ async function stackedBase(
   item: StackItemRow
 ) {
   const session = db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(parent.session_id) as Session | undefined;
   const branch = session?.branch_name;
   if (!branch) throw new Error(`${itemName(parent)} has no branch to stack on`);
@@ -52,7 +52,7 @@ async function stackedBase(
 export function existingTask(cardId: string): string | null {
   const row = db
     .prepare(
-      `SELECT id FROM sessions WHERE lh_card_id = ? AND task_status = 'running'
+      `SELECT id FROM session_rows WHERE lh_card_id = ? AND task_status = 'running'
        ORDER BY created_at DESC LIMIT 1`
     )
     .get(cardId) as { id: string } | undefined;

package/lib/stacks/testing.ts

@@ -1,7 +1,12 @@
 // Test fixtures: a project, task sessions and a stack in the test database.
 
 import { randomUUID } from "crypto";
-import { db, stackQueries as q, type StackItemStatus } from "../db";
+import {
+  db,
+  insertSessionRow,
+  stackQueries as q,
+  type StackItemStatus,
+} from "../db";
 import { createProject } from "../projects";
 
 export interface SeedItem {
@@ -28,22 +33,18 @@ export function seedStack(repo: string, specs: SeedItem[]) {
     if (!s.branch) continue;
     const id = randomUUID();
     sessions.set(s.key, id);
-    db.prepare(
-      `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id, task_status,
-         branch_name, worktree_path, base_branch, pr_number)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
+    insertSessionRow(db, {
       id,
-      s.key,
-      `claude-${id}`,
-      s.worktree ?? repo,
-      project.id,
-      s.status === "merged" ? "merged" : "running",
-      s.branch,
-      s.worktree ?? null,
-      s.baseBranch ?? null,
-      s.pr ?? null
-    );
+      name: s.key,
+      tmux_name: `claude-${id}`,
+      working_directory: s.worktree ?? repo,
+      project_id: project.id,
+      task_status: s.status === "merged" ? "merged" : "running",
+      branch_name: s.branch,
+      worktree_path: s.worktree ?? null,
+      base_branch: s.baseBranch ?? null,
+      pr_number: s.pr ?? null,
+    });
   }
   q.create(
     db,

package/lib/stacks/tick.ts

@@ -39,7 +39,7 @@ export function setStartGate(gate: StartGate | null): void {
 const LIVE = new Set(["running", "pr"]);
 
 const sessionOf = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
 

package/lib/stacks/view.ts

@@ -51,7 +51,7 @@ const prUrlOf = (sessionId: string | null) =>
   sessionId
     ? ((
         db
-          .prepare(`SELECT pr_url FROM sessions WHERE id = ?`)
+          .prepare(`SELECT pr_url FROM session_rows WHERE id = ?`)
           .get(sessionId) as { pr_url: string | null } | undefined
       )?.pr_url ?? null)
     : null;

package/lib/status/incremental.ts

@@ -60,7 +60,7 @@ export function resetStatusCaches(): void {
 function loadRows(dirty: Set<string>): void {
   const rows = getDb()
     .prepare(
-      `SELECT s.*, p.workspace_id AS project_workspace_id FROM sessions s
+      `SELECT s.*, p.workspace_id AS project_workspace_id FROM session_rows s
          LEFT JOIN projects p ON p.id = s.project_id
         WHERE s.archived_at IS NULL`
     )

package/lib/tasks/contract/actions.ts

@@ -0,0 +1,35 @@
+import type { Session } from "../../db";
+import { requireHostLink } from "../../hosts/remote-api";
+import type { MergeMethod } from "../merge-methods";
+import * as client from "./client";
+import { setMirrorStatus } from "./start";
+
+/**
+ * Sign off on the machine that runs it. It returns the method that machine
+ * merged with; null when it doesn't say (an older AgentOS).
+ */
+export async function mergeThere(
+  session: Session,
+  head?: string,
+  base?: string | null
+): Promise<MergeMethod | null> {
+  const link = requireHostLink(session.host_id);
+  const res = await client.merge(
+    link,
+    session.id,
+    head ? { head, base } : undefined,
+    session.name
+  );
+  setMirrorStatus(session.id, "merged");
+  if (head && res.head !== head)
+    throw new Error(
+      `${link.hostName} merged without confirming it was ${head.slice(0, 7)}`
+    );
+  return res.method;
+}
+
+/** Drop on the machine that runs it. */
+export async function dropThere(session: Session): Promise<void> {
+  await client.drop(requireHostLink(session.host_id), session.id);
+  setMirrorStatus(session.id, "dropped");
+}

package/lib/tasks/contract/authorize.ts

@@ -0,0 +1,82 @@
+/**
+ * Who may call a task route on the machine that runs the task. One rule per
+ * route, applied the same way everywhere:
+ *
+ *  - holder: a task an orchestrator on another machine holds (held.ts); only
+ *    the device that holds it, and a task nobody holds is "No such held task".
+ *  - open: the holder, when there is one; any caller otherwise. A mirror row
+ *    or a task started here is never held, so this machine's own web UI
+ *    (which sends no device) is never refused on them.
+ *  - plan: open, and a plan another machine placed here is read and approved
+ *    by that machine only.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { db, type Session } from "../../db";
+import { callingDevice } from "../../security/device-me";
+import { heldRefusal, holderRefusal, planWaitRefusal } from "../held";
+
+export type Rule = "holder" | "open" | "plan";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+export interface Refusal {
+  status: 403 | 404;
+  error: string;
+}
+
+export function callerRefusal(
+  id: string,
+  device: string | null | undefined,
+  rule: Rule
+): Refusal | null {
+  if (rule === "holder") {
+    const task = db
+      .prepare(
+        `SELECT held_by_device, held_from FROM session_rows WHERE id = ?`
+      )
+      .get(id) as Pick<Session, "held_by_device" | "held_from"> | undefined;
+    if (!task?.held_by_device)
+      return { status: 404, error: "No such held task" };
+    const error = holderRefusal(task, device);
+    return error ? { status: 403, error } : null;
+  }
+  const error =
+    heldRefusal(id, device) ??
+    (rule === "plan" ? planWaitRefusal(id, device) : null);
+  return error ? { status: 403, error } : null;
+}
+
+/** The refusal as a response, or null when the caller may go on. */
+export function refuse(
+  request: NextRequest,
+  id: string,
+  rule: Rule
+): NextResponse | null {
+  const refusal = callerRefusal(id, callingDevice(request), rule);
+  return refusal
+    ? NextResponse.json({ error: refusal.error }, { status: refusal.status })
+    : null;
+}
+
+export async function taskRoute(
+  request: NextRequest,
+  { params }: Ctx,
+  rule: Rule,
+  run: (task: Session) => Promise<object>
+): Promise<NextResponse> {
+  const id = (await params).id;
+  const refused = refuse(request, id, rule);
+  if (refused) return refused;
+  const task = db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+  if (!task)
+    return NextResponse.json({ error: "No such task" }, { status: 404 });
+  try {
+    return NextResponse.json(await run(task));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}