@saadnvd1/agent-os 0.3.637 → 0.3.639

package/lib/chat/registry.ts

@@ -112,9 +112,9 @@ export function emit(sessionId: string, m: ChatServerMessage): void {
 }
 
 export function getSession(sessionId: string): Session {
-  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) throw new Error("Session not found");
   return s;
 }

package/lib/chat/runner.ts

@@ -549,7 +549,7 @@ async function resumeCutOff(sessionId: string): Promise<void> {
     .prepare(
       `SELECT s.name, s.view, s.archived_at, s.task_status, s.role,
          COALESCE(s.workspace_id, p.workspace_id) AS 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.id = ?`
     )
     .get(sessionId) as

package/lib/chat/worker/main.ts

@@ -30,7 +30,7 @@ async function main(sessionId: string) {
   const { ChatHost } = await import("./host");
 
   const row = db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(sessionId) as Session | undefined;
   if (!row) {
     console.error(`No session ${sessionId}`);

package/lib/db/index.ts

@@ -1,16 +1,18 @@
 import Database from "better-sqlite3";
-import path from "path";
 import fs from "fs";
 import { createSchema } from "./schema";
 import { runMigrations } from "./migrations";
 import { dbPath } from "./path";
 
+import { machineDb } from "./machine-scope";
+
 // Re-export types and queries
 export * from "./types";
 export { queries, sessionListColumns } from "./queries";
 export * from "./lumifyhub";
 export * from "./lumifyhub-docs";
 export * from "./stacks";
+export * from "./session-parts";
 
 const DB_PATH = dbPath();
 const LOCK_PATH = DB_PATH + ".init-lock";
@@ -89,6 +91,8 @@ export function initDb(): Database.Database {
 let _db: Database.Database | null = null;
 
 export function getDb(): Database.Database {
+  const scoped = machineDb.getStore();
+  if (scoped) return scoped;
   if (!_db) {
     _db = initDb();
   }

package/lib/db/lumifyhub.ts

@@ -1,4 +1,5 @@
 import type Database from "better-sqlite3";
+import { setTask } from "./session-parts";
 
 // The one LumifyHub account this AgentOS is connected to. The token never
 // leaves the server: callers that talk to the UI map this to a status.
@@ -118,23 +119,21 @@ export const lumifyhubQueries = {
     sessionId: string,
     card: { cardId: string; boardId: string; list: string }
   ) =>
-    db
-      .prepare(
-        `UPDATE sessions SET lh_card_id = ?, lh_board_id = ?, lh_card_list = ? WHERE id = ?`
-      )
-      .run(card.cardId, card.boardId, card.list, sessionId),
+    setTask(db, sessionId, {
+      lh_card_id: card.cardId,
+      lh_board_id: card.boardId,
+      lh_card_list: card.list,
+    }),
 
   setTaskCardList: (db: Database.Database, sessionId: string, list: string) =>
-    db
-      .prepare(`UPDATE sessions SET lh_card_list = ? WHERE id = ?`)
-      .run(list, sessionId),
+    setTask(db, sessionId, { lh_card_list: list }),
 
   linkedCardIds: (db: Database.Database, boardId: string) =>
     new Set(
       (
         db
           .prepare(
-            `SELECT lh_card_id FROM sessions WHERE lh_board_id = ? AND lh_card_id IS NOT NULL`
+            `SELECT lh_card_id FROM session_rows WHERE lh_board_id = ? AND lh_card_id IS NOT NULL`
           )
           .all(boardId) as { lh_card_id: string }[]
       ).map((r) => r.lh_card_id)

package/lib/db/machine-scope.ts

@@ -0,0 +1,12 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import type Database from "better-sqlite3";
+
+/**
+ * Tests only: runs a function against another database, so one process can
+ * stand in for two machines. `getDb()` (and so `db`) follows the scope; in
+ * production nothing is ever scoped and it returns the one database.
+ */
+export const machineDb = new AsyncLocalStorage<Database.Database>();
+
+export const runOnMachine = <T>(database: Database.Database, fn: () => T): T =>
+  machineDb.run(database, fn);

package/lib/db/migrations/20261015T1800_split_sessions_tables.ts

@@ -0,0 +1,172 @@
+import type { Migration } from "../migration-types";
+import type { PartTable } from "../session-parts/columns";
+import { createSessionRowsView } from "../session-parts/view";
+
+// The split of sessions into focused tables, as it was when this shipped:
+// frozen here, so changing the live split never changes what this did.
+const PARTS: Record<string, { columns: [string, string][] }> = {
+  session_tasks: {
+    columns: [
+      ["task_prompt", "TEXT"],
+      ["task_brief", "TEXT"],
+      ["task_status", "TEXT"],
+      ["task_since", "TEXT"],
+      ["task_ended_at", "TEXT"],
+      ["merged_at", "TEXT"],
+      ["priority", "TEXT"],
+      ["quick_of", "TEXT"],
+      ["moved_to", "TEXT"],
+      ["moved_from", "TEXT"],
+      ["model_overrides", "TEXT"],
+      ["lh_card_id", "TEXT"],
+      ["lh_board_id", "TEXT"],
+      ["lh_card_list", "TEXT"],
+    ],
+  },
+  session_prs: {
+    columns: [
+      ["pr_url", "TEXT"],
+      ["pr_number", "INTEGER"],
+      ["pr_status", "TEXT"],
+      ["merge_armed_at", "TEXT"],
+      ["merge_armed_seen", "TEXT"],
+      ["rebased_from", "TEXT"],
+      ["rebased_to", "TEXT"],
+      ["rebase_asked_head", "TEXT"],
+      ["pr_wake_since", "TEXT"],
+    ],
+  },
+  session_plans: {
+    columns: [
+      ["plan_phase", "TEXT"],
+      ["plan_only", "INTEGER"],
+      ["plan_decided", "INTEGER"],
+      ["plan_reason", "TEXT"],
+      ["plan_note", "TEXT"],
+      ["plan_edits", "TEXT"],
+      ["plan_waits_for_caller", "INTEGER"],
+      ["plan_handoff_message", "TEXT"],
+    ],
+  },
+  session_placement: {
+    columns: [
+      ["peer_mirror", "INTEGER NOT NULL DEFAULT 0"],
+      ["placed_note", "TEXT"],
+      ["held_by_device", "TEXT"],
+      ["held_from", "TEXT"],
+      ["held_for", "TEXT"],
+      ["held_for_name", "TEXT"],
+      ["started_by_device", "TEXT"],
+    ],
+  },
+  session_pauses: {
+    columns: [
+      ["pause_state", "TEXT"],
+      ["paused_until", "TEXT"],
+      ["pause_id", "INTEGER"],
+      ["pause_note", "TEXT"],
+    ],
+  },
+};
+
+const hasValue = (prefix: string, column: string) =>
+  column === "peer_mirror"
+    ? `COALESCE(${prefix}.${column}, 0) != 0`
+    : `${prefix}.${column} IS NOT NULL`;
+
+export default {
+  key: "20261015T1800_split_sessions_tables",
+  up: (db) => {
+    // Additive: five tables, each keyed by the session and holding a row only
+    // for a session with a value in its group; the session_rows view that
+    // reads them back as one flat row; and triggers that keep a write to a
+    // legacy sessions column (an older build, a chat worker that has not
+    // restarted) landing in the new tables. No sessions column is touched.
+    // Writers in this build go through lib/db/session-parts. Dropping the old
+    // columns is a later step (docs/decisions/2026-10-15-split-sessions-table.md).
+    db.transaction(() => {
+      for (const [table, { columns }] of Object.entries(PARTS)) {
+        const names = columns.map(([name]) => name);
+
+        db.exec(
+          `CREATE TABLE IF NOT EXISTS ${table} (
+             session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE ON UPDATE CASCADE,
+             ${columns.map(([n, type]) => `${n} ${type}`).join(",\n             ")}
+           )`
+        );
+
+        const anyValue = (prefix: string) =>
+          names.map((n) => hasValue(prefix, n)).join(" OR ");
+        db.exec(
+          `INSERT OR IGNORE INTO ${table} (session_id, ${names.join(", ")})
+           SELECT s.id, ${names.map((n) => `s.${n}`).join(", ")}
+             FROM sessions s WHERE ${anyValue("s")}`
+        );
+
+        db.exec(
+          `CREATE TRIGGER IF NOT EXISTS ${table}_from_sessions_ins
+             AFTER INSERT ON sessions
+             WHEN ${anyValue("NEW")}
+           BEGIN
+             INSERT OR REPLACE INTO ${table} (session_id, ${names.join(", ")})
+             VALUES (NEW.id, ${names.map((n) => `NEW.${n}`).join(", ")});
+           END`
+        );
+        db.exec(
+          `CREATE TRIGGER IF NOT EXISTS ${table}_from_sessions_upd
+             AFTER UPDATE OF ${names.join(", ")} ON sessions
+             WHEN ${names.map((n) => `NEW.${n} IS NOT OLD.${n}`).join(" OR ")}
+           BEGIN
+             INSERT INTO ${table} (session_id, ${names.join(", ")})
+             VALUES (NEW.id, ${names.map((n) => `NEW.${n}`).join(", ")})
+             ON CONFLICT(session_id) DO UPDATE SET
+               ${names
+                 .map(
+                   (n) =>
+                     `${n} = CASE WHEN NEW.${n} IS NOT OLD.${n} THEN excluded.${n} ELSE ${table}.${n} END`
+                 )
+                 .join(",\n               ")};
+           END`
+        );
+        db.exec(
+          `CREATE TRIGGER IF NOT EXISTS ${table}_from_sessions_del
+             AFTER DELETE ON sessions
+           BEGIN
+             DELETE FROM ${table} WHERE session_id = OLD.id;
+           END`
+        );
+
+        for (const [suffix, event] of [
+          ["ins", "INSERT"],
+          ["upd", "UPDATE"],
+          ["del", "DELETE"],
+        ])
+          db.exec(
+            `CREATE TRIGGER IF NOT EXISTS ${table}_bump_sessions_${suffix}
+               AFTER ${event} ON ${table}
+             BEGIN
+               INSERT INTO change_versions (topic, version) VALUES ('sessions', 1)
+               ON CONFLICT(topic) DO UPDATE SET version = version + 1;
+             END`
+          );
+      }
+
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_session_tasks_status ON session_tasks(task_status)`
+      );
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_session_tasks_moved_from ON session_tasks(moved_from)`
+      );
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_session_tasks_quick_of ON session_tasks(quick_of) WHERE quick_of IS NOT NULL`
+      );
+
+      createSessionRowsView(
+        db,
+        Object.fromEntries(
+          Object.entries(PARTS).map(([t, p]) => [t, p.columns.map(([n]) => n)])
+        ) as Record<PartTable, string[]>
+      );
+    })();
+  },
+} satisfies Migration;

package/lib/db/migrations/README.md

@@ -33,3 +33,10 @@ export default {
   `lib/db/migrations.ts` loads. `lib/db/migrations.test.ts` also checks order, the
   legacy bodies, and that a database migrated before the split would run nothing
   again.
+- Adding a column to `sessions`? `session_rows` (the view that reads a session
+  with its columns from the tables they moved to) lists the columns at the time
+  it was built. Add the name to `SESSION_ROW_COLUMNS` in
+  `lib/db/session-parts/columns.ts` and call `createSessionRowsView(db)` after
+  the `ALTER`; `lib/db/split-sessions-migration.test.ts` fails if the view and
+  the table disagree. Columns that belong to a group go in `PART_COLUMNS` and a
+  new migration for that table instead.

package/lib/db/queries.ts

@@ -1,4 +1,5 @@
 import type Database from "better-sqlite3";
+import { SESSION_ROW_COLUMNS } from "./session-parts/columns";
 
 // Prepared statement cache
 const stmtCache = new Map<string, Database.Statement>();
@@ -13,28 +14,18 @@ function getStmt(db: Database.Database, sql: string): Database.Statement {
   return stmt;
 }
 
-// Every sessions column but the two large text ones, which only the single
+// Every session column but the two large text ones, which only the single
 // session paths read; a list gets has_brief for whether a brief exists.
-const listColumns = new WeakMap<Database.Database, string>();
-export function sessionListColumns(db: Database.Database, alias = ""): string {
-  let cols = listColumns.get(db);
-  if (!cols) {
-    cols = (
-      db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
-    )
-      .map((c) => c.name)
-      .filter((n) => n !== "task_brief" && n !== "system_prompt")
-      .join(",");
-    listColumns.set(db, cols);
-  }
+// Read from session_rows (lib/db/session-parts).
+const LIST_COLUMNS = SESSION_ROW_COLUMNS.filter(
+  (n) => n !== "task_brief" && n !== "system_prompt"
+);
+export function sessionListColumns(_db: Database.Database, alias = ""): string {
   const prefix = alias ? `${alias}.` : "";
-  const list = cols
-    .split(",")
-    .map((c) => `${prefix}${c}`)
-    .join(", ");
+  const list = LIST_COLUMNS.map((c) => `${prefix}${c}`).join(", ");
   // The recipe run or feature piece a session is, as JSON, for its row's chip.
-  const recipe = `(SELECT json_object('id', r.id, 'name', r.name, 'seq', rr.seq, 'status', rr.status) FROM recipe_runs rr JOIN recipes r ON r.id = rr.recipe_id WHERE rr.session_id = ${alias || "sessions"}.id)`;
-  const piece = `(SELECT json_object('feature', f.id, 'name', f.name, 'position', fp.position, 'total', (SELECT COUNT(*) FROM feature_pieces WHERE feature_id = f.id AND status != 'dropped')) FROM feature_pieces fp JOIN features f ON f.id = fp.feature_id WHERE fp.session_id = ${alias || "sessions"}.id)`;
+  const recipe = `(SELECT json_object('id', r.id, 'name', r.name, 'seq', rr.seq, 'status', rr.status) FROM recipe_runs rr JOIN recipes r ON r.id = rr.recipe_id WHERE rr.session_id = ${alias || "session_rows"}.id)`;
+  const piece = `(SELECT json_object('feature', f.id, 'name', f.name, 'position', fp.position, 'total', (SELECT COUNT(*) FROM feature_pieces WHERE feature_id = f.id AND status != 'dropped')) FROM feature_pieces fp JOIN features f ON f.id = fp.feature_id WHERE fp.session_id = ${alias || "session_rows"}.id)`;
   return `${list}, (${prefix}task_brief IS NOT NULL AND ${prefix}task_brief != '') AS has_brief, ${recipe} AS recipe_run, ${piece} AS feature_piece`;
 }
 
@@ -48,12 +39,12 @@ export const queries = {
     ),
 
   getSession: (db: Database.Database) =>
-    getStmt(db, `SELECT * FROM sessions WHERE id = ?`),
+    getStmt(db, `SELECT * FROM session_rows WHERE id = ?`),
 
   getAllSessions: (db: Database.Database) =>
     getStmt(
       db,
-      `SELECT ${sessionListColumns(db)} FROM sessions ORDER BY updated_at DESC`
+      `SELECT ${sessionListColumns(db)} FROM session_rows ORDER BY updated_at DESC`
     ),
 
   // The sidebar's sessions: not archived, and not a dropped task (a
@@ -62,7 +53,7 @@ export const queries = {
   getSidebarSessions: (db: Database.Database) =>
     getStmt(
       db,
-      `SELECT ${sessionListColumns(db)} FROM sessions
+      `SELECT ${sessionListColumns(db)} FROM session_rows
          WHERE archived_at IS NULL
            AND (task_status IS NULL
                 OR task_status NOT IN ('dropped', 'moved'))
@@ -103,12 +94,6 @@ export const queries = {
       `UPDATE sessions SET worktree_path = ?, branch_name = ?, base_branch = ?, dev_server_port = ?, updated_at = datetime('now') WHERE id = ?`
     ),
 
-  updateSessionPR: (db: Database.Database) =>
-    getStmt(
-      db,
-      `UPDATE sessions SET pr_url = ?, pr_number = ?, pr_status = ?, updated_at = datetime('now') WHERE id = ?`
-    ),
-
   updateSessionGroup: (db: Database.Database) =>
     getStmt(
       db,
@@ -118,7 +103,7 @@ export const queries = {
   getSessionsByGroup: (db: Database.Database) =>
     getStmt(
       db,
-      `SELECT * FROM sessions WHERE group_path = ? ORDER BY updated_at DESC`
+      `SELECT * FROM session_rows WHERE group_path = ? ORDER BY updated_at DESC`
     ),
 
   moveSessionsToGroup: (db: Database.Database) =>
@@ -136,14 +121,14 @@ export const queries = {
   getSessionsByProject: (db: Database.Database) =>
     getStmt(
       db,
-      `SELECT * FROM sessions WHERE project_id = ? ORDER BY updated_at DESC`
+      `SELECT * FROM session_rows WHERE project_id = ? ORDER BY updated_at DESC`
     ),
 
   // Orchestration
   getWorkersByConductor: (db: Database.Database) =>
     getStmt(
       db,
-      `SELECT * FROM sessions WHERE conductor_session_id = ? ORDER BY created_at ASC`
+      `SELECT * FROM session_rows WHERE conductor_session_id = ? ORDER BY created_at ASC`
     ),
 
   updateWorkerStatus: (db: Database.Database) =>

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);
+
+// Every column of the sessions table, in order: the shape of a session row
+// and of `session_rows`. 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,9 @@
+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";

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);