@saadnvd1/agent-os 0.3.631 → 0.3.639

package/lib/away/report.ts

@@ -137,7 +137,7 @@ function merged(
   const rows = db
     .prepare(
       `SELECT s.id, s.name, p.name AS project, p.id AS project_id, s.pr_number, s.pr_url
-       FROM sessions s JOIN projects p ON p.id = s.project_id
+       FROM session_rows s JOIN projects p ON p.id = s.project_id
        WHERE p.workspace_id = ? AND s.task_status = 'merged'
          AND s.merged_at >= ? AND s.merged_at <= ?
        ORDER BY s.merged_at, s.id`
@@ -178,7 +178,7 @@ function inFlight(workspaceId: string, awayId: number): InFlightItem[] {
     .prepare(
       `SELECT s.id, s.name, p.name AS project, s.pr_number, s.pr_url,
          s.merge_armed_at AS armed_at
-       FROM sessions s JOIN projects p ON p.id = s.project_id
+       FROM session_rows s JOIN projects p ON p.id = s.project_id
        WHERE p.workspace_id = ? AND s.role IS NULL AND s.archived_at IS NULL
          AND s.task_status = 'running'
          AND EXISTS (SELECT 1 FROM away_actions a WHERE a.away_id = ?
@@ -224,7 +224,7 @@ function failed(workspaceId: string, away: AwayRow, end: string) {
   const deploys = db
     .prepare(
       `SELECT a.detail, s.name, s.pr_number, s.pr_url FROM away_actions a
-       LEFT JOIN sessions s ON s.id = a.subject
+       LEFT JOIN session_rows s ON s.id = a.subject
        WHERE a.away_id = ? AND a.workspace_id = ? AND a.kind = 'deploy_failed'
        ORDER BY a.id`
     )
@@ -236,7 +236,7 @@ function failed(workspaceId: string, away: AwayRow, end: string) {
   }[];
   const ended = db
     .prepare(
-      `SELECT s.name, s.task_status, s.pr_number, s.pr_url FROM sessions s
+      `SELECT s.name, s.task_status, s.pr_number, s.pr_url FROM session_rows s
        JOIN projects p ON p.id = s.project_id
        WHERE p.workspace_id = ? AND s.task_status IN ('dropped', 'done')
          AND s.task_ended_at >= ? AND s.task_ended_at <= ?

package/lib/away/run.ts

@@ -69,7 +69,7 @@ function orchestrated(): { workspaceId: string; orchestratorId: string }[] {
 }
 
 const sessionRow = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
 
@@ -330,7 +330,7 @@ async function checkDeploys(
   const found: DeployFinding[] = [];
   const merged = db
     .prepare(
-      `SELECT s.* FROM sessions s JOIN projects p ON p.id = s.project_id
+      `SELECT s.* FROM session_rows s JOIN projects p ON p.id = s.project_id
        WHERE p.workspace_id = ? AND s.task_status = 'merged' AND s.merged_at >= ?
          AND NOT EXISTS (SELECT 1 FROM away_actions a
            WHERE a.away_id = ? AND a.key = 'deploy:' || s.id)`

package/lib/bookmarks/store.ts

@@ -57,7 +57,7 @@ type Joined = Row & {
 // The bookmark with its chat's state as of now.
 const SELECT = `
   SELECT b.*, s.id AS s_id, s.task_status, s.archived_at
-  FROM chat_bookmarks b LEFT JOIN sessions s ON s.id = b.session_id`;
+  FROM chat_bookmarks b LEFT JOIN session_rows s ON s.id = b.session_id`;
 
 function toBookmark(r: Joined): Bookmark {
   return {
@@ -141,7 +141,7 @@ export function createBookmark(input: {
     throw new BookmarkError("scope must be 'item' or 'turn'", 400);
   const note = cleanNote(input.note);
   const session = db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(sessionId) as Session | undefined;
   if (!session) throw new BookmarkError("Session not found", 404);
   const existing = db
@@ -308,7 +308,7 @@ export function insertMovedBookmarks(
 ): void {
   if (!rows.length) return;
   const session = db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(sessionId) as Session | undefined;
   if (!session) return;
   const workspace = sessionWorkspace(session);

package/lib/bus/held-reply.ts

@@ -68,7 +68,7 @@ export function pendingReplies(device: string, limit = 50): PendingReply[] {
     db
       .prepare(
         `SELECT m.id, m.from_id AS fromId, m.body, m.created_at AS createdAt
-         FROM bus_messages m JOIN sessions s ON s.id = m.from_id
+         FROM bus_messages m JOIN session_rows s ON s.id = m.from_id
          WHERE m.relay_state = 'pending' AND s.held_by_device = ?
          ORDER BY m.id LIMIT ?`
       )
@@ -81,7 +81,7 @@ export function ackReplies(device: string, ids: number[]): void {
   const mark = db.prepare(
     `UPDATE bus_messages SET relay_state = 'relayed', delivered_at = datetime('now')
      WHERE id = ? AND relay_state = 'pending'
-       AND from_id IN (SELECT id FROM sessions WHERE held_by_device = ?)`
+       AND from_id IN (SELECT id FROM session_rows WHERE held_by_device = ?)`
   );
   db.transaction(() => {
     for (const id of ids) mark.run(id, device);

package/lib/bus/index.ts

@@ -15,7 +15,7 @@ import { deliverToPane, type Delivery } from "./delivery";
 import { resolveRef, wasNames, type Candidate } from "./resolve";
 import { tmuxPane } from "./tmux-pane";
 import { pauseHoldOf, pausedNote } from "../tasks/pause-hold";
-import { isHeldRemote, relayToHeldTask } from "../tasks/held-remote";
+import { isHeldRemote, relayToHeldTask } from "../tasks/contract/held-calls";
 import {
   assertTakesMessages,
   findQueuedTarget,
@@ -43,7 +43,7 @@ export interface Peer {
 function liveSessions(): Session[] {
   return db
     .prepare(
-      `SELECT * FROM sessions WHERE (task_status IS NULL OR task_status = 'running')
+      `SELECT * FROM session_rows WHERE (task_status IS NULL OR task_status = 'running')
          AND archived_at IS NULL
        ORDER BY updated_at DESC`
     )
@@ -63,7 +63,7 @@ function candidates(sessions: Session[]): Candidate[] {
 
 const sessionById = (id: string | null | undefined) =>
   id
-    ? (db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    ? (db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
         | Session
         | undefined)
     : undefined;

package/lib/chat/compact-context.ts

@@ -28,7 +28,7 @@ async function gitStatus(cwd: string): Promise<string> {
 export async function compactContext(sessionId: string): Promise<string> {
   const session = db
     .prepare(
-      `SELECT working_directory, task_prompt, role FROM sessions WHERE id = ?`
+      `SELECT working_directory, task_prompt, role FROM session_rows WHERE id = ?`
     )
     .get(sessionId) as
     | Pick<Session, "working_directory" | "task_prompt" | "role">

package/lib/chat/events.ts

@@ -149,6 +149,10 @@ export type ChatItem =
       // Saved since messages were tagged where they're sent: without an
       // origin, the reader typed it. Older items are matched by their text.
       tagged?: true;
+      // Whether it was sent while a turn ran: the agent then reads it once
+      // that turn ends, so what follows until then is still that turn's.
+      // Always set when saved; absent only on history from before it was.
+      midTurn?: boolean;
       // The provider's id for this message, to undo file changes back to it.
       checkpoint?: string;
     })

package/lib/chat/group.ts

@@ -1,4 +1,5 @@
 import type { ChatItem } from "./events";
+import { readingOrder } from "./reading-order";
 import { eventTurnAt, type EventTurn } from "./turns";
 
 export type ToolItem = Extract<ChatItem, { kind: "tool" }>;
@@ -23,9 +24,10 @@ export const STANDALONE_TOOLS = new Set(["Skill", "Task", "Agent"]);
 // collapsible block, so a long turn reads as what was said, not every step.
 // Undone messages fold into one block behind the undo that took them back.
 export function groupTimeline(
-  items: ChatItem[],
+  all: ChatItem[],
   opts: GroupOptions = {}
 ): TimelineBlock[] {
+  const items = opts.foldEvents ? readingOrder(all) : all;
   const blocks: TimelineBlock[] = [];
   let tools: ToolItem[] = [];
   const flush = () => {

package/lib/chat/hold.ts

@@ -15,10 +15,10 @@ import { db } from "../db";
 
 // The SQL form, for queries that take the session id as @sid.
 export const HELD_SQL = `(
-  EXISTS (SELECT 1 FROM sessions WHERE id = @sid AND task_status = 'moving')
+  EXISTS (SELECT 1 FROM session_rows WHERE id = @sid AND task_status = 'moving')
   OR EXISTS (SELECT 1 FROM stack_items i JOIN stacks s ON s.id = i.stack_id
              WHERE i.session_id = @sid AND s.status = 'landing')
-  OR EXISTS (SELECT 1 FROM sessions WHERE id = @sid
+  OR EXISTS (SELECT 1 FROM session_rows WHERE id = @sid
              AND pause_state IN ('pausing', 'paused'))
 )`;
 
@@ -58,7 +58,7 @@ const holdRow = (sessionId: string) =>
       `SELECT task_status, moved_to, quick_of, pause_state, paused_until,
          EXISTS (SELECT 1 FROM stack_items i JOIN stacks s ON s.id = i.stack_id
                  WHERE i.session_id = @sid AND s.status = 'landing') AS landing
-       FROM sessions WHERE id = @sid`
+       FROM session_rows WHERE id = @sid`
     )
     .get({ sid: sessionId }) as HoldRow | undefined;
 

package/lib/chat/reading-order.ts

@@ -0,0 +1,50 @@
+import type { ChatItem } from "./events";
+import { activityOrigin } from "./turns";
+
+// Activity sent while a turn runs is saved when sent but read by the agent
+// once that turn ends. It moves to after the turn's end, so the turn a
+// person's message started stays whole and the activity gets its own reply.
+//
+// Several waiting at one turn's end are taken a turn each: the first starts
+// after the end, the next after the following one. Whether the agent
+// answers them together or apart isn't recorded, and this way a turn each
+// keeps every reply with its own event; answered together, the first takes
+// the reply and the rest show as bare rows.
+//
+// A message saved with `midTurn` is trusted either way. Only history from
+// before the field is guessed, from whether a turn was open when it landed.
+export function readingOrder(items: ChatItem[]): ChatItem[] {
+  const out: ChatItem[] = [];
+  const waiting: ChatItem[] = [];
+  let open = false;
+  let moved = false;
+  const release = () => out.push(...waiting.splice(0));
+  for (const item of items) {
+    if (item.kind === "user") {
+      const waits = item.midTurn === undefined ? open : item.midTurn;
+      if (waits && activityOrigin(item)) {
+        waiting.push(item);
+        moved = true;
+        continue;
+      }
+      release();
+      out.push(item);
+      open = true;
+    } else if (item.kind === "turn_end") {
+      out.push(item);
+      open = false;
+      const next = waiting.shift();
+      if (next) out.push(next);
+    } else if (
+      item.kind === "undo" ||
+      item.kind === "error" ||
+      item.kind === "command_output"
+    ) {
+      release();
+      out.push(item);
+      open = false;
+    } else out.push(item);
+  }
+  release();
+  return moved ? out : items;
+}

package/lib/chat/refresh.ts

@@ -163,7 +163,7 @@ export function autoCompactEnv(sessionId: string): Record<string, string> {
   const row = db
     .prepare(
       `SELECT role, task_status, plan_phase, started_by, model_provider
-       FROM sessions WHERE id = ?`
+       FROM session_rows WHERE id = ?`
     )
     .get(sessionId) as
     | {

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

@@ -18,8 +18,6 @@ export interface EventTurn {
   at: number;
   // Still being answered.
   live: boolean;
-  // The reply opened a question for the reader.
-  hasQuestion: boolean;
 }
 
 const FOLDED_KINDS = new Set(["event", "peer", "schedule", "system"]);
@@ -39,6 +37,26 @@ export function activityOrigin(item: UserItem): ChatOrigin | null {
 export const isQuestionTool = (item: ChatItem): boolean =>
   item.kind === "tool" && /(^|__)question$/.test(item.name);
 
+export const isAskTool = (item: ChatItem): boolean =>
+  item.kind === "tool" && /(^|__)ask_saad$/.test(item.name);
+
+// The assistant message a question was asked in (its turn's last words
+// before the call), else the call itself.
+export function questionSource(items: ChatItem[], text: string): string | null {
+  const at = items.findLastIndex(
+    (i) =>
+      isQuestionTool(i) &&
+      (i as { input?: { text?: string } }).input?.text === text
+  );
+  if (at === -1) return null;
+  for (let i = at - 1; i >= 0; i--) {
+    const item = items[i];
+    if (item.kind === "user" || item.kind === "turn_end") break;
+    if (item.kind === "assistant" && item.text.trim()) return item.id;
+  }
+  return items[at].id;
+}
+
 export function plainSummary(text: string, max = 140): string {
   const line =
     text
@@ -89,6 +107,8 @@ export function eventTurnAt(
     (i) =>
       i.kind === "plan" ||
       i.kind === "error" ||
+      isQuestionTool(i) ||
+      isAskTool(i) ||
       (i.kind === "approval" && i.status === "pending")
   );
   if (needsReader) return null;
@@ -105,7 +125,6 @@ export function eventTurnAt(
       task: taskName(origin),
       at: user.createdAt,
       live: !ended && end >= items.length,
-      hasQuestion: replies.some(isQuestionTool),
     },
   };
 }

package/lib/chat/worker/host.ts

@@ -564,6 +564,8 @@ export class ChatHost {
     this.sent.add(m.id);
     this.currentTurn = m.id;
     this.hardStopAt = 0;
+    // A message sent now stops the turn and is read next: nothing waits.
+    const midTurn = this.busy() && !now;
     if (this.busy()) this.behind++;
     // Sent now, it stops the running turn, which still ends after this.
     if (!this.busy()) now = false;
@@ -599,6 +601,7 @@ export class ChatHost {
       peer: m.peer,
       origin: m.origin,
       tagged: true as const,
+      midTurn,
       createdAt: Date.now(),
       checkpoint,
     };

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/20261015T1600_plan_waits_for_caller.ts

@@ -0,0 +1,19 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261015T1600_plan_waits_for_caller",
+  up: (db) => {
+    // A plan another machine placed here: it stops at the plan for that
+    // machine to decide what comes next. On the machine that placed it, the
+    // approval's message waits for the move home. Additive.
+    const add = (col: string, type: string) => {
+      const columns = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+        name: string;
+      }[];
+      if (!columns.some((c) => c.name === col))
+        db.exec(`ALTER TABLE sessions ADD COLUMN ${col} ${type}`);
+    };
+    add("plan_waits_for_caller", "INTEGER");
+    add("plan_handoff_message", "TEXT");
+  },
+} satisfies Migration;

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.