@saadnvd1/agent-os 0.3.637 → 0.3.644

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

@@ -0,0 +1,186 @@
+import type { Session } from "@/lib/db/types";
+
+// The sessions columns that live in their own tables, by concern. Each table
+// is keyed by session_id and holds a row only for a session that has a value
+// in the group; `session_rows` joins them back into the flat shape of a
+// session. See docs/decisions/2026-10-15-split-sessions-table.md.
+export const PART_COLUMNS = {
+  session_tasks: [
+    "task_prompt",
+    "task_brief",
+    "task_status",
+    "task_since",
+    "task_ended_at",
+    "merged_at",
+    "priority",
+    "quick_of",
+    "moved_to",
+    "moved_from",
+    "model_overrides",
+    "lh_card_id",
+    "lh_board_id",
+    "lh_card_list",
+  ],
+  session_prs: [
+    "pr_url",
+    "pr_number",
+    "pr_status",
+    "merge_armed_at",
+    "merge_armed_seen",
+    "rebased_from",
+    "rebased_to",
+    "rebase_asked_head",
+    "pr_wake_since",
+  ],
+  session_plans: [
+    "plan_phase",
+    "plan_only",
+    "plan_decided",
+    "plan_reason",
+    "plan_note",
+    "plan_edits",
+    "plan_waits_for_caller",
+    "plan_handoff_message",
+  ],
+  session_placement: [
+    "peer_mirror",
+    "placed_note",
+    "held_by_device",
+    "held_from",
+    "held_for",
+    "held_for_name",
+    "started_by_device",
+  ],
+  session_pauses: ["pause_state", "paused_until", "pause_id", "pause_note"],
+} as const satisfies Record<string, readonly (keyof Session)[]>;
+
+export type PartTable = keyof typeof PART_COLUMNS;
+export type PartColumn<T extends PartTable> = (typeof PART_COLUMNS)[T][number];
+export type PartPatch<T extends PartTable> = {
+  [C in PartColumn<T>]?: Session[C & keyof Session];
+};
+
+export const PART_TABLES = Object.keys(PART_COLUMNS) as PartTable[];
+
+// Everything else is an INTEGER or TEXT by this list.
+export const INTEGER_COLUMNS: ReadonlySet<string> = new Set([
+  "pr_number",
+  "plan_only",
+  "plan_decided",
+  "plan_waits_for_caller",
+  "peer_mirror",
+  "pause_id",
+]);
+
+const partOfColumn = new Map<string, PartTable>(
+  PART_TABLES.flatMap((t) =>
+    (PART_COLUMNS[t] as readonly string[]).map((c) => [c, t] as const)
+  )
+);
+
+export const isMovedColumn = (column: string): boolean =>
+  partOfColumn.has(column);
+
+export const partOf = (column: string): PartTable | undefined =>
+  partOfColumn.get(column);
+
+// The shape of a session row and of `session_rows`, in order: the sessions
+// columns and the moved ones where they always stood. A migration that adds a
+// sessions column adds it here and rebuilds the view (createSessionRowsView).
+export const SESSION_ROW_COLUMNS: readonly string[] = [
+  "id",
+  "name",
+  "created_at",
+  "updated_at",
+  "status",
+  "working_directory",
+  "parent_session_id",
+  "claude_session_id",
+  "model",
+  "system_prompt",
+  "group_path",
+  "agent_type",
+  "worktree_path",
+  "branch_name",
+  "base_branch",
+  "dev_server_port",
+  "pr_url",
+  "pr_number",
+  "pr_status",
+  "conductor_session_id",
+  "worker_task",
+  "worker_status",
+  "auto_approve",
+  "project_id",
+  "tmux_name",
+  "host_id",
+  "task_prompt",
+  "task_status",
+  "view",
+  "lh_card_id",
+  "lh_board_id",
+  "lh_card_list",
+  "chat_access",
+  "chat_resume_at",
+  "last_seen_at",
+  "role",
+  "workspace_id",
+  "orch_token",
+  "archived_at",
+  "pinned",
+  "chat_suggestion",
+  "chat_plan",
+  "chat_context",
+  "chat_usage",
+  "name_source",
+  "setup_status",
+  "setup_ms",
+  "setup_error",
+  "task_brief",
+  "moved_to",
+  "moved_from",
+  "port_slot",
+  "ports",
+  "database",
+  "peer_mirror",
+  "chat_restarted",
+  "chat_tools_digest",
+  "merge_armed_at",
+  "merge_armed_seen",
+  "rebased_from",
+  "rebased_to",
+  "rebase_asked_head",
+  "chat_refreshed",
+  "pr_wake_since",
+  "merged_at",
+  "task_ended_at",
+  "model_provider",
+  "model_overrides",
+  "plan_phase",
+  "quick_of",
+  "started_by",
+  "plan_decided",
+  "plan_reason",
+  "task_since",
+  "held_by_device",
+  "held_from",
+  "plan_note",
+  "held_for",
+  "held_for_name",
+  "plan_only",
+  "plan_edits",
+  "active_at",
+  "settled_at",
+  "snoozed_until",
+  "snoozed_at",
+  "priority",
+  "pause_state",
+  "paused_until",
+  "pause_id",
+  "placed_note",
+  "started_by_device",
+  "pause_note",
+  "started_via",
+  "plan_waits_for_caller",
+  "plan_handoff_message",
+];

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

@@ -0,0 +1,33 @@
+import type Database from "better-sqlite3";
+import { partOf, type PartTable } from "./columns";
+import { writePart } from "./write";
+
+// Copies values onto a session's moved columns where it has none yet: a
+// column that already holds a value, and a null to copy, are left alone.
+// Names that aren't moved columns are the caller's to write.
+export function fillMissing(
+  db: Database.Database,
+  sessionId: string,
+  values: Record<string, string | number | null | undefined>
+): void {
+  const byTable = new Map<PartTable, string[]>();
+  for (const [column, value] of Object.entries(values)) {
+    const table = partOf(column);
+    if (!table || value === null || value === undefined) continue;
+    byTable.set(table, [...(byTable.get(table) ?? []), column]);
+  }
+  db.transaction(() => {
+    for (const [table, columns] of byTable) {
+      const current = db
+        .prepare(`SELECT ${columns.join(", ")} FROM session_rows WHERE id = ?`)
+        .get(sessionId) as Record<string, unknown> | undefined;
+      if (!current) continue;
+      const patch = Object.fromEntries(
+        columns
+          .filter((c) => current[c] === null)
+          .map((c) => [c, values[c]] as const)
+      );
+      writePart(db, table, sessionId, patch as never);
+    }
+  })();
+}

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

@@ -0,0 +1,10 @@
+export * from "./columns";
+export { createSessionRowsView } from "./view";
+export { writePart, type When } from "./write";
+export { setTask, startTaskClock } from "./tasks";
+export { setPr, recordPr } from "./prs";
+export { setPlan, advancePlan } from "./plans";
+export { setPlacement } from "./placement";
+export { setPause } from "./pauses";
+export { fillMissing } from "./fill";
+export { insertSessionRow, updateSessionRow } from "./rows";

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

@@ -0,0 +1,11 @@
+import type Database from "better-sqlite3";
+import type { PartPatch } from "./columns";
+import { writePart, type When } from "./write";
+
+// A task's timed pause.
+export const setPause = (
+  db: Database.Database,
+  sessionId: string,
+  patch: PartPatch<"session_pauses">,
+  when?: When<"session_pauses">
+): boolean => writePart(db, "session_pauses", sessionId, patch, when);

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

@@ -0,0 +1,11 @@
+import type Database from "better-sqlite3";
+import type { PartPatch } from "./columns";
+import { writePart, type When } from "./write";
+
+// Where a task came from and who holds it: mirror, holder, starting device.
+export const setPlacement = (
+  db: Database.Database,
+  sessionId: string,
+  patch: PartPatch<"session_placement">,
+  when?: When<"session_placement">
+): boolean => writePart(db, "session_placement", sessionId, patch, when);

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/rows.ts

@@ -0,0 +1,69 @@
+import type Database from "better-sqlite3";
+import { PART_TABLES, partOf, type PartTable } from "./columns";
+import { writePart } from "./write";
+
+type Value = string | number | null | undefined;
+
+function split(row: Record<string, Value>) {
+  const own: Record<string, Value> = {};
+  const parts = new Map<PartTable, Record<string, Value>>();
+  for (const [column, value] of Object.entries(row)) {
+    if (value === undefined) continue;
+    const table = partOf(column);
+    if (!table) own[column] = value;
+    else parts.set(table, { ...parts.get(table), [column]: value });
+  }
+  return { own, parts };
+}
+
+const writeParts = (
+  db: Database.Database,
+  id: string,
+  parts: Map<PartTable, Record<string, Value>>
+) => {
+  for (const table of PART_TABLES) {
+    const patch = parts.get(table);
+    if (patch) writePart(db, table, id, patch as never);
+  }
+};
+
+// A session row in its flat shape (sessions columns and moved ones together),
+// written to sessions and the part tables. A moved column left null or unset
+// makes no part row. For seeds, imports and tests.
+export function insertSessionRow(
+  db: Database.Database,
+  row: Record<string, Value> & { id: string }
+): void {
+  const { own, parts } = split(row);
+  for (const [table, patch] of parts) {
+    for (const [c, v] of Object.entries(patch))
+      if (v === null || (c === "peer_mirror" && v === 0)) delete patch[c];
+    if (Object.keys(patch).length === 0) parts.delete(table);
+  }
+  const columns = Object.keys(own);
+  db.transaction(() => {
+    db.prepare(
+      `INSERT INTO sessions (${columns.join(", ")})
+       VALUES (${columns.map((c) => `@${c}`).join(", ")})`
+    ).run(own);
+    writeParts(db, row.id, parts);
+  })();
+}
+
+// Updates any of a session's columns by name, wherever each one lives.
+export function updateSessionRow(
+  db: Database.Database,
+  id: string,
+  patch: Record<string, Value>
+): void {
+  const { own, parts } = split(patch);
+  const columns = Object.keys(own);
+  db.transaction(() => {
+    if (columns.length > 0)
+      db.prepare(
+        `UPDATE sessions SET ${columns.map((c) => `${c} = @${c}`).join(", ")}
+          WHERE id = @__id`
+      ).run({ ...own, __id: id });
+    writeParts(db, id, parts);
+  })();
+}

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,50 @@
+import type Database from "better-sqlite3";
+import { PART_COLUMNS, SESSION_ROW_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`: a session with each moved column read from its own table,
+// in the order of SESSION_ROW_COLUMNS (the flat shape a session row always
+// had). A column with a default (peer_mirror) keeps it. Rebuild it in any
+// migration that adds a sessions column. `parts` is the split as that
+// migration knew it; a column on both sessions and a part (before the old
+// columns were dropped) is read from the part.
+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 onSessions = new Set(sessionColumns);
+  const known = new Set(SESSION_ROW_COLUMNS);
+  const names = [
+    ...SESSION_ROW_COLUMNS.filter((c) => source.has(c) || onSessions.has(c)),
+    ...sessionColumns.filter((c) => !known.has(c)),
+  ];
+  const select = names
+    .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,61 @@
+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 (docs/decisions/2026-10-15-split-sessions-table.md). 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);
+    return inserted.changes > 0;
+  });
+  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/done/remote.ts

@@ -4,9 +4,8 @@
 
 import type { Session } from "../db";
 import type { TaskPR } from "../tasks";
-import { git, gitPush } from "../git-exec";
 import { projectPathFor } from "../tasks/session";
-import { PROTECTED_BRANCHES } from "../tasks/finish";
+import { deleteTaskBranch } from "../tasks/remote-branch";
 import { liveChildren } from "../stacks/guard";
 
 export async function deleteMergedRemote(
@@ -14,23 +13,13 @@ export async function deleteMergedRemote(
   pr: TaskPR | null
 ): Promise<boolean> {
   const repo = projectPathFor(s);
-  const branch = s.branch_name;
-  if (
-    !repo ||
-    !branch ||
-    PROTECTED_BRANCHES.has(branch) ||
-    !pr?.head ||
-    liveChildren(s.id).length
-  )
-    return false;
-  const line = await git(
+  if (!repo || !s.branch_name) return false;
+  const out = await deleteTaskBranch({
     repo,
-    ["ls-remote", "--heads", "origin", `refs/heads/${branch}`],
-    { timeout: 30000 }
-  ).catch(() => "");
-  const tip = line.trim().split(/\s+/)[0];
-  if (!tip || tip !== pr.head) return false;
-  return gitPush(repo, ["origin", "--delete", branch], { timeout: 60000 })
-    .then(() => true)
-    .catch(() => false);
+    branch: s.branch_name,
+    prHead: pr?.head,
+    keep: [s.base_branch],
+    hasChildren: liveChildren(s.id).length > 0,
+  });
+  return out.deleted;
 }

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 {