@saadnvd1/agent-os 0.3.631 → 0.3.639

package/lib/done/index.ts

@@ -31,10 +31,11 @@ import { releasePorts } from "../ports";
 import { dropSessionDatabase } from "../project-config/database";
 import { doneOnPeer, peerSessionLink } from "../hosts/peer-actions";
 import { hostLink } from "../hosts/remote-api";
-import { doneHeldTask, isHeldRemote } from "../tasks/held-remote";
+import { doneHeldTask, isHeldRemote } from "../tasks/contract/held-calls";
 import { captureMergedTask } from "../session-logs";
 import { sessionEnded } from "../experiments/hooks";
 import { pushMerged } from "../notify/push/events";
+import { setPr, setTask } from "../db/session-parts";
 
 export interface DoneOptions {
   // Who asked: the orchestrator's gate failures count toward Saad, as its
@@ -108,11 +109,10 @@ async function mergeThroughGates(
 }
 
 function mark(s: Session, status: "merged" | "done", pr: TaskPR | null) {
-  db.prepare(
-    status === "merged"
-      ? `UPDATE sessions SET task_status = 'merged', pr_status = 'merged' WHERE id = ?`
-      : `UPDATE sessions SET task_status = 'done' WHERE id = ?`
-  ).run(s.id);
+  db.transaction(() => {
+    setTask(db, s.id, { task_status: status });
+    if (status === "merged") setPr(db, s.id, { pr_status: "merged" });
+  })();
   endPauseOnFinish(s.id);
   syncTaskCardInBackground(s, status, pr);
   void sessionEnded(s.id, status);
@@ -133,10 +133,7 @@ export async function doneSession(
     if (s.role === "orchestrator")
       throw new Error("An orchestrator isn't marked done.");
     if (s.archived_at) throw new Error(`${s.name} is already archived.`);
-    if (s.task_prompt)
-      db.prepare(`UPDATE sessions SET task_status = 'done' WHERE id = ?`).run(
-        s.id
-      );
+    if (s.task_prompt) setTask(db, s.id, { task_status: "done" });
     archiveSession(s.id);
     return {
       id: s.id,
@@ -180,10 +177,7 @@ export async function doneSession(
     // agent and removes the worktree, which is where they are.
     await doneHeldTask(s);
     if (plan.mark) mark(s, plan.mark, plan.pr);
-    else
-      db.prepare(
-        `UPDATE sessions SET task_status = 'done' WHERE id = ? AND task_status = 'running'`
-      ).run(s.id);
+    else setTask(db, s.id, { task_status: "done" }, { task_status: "running" });
     worktree = {
       action: "removed",
       why: `on ${hostLink(s.host_id)?.hostName ?? "its machine"}`,

package/lib/env-setup.ts

@@ -8,6 +8,7 @@
 
 import * as fs from "fs";
 import * as path from "path";
+import { gitOk } from "./git-exec";
 import { bringDependencies, runCommand } from "./worktree-deps";
 import { inside, realExisting } from "./worktree-deps/paths";
 import { seedBuildCaches } from "./worktree-deps/caches";
@@ -40,16 +41,20 @@ export interface SetupResult {
   durationMs: number;
 }
 
+// A gitignored CLAUDE.md holds the project's private notes. Only one the
+// worktree confirms is ignored is copied: any other would be committable.
+const PRIVATE_NOTES = "CLAUDE.md";
+
 /**
- * Find env files to copy (excludes .env.example)
+ * Find env files to copy (excludes .env.example), and the private notes
  */
 export function findEnvFiles(projectPath: string): string[] {
   try {
     const files = fs.readdirSync(projectPath);
     return files.filter(
       (f) =>
-        f.startsWith(".env") &&
-        !f.endsWith(".example") &&
+        ((f.startsWith(".env") && !f.endsWith(".example")) ||
+          f === PRIVATE_NOTES) &&
         fs.statSync(path.join(projectPath, f)).isFile()
     );
   } catch {
@@ -58,7 +63,7 @@ export function findEnvFiles(projectPath: string): string[] {
 }
 
 /**
- * Copy env files from source to worktree
+ * Copy env files (and the private CLAUDE.md) from source to worktree
  */
 export async function copyEnvFiles(
   sourcePath: string,
@@ -71,6 +76,14 @@ export async function copyEnvFiles(
     try {
       const src = path.join(sourcePath, file);
       const dest = path.join(worktreePath, file);
+      const there = await fs.promises.lstat(dest).catch(() => null);
+      if (file === PRIVATE_NOTES) {
+        if (there || !(await gitOk(worktreePath, ["check-ignore", "-q", file])))
+          continue;
+      } else if (there?.isSymbolicLink()) {
+        // Never written through: a committed link could point outside.
+        await fs.promises.unlink(dest);
+      }
       await fs.promises.copyFile(src, dest);
       copied.push(file);
     } catch (error) {

package/lib/health/evidence.ts

@@ -61,7 +61,7 @@ function schedulerSnapshot(f: HealthFacts): string {
   const running = db
     .prepare(
       `SELECT s.name, s.pause_state, s.plan_only, s.plan_phase, s.task_status
-       FROM sessions s WHERE s.task_status IN ('running', 'moving')
+       FROM session_rows s WHERE s.task_status IN ('running', 'moving')
          AND s.archived_at IS NULL AND s.quick_of IS NULL LIMIT 20`
     )
     .all() as {

package/lib/health/facts.ts

@@ -123,7 +123,7 @@ function armed(): ArmedFact[] {
     db
       .prepare(
         `SELECT s.id, s.name, s.merge_armed_at, s.pr_number, p.workspace_id
-         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 s.merge_armed_at IS NOT NULL AND s.archived_at IS NULL
            AND COALESCE(s.task_status, 'running') = 'running'`
       )

package/lib/health/pieces.ts

@@ -39,7 +39,7 @@ export function mergedSince(
   return (
     db
       .prepare(
-        `SELECT id, name, pr_number, task_prompt, updated_at FROM sessions
+        `SELECT id, name, pr_number, task_prompt, updated_at FROM session_rows
          WHERE project_id = ? AND task_status = 'merged'
            AND updated_at >= datetime(?)`
       )

package/lib/hosts/peer-actions.ts

@@ -15,7 +15,7 @@ import { isValidTmuxName } from "./attach";
 import { homeRelative } from "./discover";
 import { toPeerSession } from "./peer-sessions";
 import { insertMirror } from "./peer-sync";
-import { hostTasks, postIdempotent } from "../tasks/remote";
+import { list as hostTasks, postIdempotent } from "../tasks/contract/client";
 import type { ProjectRef } from "../tasks/project-ref";
 import {
   HostApiError,
@@ -83,7 +83,7 @@ const path = (id: string, rest = "") =>
   `/api/sessions/${encodeURIComponent(id)}${rest}`;
 
 const row = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as Session;
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as Session;
 
 export async function renameOnPeer(
   link: HostLink,

package/lib/hosts/peer-mirror.ts

@@ -16,7 +16,7 @@ export async function mirrorPeerSession(
   sessionId: string
 ): Promise<Session> {
   const existing = db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(sessionId) as Session | undefined;
   if (existing) {
     if (existing.host_id !== hostId)
@@ -43,6 +43,6 @@ export async function mirrorPeerSession(
     )
   );
   return db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(peer.id) as Session;
 }

package/lib/hosts/peer-sync.ts

@@ -6,37 +6,45 @@
  * go there (peer-actions.ts).
  */
 
-import { db, queries, type Project } from "../db";
+import { db, queries, type Project, type Session } from "../db";
 import { isValidAgentType } from "../providers";
 import { projectMatcher } from "./discover";
 import type { PeerSession } from "./peer-sessions";
+import { setPlacement, setPr } from "../db/session-parts";
 
 export function insertMirror(
   peer: PeerSession,
   projectId: string | null
 ): void {
-  db.prepare(
-    `INSERT INTO sessions (id, name, tmux_name, working_directory, model, group_path,
-       agent_type, project_id, host_id, view, name_source, pr_url, pr_number,
-       pr_status, updated_at, peer_mirror)
-     VALUES (?, ?, ?, ?, ?, 'sessions', ?, ?, ?, ?, 'user', ?, ?, ?,
-       COALESCE(?, datetime('now')), 1)
-     ON CONFLICT(id) DO NOTHING`
-  ).run(
-    peer.id,
-    peer.name,
-    peer.tmuxName || `${peer.agentType}-${peer.id}`,
-    peer.path || "~",
-    peer.model,
-    isValidAgentType(peer.agentType) ? peer.agentType : "shell",
-    projectId,
-    peer.hostId,
-    peer.view,
-    peer.prUrl,
-    peer.prNumber,
-    peer.prStatus,
-    peer.updatedAt
-  );
+  db.transaction(() => {
+    const inserted = db
+      .prepare(
+        `INSERT INTO sessions (id, name, tmux_name, working_directory, model, group_path,
+           agent_type, project_id, host_id, view, name_source, updated_at)
+         VALUES (?, ?, ?, ?, ?, 'sessions', ?, ?, ?, ?, 'user',
+           COALESCE(?, datetime('now')))
+         ON CONFLICT(id) DO NOTHING`
+      )
+      .run(
+        peer.id,
+        peer.name,
+        peer.tmuxName || `${peer.agentType}-${peer.id}`,
+        peer.path || "~",
+        peer.model,
+        isValidAgentType(peer.agentType) ? peer.agentType : "shell",
+        projectId,
+        peer.hostId,
+        peer.view,
+        peer.updatedAt
+      );
+    if (!inserted.changes) return;
+    setPr(db, peer.id, {
+      pr_url: peer.prUrl,
+      pr_number: peer.prNumber,
+      pr_status: peer.prStatus as Session["pr_status"],
+    });
+    setPlacement(db, peer.id, { peer_mirror: 1 });
+  })();
 }
 
 // One listing mirrors at most this many: a listing is another machine's
@@ -71,17 +79,46 @@ export function syncPeerMirrors(
   );
   // That machine lists the id, so it's its session: a row mirrored on open
   // before this column existed is marked too.
-  const update = db.prepare(
+  const current = db.prepare(
+    `SELECT name, view, tmux_name, project_id, pr_url, pr_number, pr_status,
+       updated_at, peer_mirror
+       FROM session_rows WHERE id = ? AND host_id = ? AND task_prompt IS NULL`
+  );
+  const touch = db.prepare(
     `UPDATE sessions SET name = ?, view = ?, tmux_name = ?, project_id = ?,
-       pr_url = ?, pr_number = ?, pr_status = ?,
-       updated_at = COALESCE(?, updated_at), peer_mirror = 1
-     WHERE id = ? AND host_id = ? AND task_prompt IS NULL
-       AND NOT (name IS ? AND view IS ? AND tmux_name IS ? AND project_id IS ?
-         AND pr_url IS ? AND pr_number IS ? AND pr_status IS ?
-         AND updated_at IS COALESCE(?, updated_at) AND peer_mirror = 1)`
+       updated_at = COALESCE(?, updated_at) WHERE id = ?`
   );
+  const update = (
+    peer: PeerSession,
+    fields: (string | number | null)[]
+  ): void => {
+    const [name, view, tmuxName, projectId, prUrl, prNumber, prStatus, at] =
+      fields;
+    const cur = current.get(peer.id, hostId) as
+      | Record<string, string | number | null>
+      | undefined;
+    if (!cur) return;
+    const same =
+      cur.name === name &&
+      cur.view === view &&
+      cur.tmux_name === tmuxName &&
+      cur.project_id === projectId &&
+      cur.pr_url === prUrl &&
+      cur.pr_number === prNumber &&
+      cur.pr_status === prStatus &&
+      cur.updated_at === (at ?? cur.updated_at) &&
+      cur.peer_mirror === 1;
+    if (same) return;
+    touch.run(name, view, tmuxName, projectId, at, peer.id);
+    setPr(db, peer.id, {
+      pr_url: prUrl as string | null,
+      pr_number: prNumber as number | null,
+      pr_status: prStatus as Session["pr_status"],
+    });
+    setPlacement(db, peer.id, { peer_mirror: 1 });
+  };
   const mirrors = db.prepare(
-    `SELECT id FROM sessions WHERE host_id = ? AND peer_mirror = 1
+    `SELECT id FROM session_rows WHERE host_id = ? AND peer_mirror = 1
        AND task_prompt IS NULL AND archived_at IS NULL
        AND created_at < datetime(?, 'unixepoch')`
   );
@@ -112,7 +149,7 @@ export function syncPeerMirrors(
         peer.prStatus,
         peer.updatedAt,
       ];
-      update.run(...fields, peer.id, hostId, ...fields);
+      update(peer, fields);
     }
     if (!complete) return;
     const now = new Set(listed.map((p) => p.id));

package/lib/learning-cards/input.ts

@@ -80,7 +80,7 @@ export async function readSession(id: string): Promise<SessionInput | null> {
     ? (
         db
           .prepare(
-            `SELECT s.task_prompt AS p FROM sessions s JOIN projects p ON p.id = s.project_id
+            `SELECT s.task_prompt AS p FROM session_rows s JOIN projects p ON p.id = s.project_id
              WHERE p.workspace_id = ? AND s.id != ? AND s.quick_of IS NULL
                AND s.task_prompt IS NOT NULL
                AND s.created_at >= datetime('now', ?)

package/lib/learning-cards/store.ts

@@ -30,7 +30,7 @@ export function listPending(): PendingRow[] {
       `SELECT lc.*, s.name AS session_name,
               COALESCE(lc.workspace_id, s.workspace_id, p.workspace_id) AS ws
        FROM learning_cards lc
-       JOIN sessions s ON s.id = lc.session_id
+       JOIN session_rows s ON s.id = lc.session_id
        LEFT JOIN projects p ON p.id = s.project_id
        WHERE lc.status = 'pending'
        ORDER BY lc.created_at DESC, lc.id DESC`

package/lib/models/plan-step.ts

@@ -24,6 +24,7 @@ import { addNote } from "../orchestrator/notes";
 import { amendBrief, scopeChangesOf } from "../orchestrator/amendments";
 import { PIECES_PROMPT, foldedBrief, pieceBrief } from "../plans/pieces";
 import { orchestratorOf } from "../tasks/starter";
+import { isRemoteHost } from "../hosts";
 import { refreshBase } from "../tasks/refresh-base";
 import {
   createFeature,
@@ -32,6 +33,7 @@ import {
   planPathOf,
   splitOf,
 } from "../plans/features";
+import { advancePlan, setPlan } from "../db/session-parts";
 
 export const PLAN_FILE = ".agentos/plan.md";
 
@@ -121,8 +123,35 @@ function piecesLine(r: NonNullable<ReturnType<typeof planFor>>): string {
   return `${r.pieces.length} pieces${folded}: ${parts.join("; ")}`;
 }
 
+// The "plan written" line for a task: where the plan is, what comes next,
+// its first lines and how it split. `file` is where this machine can read it.
+export function planNoteFor(
+  s: Session,
+  file: string,
+  next: string,
+  again = "",
+  after = ""
+): string {
+  let head = `Task "${s.name}": no plan file was written${again}; ${next}${after}.`;
+  try {
+    const text = fs.readFileSync(file, "utf8");
+    const summary = planSummary(text);
+    head = `Task "${s.name}": plan written to ${file}; ${next}.`;
+    if (summary.length) head += `\n${summary.map((l) => `- ${l}`).join("\n")}`;
+    const pieces = planFor(s, text);
+    if (pieces && pieces.pieces.length > 1) head += `\n${piecesLine(pieces)}`;
+    if (pieces?.folded.length)
+      head += `\nPlan listed ${pieces.listed} pieces, building ${pieces.pieces.length}: ${pieces.folded.map((f) => `${f.name} folded (${f.why})`).join("; ")}`;
+  } catch {
+    // No plan file: the line says so.
+  }
+  return head;
+}
+
 // Tells the orchestrator that started a task its plan is written, once.
 function announcePlan(s: Session, ref: string | null, retried = false): void {
+  // The machine that placed it announces the plan, from its own copy.
+  if (s.plan_waits_for_caller) return;
   if (!orchestratorOf(s.started_by) && !s.held_by_device) return;
   const workspaceId = sessionWorkspace(s);
   // A task held for another machine's orchestrator can't reach it: the line
@@ -134,23 +163,9 @@ function announcePlan(s: Session, ref: string | null, retried = false): void {
     ? `implementing on ${ref}`
     : "waiting for approval, not implementing (approve_plan to go ahead, drop to reject)";
   const again = retried ? " (asked once more for it first)" : "";
-  let head = `Task "${s.name}": no plan file was written${again}; ${next}${ref ? " anyway" : ""}.`;
-  try {
-    const summary = planSummary(fs.readFileSync(file, "utf8"));
-    head = `Task "${s.name}": plan written to ${file}; ${next}.`;
-    if (summary.length) head += `\n${summary.map((l) => `- ${l}`).join("\n")}`;
-    const pieces = planFor(s, fs.readFileSync(file, "utf8"));
-    if (pieces && pieces.pieces.length > 1) head += `\n${piecesLine(pieces)}`;
-    if (pieces?.folded.length)
-      head += `\nPlan listed ${pieces.listed} pieces, building ${pieces.pieces.length}: ${pieces.folded.map((f) => `${f.name} folded (${f.why})`).join("; ")}`;
-  } catch {
-    // No plan file: the line says so.
-  }
+  const head = planNoteFor(s, file, next, again, ref ? " anyway" : "");
   if (s.held_by_device) {
-    db.prepare(`UPDATE sessions SET plan_note = ? WHERE id = ?`).run(
-      head,
-      s.id
-    );
+    setPlan(db, s.id, { plan_note: head });
     return;
   }
   queueEvent(workspaceId!, `plan-done:${s.id}`, s.id, head);
@@ -210,9 +225,9 @@ export const implementMessageId = (sessionId: string) =>
 type Send = (sessionId: string, id: string) => Promise<void>;
 
 function getSession(sessionId: string): Session | undefined {
-  return db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(sessionId) as
-    | Session
-    | undefined;
+  return db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(sessionId) as Session | undefined;
 }
 
 // Planning (or, once approved, awaiting) becomes implementing, once: the
@@ -244,7 +259,10 @@ async function startImplementing(
     ? undefined
     : fresh.note &&
       `Note: ${fresh.note}. Rebase onto the latest base before you open the PR.`;
-  let split = planText ? splitOf(s, planText) : null;
+  // A plan another machine placed here was checked there, against its
+  // projects; this one's workspace doesn't know them.
+  let split =
+    planText && !s.plan_waits_for_caller ? splitOf(s, planText) : null;
   const workspaceId = sessionWorkspace(s);
   // Approved despite pieces that couldn't be registered: built as one piece,
   // and told so, rather than guessing which repository each belongs to.
@@ -253,13 +271,7 @@ async function startImplementing(
   let nothingOwn = false;
   let featureId: string | null = null;
   const claimed = db.transaction(() => {
-    const changed = db
-      .prepare(
-        `UPDATE sessions SET plan_phase = 'implementing'
-         WHERE id = ? AND plan_phase = ? AND task_status = 'running'`
-      )
-      .run(sessionId, from).changes;
-    if (!changed) return false;
+    if (!advancePlan(db, sessionId, from, "implementing")) return false;
     setSessionModel(sessionId, routed);
     let piece: string | undefined;
     let note = amendment;
@@ -441,9 +453,12 @@ export async function handoffAfterPlan(
   forget(sessionId);
   // No approvals mode doesn't stop at the plan to wait for one. Pieces that
   // couldn't be registered always do: building on a guess is the bug.
-  const auto = !!s.plan_only && noApprovalsOn();
+  const auto = !!s.plan_only && noApprovalsOn() && !s.plan_waits_for_caller;
   const planText = readPlan(s);
-  const pieceErrors = (planText ? splitOf(s, planText)?.errors : null) ?? [];
+  const pieceErrors =
+    (planText && !s.plan_waits_for_caller
+      ? splitOf(s, planText)?.errors
+      : null) ?? [];
   if ((!s.plan_only || auto) && !pieceErrors.length) {
     const ref = await startImplementing(
       s,
@@ -462,13 +477,7 @@ export async function handoffAfterPlan(
       });
     return ref !== null;
   }
-  const awaiting = db
-    .prepare(
-      `UPDATE sessions SET plan_phase = 'awaiting'
-       WHERE id = ? AND plan_phase = 'planning' AND task_status = 'running'`
-    )
-    .run(sessionId).changes;
-  if (!awaiting) return false;
+  if (!advancePlan(db, sessionId, "planning", "awaiting")) return false;
   try {
     announcePlan(s, null, retried);
   } catch (e) {
@@ -482,14 +491,17 @@ export async function handoffAfterPlan(
       s.id,
       `Plan of "${s.name}": couldn't register its pieces: ${pieceErrors.join("; ")}. It is held, not building. Message the task to fix the plan, or approve_plan to build it as one piece.`
     );
+  // The machine that placed a plan sends its own push.
   try {
-    const text = readPlan(s);
-    const planned = text ? planFor(s, text) : null;
-    (await import("../notify/push/events")).pushPlanAwaiting(
-      s.id,
-      s.name,
-      planned?.pieces.length ?? 1
-    );
+    if (!s.plan_waits_for_caller) {
+      const text = readPlan(s);
+      const planned = text ? planFor(s, text) : null;
+      (await import("../notify/push/events")).pushPlanAwaiting(
+        s.id,
+        s.name,
+        planned?.pieces.length ?? 1
+      );
+    }
   } catch (e) {
     console.error("plan push failed:", e);
   }
@@ -512,7 +524,7 @@ export async function recheckPlanning(
 ): Promise<void> {
   const rows = db
     .prepare(
-      `SELECT id FROM sessions
+      `SELECT id FROM session_rows
        WHERE plan_phase = 'planning' AND task_status = 'running'
          AND archived_at IS NULL AND worktree_path IS NOT NULL`
     )
@@ -560,9 +572,12 @@ export async function approvePlan(
     );
   const text = message?.trim() || undefined;
   const workspaceId = sessionWorkspace(s);
+  // A plan another machine placed here is approved by that machine, which
+  // keeps the brief its review reads.
+  const placedHere = !!s.plan_waits_for_caller && !isRemoteHost(s.host_id);
   // Every approval is on the brief, so the review judges the PR as the
   // implementation of the plan, not as plan-only work.
-  if (workspaceId) {
+  if (workspaceId && !placedHere) {
     if (text) {
       amendBrief(workspaceId, s.id, text);
       addNote(
@@ -571,7 +586,11 @@ export async function approvePlan(
       );
     } else amendBrief(workspaceId, s.id, APPROVAL_TEXT[by], "approval");
   }
-  const ref = await startImplementing(s, "awaiting", send, text);
+  // On another machine, the plan was written there: this machine decides
+  // where it is built, and the approval follows it.
+  const ref = isRemoteHost(s.host_id)
+    ? await (await import("../tasks/contract/plan")).continuePlanThere(s, text)
+    : await startImplementing(s, "awaiting", send, text);
   if (!ref) throw new Error(`${s.name} isn't waiting for plan approval`);
   if (by === "no-approvals")
     recordAutoApproval({
@@ -583,3 +602,21 @@ export async function approvePlan(
     });
   return { ref, amendments: scopeChangesOf(s.id).length };
 }
+
+// A plan that moved here to be built (contract/plan.ts): implementation starts
+// on this machine, once, with the approval's change if it had one.
+export async function implementArrived(
+  sessionId: string,
+  message?: string
+): Promise<string | null> {
+  const s = getSession(sessionId);
+  if (!s || s.plan_phase !== "awaiting" || s.task_status !== "running")
+    throw new Error(`${s?.name ?? "That task"} isn't waiting for a plan`);
+  const { sendQueuedNow } = await import("../chat/runner");
+  return startImplementing(
+    s,
+    "awaiting",
+    (id, m) => sendQueuedNow(id, m),
+    message
+  );
+}

package/lib/models/resume.ts

@@ -19,6 +19,7 @@ import {
   type ModelOverride,
 } from "./resolve";
 import { sessionRole } from "./session-role";
+import { setTask } from "../db/session-parts";
 
 export const RESUME_MESSAGE =
   "You were paused. Carry on where you left off: check the worktree and the conversation above for where things stand, then finish the task.";
@@ -45,9 +46,9 @@ export async function resumeOnModel(
   model: unknown,
   message = RESUME_MESSAGE
 ): Promise<ResumeResult> {
-  const s = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(sessionId) as
-    | Session
-    | undefined;
+  const s = db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(sessionId) as Session | undefined;
   if (!s?.task_status) throw new Error("No such task");
   if (s.task_status !== "running")
     throw new Error(
@@ -65,10 +66,7 @@ export async function resumeOnModel(
     throw new Error(
       "It's mid-turn: stop it first, or wait for the turn to end"
     );
-  db.prepare(`UPDATE sessions SET model_overrides = ? WHERE id = ?`).run(
-    JSON.stringify(override),
-    sessionId
-  );
+  setTask(db, sessionId, { model_overrides: JSON.stringify(override) });
   if (launchPending(sessionId)) {
     setSessionModel(sessionId, routed);
     return { ref: routed.ref, resumed: false };

package/lib/notify/index.ts

@@ -160,7 +160,7 @@ export async function notifyFrom(
   text: string
 ): Promise<Outcome> {
   const session = from
-    ? (db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(from) as
+    ? (db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(from) as
         | Session
         | undefined)
     : undefined;

package/lib/notify/push/events.ts

@@ -92,7 +92,7 @@ export const pushPlanAwaiting = (
 export const pushPlanReady = (sessionId: string, itemId: string) => {
   // Only a task has a screen to open; a plain chat's plan goes to the list.
   const task = db
-    .prepare(`SELECT task_status FROM sessions WHERE id = ?`)
+    .prepare(`SELECT task_status FROM session_rows WHERE id = ?`)
     .get(sessionId) as { task_status: string | null } | undefined;
   fire(
     {

package/lib/notify/push/index.ts

@@ -57,7 +57,7 @@ export interface PushOptions {
 
 function isMirrored(sessionId: string): boolean {
   const s = db
-    .prepare(`SELECT host_id, peer_mirror FROM sessions WHERE id = ?`)
+    .prepare(`SELECT host_id, peer_mirror FROM session_rows WHERE id = ?`)
     .get(sessionId) as
     | { host_id: string | null; peer_mirror: number | null }
     | undefined;

package/lib/orchestrator/act.ts

@@ -439,7 +439,7 @@ export async function resurrect(
   if (!reason.trim()) throw new Error("Say why it's restored");
   const id = resolveEnded(ref, { workspaceId });
   const row = db
-    .prepare(`SELECT task_status, archived_at FROM sessions WHERE id = ?`)
+    .prepare(`SELECT task_status, archived_at FROM session_rows WHERE id = ?`)
     .get(id) as { task_status: string | null; archived_at: string | null };
   const task =
     row.task_status === "dropped" ||