@saadnvd1/agent-os 0.3.637 → 0.3.639

package/lib/db/session-parts/plans.ts

@@ -0,0 +1,31 @@
+import type Database from "better-sqlite3";
+import type { PartPatch } from "./columns";
+import { writePart, type When } from "./write";
+
+// A task's plan step: phase, note, edits and the hand-off.
+export const setPlan = (
+  db: Database.Database,
+  sessionId: string,
+  patch: PartPatch<"session_plans">,
+  when?: When<"session_plans">
+): boolean => writePart(db, "session_plans", sessionId, patch, when);
+
+// Moves a plan from one phase to the next, only while the task is running
+// and still in `from` (a step another caller took first returns false).
+export function advancePlan(
+  db: Database.Database,
+  sessionId: string,
+  from: string,
+  to: NonNullable<PartPatch<"session_plans">["plan_phase"]>
+): boolean {
+  return db.transaction(() => {
+    const running = db
+      .prepare(
+        `SELECT 1 FROM session_rows WHERE id = ? AND task_status = 'running'`
+      )
+      .get(sessionId);
+    return running
+      ? setPlan(db, sessionId, { plan_phase: to }, { plan_phase: from })
+      : false;
+  })();
+}

package/lib/db/session-parts/prs.ts

@@ -0,0 +1,31 @@
+import type Database from "better-sqlite3";
+import type { Session } from "@/lib/db/types";
+import type { PartPatch } from "./columns";
+import { writePart, type When } from "./write";
+
+// A session's PR and the merge and rebase state kept for it.
+export const setPr = (
+  db: Database.Database,
+  sessionId: string,
+  patch: PartPatch<"session_prs">,
+  when?: When<"session_prs">
+): boolean => writePart(db, "session_prs", sessionId, patch, when);
+
+// A PR found for the session: its link, number and state, and the session
+// counts as touched.
+export function recordPr(
+  db: Database.Database,
+  sessionId: string,
+  pr: { url: string; number: number; state: string }
+): void {
+  db.transaction(() => {
+    setPr(db, sessionId, {
+      pr_url: pr.url,
+      pr_number: pr.number,
+      pr_status: pr.state as Session["pr_status"],
+    });
+    db.prepare(
+      `UPDATE sessions SET updated_at = datetime('now') WHERE id = ?`
+    ).run(sessionId);
+  })();
+}

package/lib/db/session-parts/tasks.ts

@@ -0,0 +1,27 @@
+import type Database from "better-sqlite3";
+import type { PartPatch } from "./columns";
+import { writePart, type When } from "./write";
+
+// A task's brief, status, priority, models and card: lib/db/session-parts/columns.ts.
+export const setTask = (
+  db: Database.Database,
+  sessionId: string,
+  patch: PartPatch<"session_tasks">,
+  when?: When<"session_tasks">
+): boolean => writePart(db, "session_tasks", sessionId, patch, when);
+
+// The task's first start, kept across moves: set once, from created_at when
+// the caller has no better time.
+export function startTaskClock(
+  db: Database.Database,
+  sessionId: string,
+  at?: string | null
+): void {
+  const row = db
+    .prepare(`SELECT created_at, task_since FROM session_rows WHERE id = ?`)
+    .get(sessionId) as
+    | { created_at: string; task_since: string | null }
+    | undefined;
+  if (!row || row.task_since) return;
+  setTask(db, sessionId, { task_since: at ?? row.created_at });
+}

package/lib/db/session-parts/view.ts

@@ -0,0 +1,43 @@
+import type Database from "better-sqlite3";
+import { PART_COLUMNS, type PartTable } from "./columns";
+
+const ALIAS: Record<PartTable, string> = {
+  session_tasks: "t",
+  session_prs: "pr",
+  session_plans: "pl",
+  session_placement: "pp",
+  session_pauses: "pa",
+};
+
+// `session_rows`: the sessions table with each moved column read from its own
+// table, under the same names and in the same order, so a row is the flat
+// session it always was. A column with a default on sessions
+// (peer_mirror) keeps it. Rebuild it in any migration that adds a sessions
+// column. `parts` is the split as that migration knew it.
+export function createSessionRowsView(
+  db: Database.Database,
+  parts: Record<PartTable, readonly string[]> = PART_COLUMNS
+): void {
+  const source = new Map<string, string>();
+  for (const table of Object.keys(parts) as PartTable[])
+    for (const c of parts[table]) source.set(c, ALIAS[table]);
+  const sessionColumns = (
+    db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
+  ).map((c) => c.name);
+  const select = sessionColumns
+    .map((c) => {
+      const alias = source.get(c);
+      if (!alias) return `s.${c}`;
+      return c === "peer_mirror"
+        ? `COALESCE(${alias}.${c}, 0) AS ${c}`
+        : `${alias}.${c} AS ${c}`;
+    })
+    .join(", ");
+  const joins = (Object.keys(parts) as PartTable[])
+    .map((t) => `LEFT JOIN ${t} ${ALIAS[t]} ON ${ALIAS[t]}.session_id = s.id`)
+    .join(" ");
+  db.exec(`DROP VIEW IF EXISTS session_rows`);
+  db.exec(
+    `CREATE VIEW session_rows AS SELECT ${select} FROM sessions s ${joins}`
+  );
+}

package/lib/db/session-parts/write.ts

@@ -0,0 +1,69 @@
+import type Database from "better-sqlite3";
+import { PART_COLUMNS, type PartPatch, type PartTable } from "./columns";
+
+type Value = string | number | null;
+
+// A condition on the part row's current values, checked with the write in one
+// transaction: every column must equal one of its listed values (null for
+// "unset").
+export type When<T extends PartTable> = {
+  [C in keyof PartPatch<T>]?: Value | readonly Value[];
+};
+
+const sameAs = (current: unknown, wanted: Value | readonly Value[]): boolean =>
+  (Array.isArray(wanted) ? (wanted as Value[]) : [wanted as Value]).some(
+    (w) => (current ?? null) === w
+  );
+
+// The one writer of the part tables. Writes the patched columns to the part
+// table, then mirrors the same values onto the legacy sessions columns, which
+// stay until they are dropped (docs/decisions/2026-10-15-split-sessions-table.md):
+// that UPDATE is the only dual-write, and the step that drops the columns
+// deletes it. Returns whether it wrote (false: the session is gone or `when`
+// no longer holds).
+export function writePart<T extends PartTable>(
+  db: Database.Database,
+  table: T,
+  sessionId: string,
+  patch: PartPatch<T>,
+  when?: When<T>
+): boolean {
+  const allowed = PART_COLUMNS[table] as readonly string[];
+  const columns = Object.keys(patch).filter(
+    (c) => (patch as Record<string, unknown>)[c] !== undefined
+  );
+  for (const c of [...columns, ...Object.keys(when ?? {})])
+    if (!allowed.includes(c)) throw new Error(`${c} is not a ${table} column`);
+  if (columns.length === 0) return false;
+
+  const run = db.transaction((): boolean => {
+    if (when && Object.keys(when).length > 0) {
+      const current = db
+        .prepare(
+          `SELECT ${Object.keys(when).join(", ")} FROM session_rows WHERE id = ?`
+        )
+        .get(sessionId) as Record<string, unknown> | undefined;
+      if (!current) return false;
+      for (const [c, wanted] of Object.entries(when))
+        if (!sameAs(current[c], wanted as Value | readonly Value[]))
+          return false;
+    }
+    const values = { id: sessionId, ...(patch as Record<string, Value>) };
+    const inserted = db
+      .prepare(
+        `INSERT INTO ${table} (session_id, ${columns.join(", ")})
+         SELECT id, ${columns.map((c) => `@${c}`).join(", ")}
+           FROM sessions WHERE id = @id
+         ON CONFLICT(session_id) DO UPDATE SET
+           ${columns.map((c) => `${c} = excluded.${c}`).join(", ")}`
+      )
+      .run(values);
+    if (inserted.changes === 0) return false;
+    db.prepare(
+      `UPDATE sessions SET ${columns.map((c) => `${c} = @${c}`).join(", ")}
+        WHERE id = @id`
+    ).run(values);
+    return true;
+  });
+  return run();
+}

package/lib/done/archive.ts

@@ -34,7 +34,7 @@ export function unarchiveSession(id: string): Session {
       `UPDATE sessions SET archived_at = NULL WHERE id = ? AND archived_at IS NOT NULL`
     )
     .run(id).changes;
-  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;
   if (!row) throw new Error("Session not found");
@@ -48,7 +48,7 @@ export function listArchived(workspaceId?: string): ArchivedView[] {
     .prepare(
       `SELECT s.id, s.name, s.project_id, s.view, s.task_status, s.branch_name,
          s.pr_url, s.worktree_path, s.archived_at, p.name AS project_name, p.workspace_id AS project_workspace
-       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.archived_at IS NOT NULL
          AND (? IS NULL OR p.workspace_id = ?)
        ORDER BY s.archived_at DESC, s.updated_at DESC`

package/lib/done/auto-archive.ts

@@ -33,7 +33,7 @@ const inDone = (s: Session) =>
 export async function archiveStaleDone(now = Date.now()): Promise<string[]> {
   const rows = db
     .prepare(
-      `SELECT * FROM sessions
+      `SELECT * FROM session_rows
        WHERE archived_at IS NULL AND pinned = 0 AND role IS NULL
          AND peer_mirror = 0 AND quick_of IS NULL
          AND (pr_status IS NULL OR pr_status != 'open')`

package/lib/done/bulk.ts

@@ -50,7 +50,7 @@ function scopeSessions(scope: DoneScope): Session[] {
   if (!projectIds.length) return [];
   return db
     .prepare(
-      `SELECT * FROM sessions
+      `SELECT * FROM session_rows
        WHERE project_id IN (${projectIds.map(() => "?").join(", ")})
          AND role IS NULL AND archived_at IS NULL
          -- A linked machine's own sessions are cleaned up there.

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/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

@@ -33,6 +33,7 @@ import {
   planPathOf,
   splitOf,
 } from "../plans/features";
+import { advancePlan, setPlan } from "../db/session-parts";
 
 export const PLAN_FILE = ".agentos/plan.md";
 
@@ -164,10 +165,7 @@ function announcePlan(s: Session, ref: string | null, retried = false): void {
   const again = retried ? " (asked once more for it first)" : "";
   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);
@@ -227,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
@@ -273,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;
@@ -485,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) {
@@ -538,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`
     )
@@ -603,7 +589,7 @@ export async function approvePlan(
   // 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/remote-plan")).continueRemotePlan(s, text)
+    ? 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")
@@ -617,7 +603,7 @@ export async function approvePlan(
   return { ref, amendments: scopeChangesOf(s.id).length };
 }
 
-// A plan that moved here to be built (remote-plan.ts): implementation starts
+// 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,

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(
     {