@saadnvd1/agent-os 0.3.637 → 0.3.644

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

@@ -0,0 +1,40 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261015T1733_gate_loop_guard",
+  up: (db) => {
+    // The loop guard (orchestrator/loop-guard.ts): how many commits in a row
+    // a gate has failed on, the last failure's signature, whether it repeated
+    // the one before, and the reason the task went to Saad. Additive.
+    const columns = (table: string) =>
+      new Set(
+        (
+          db.prepare(`PRAGMA table_info(${table})`).all() as { name: string }[]
+        ).map((c) => c.name)
+      );
+    const failures = columns("orchestrator_gate_failures");
+    if (!failures.has("streak")) {
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failures ADD COLUMN streak INTEGER NOT NULL DEFAULT 0`
+      );
+      // A pass never reset the old count, so it's the most the streak can be.
+      db.exec(`UPDATE orchestrator_gate_failures SET streak = count`);
+    }
+    if (!failures.has("last_signature"))
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failures ADD COLUMN last_signature TEXT`
+      );
+    if (!failures.has("repeated"))
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failures ADD COLUMN repeated INTEGER NOT NULL DEFAULT 0`
+      );
+    if (!failures.has("escalated_why"))
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failures ADD COLUMN escalated_why TEXT`
+      );
+    if (!columns("orchestrator_gate_failure_commits").has("signature"))
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failure_commits ADD COLUMN signature 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/20261015T1830_drop_moved_session_columns.ts

@@ -0,0 +1,173 @@
+import type { Migration } from "../migration-types";
+import type { PartTable } from "../session-parts/columns";
+import { createSessionRowsView } from "../session-parts/view";
+import { backupDatabase } from "../backup";
+
+// The moved columns as 20261015T1800 split them, frozen here.
+const PARTS: Record<PartTable, string[]> = {
+  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"],
+};
+
+const hasValue = (prefix: string, column: string) =>
+  column === "peer_mirror"
+    ? `COALESCE(${prefix}.${column}, 0) != 0`
+    : `${prefix}.${column} IS NOT NULL`;
+
+// A value in the part table wins (it is the newer write); one only on
+// sessions is carried over.
+const carried = (table: string, column: string) =>
+  column === "peer_mirror"
+    ? `MAX(COALESCE(${table}.${column}, 0), COALESCE(s.${column}, 0))`
+    : `COALESCE(${table}.${column}, s.${column})`;
+
+export default {
+  key: "20261015T1830_drop_moved_session_columns",
+  up: (db) => {
+    // The destructive half of the split (docs/decisions/2026-10-15-split-sessions-table.md):
+    // the 42 moved columns leave sessions. A full copy of the database comes
+    // first, and nothing changes unless it was written. Every value still only
+    // on sessions is carried into its table before the columns go.
+    const parts = Object.entries(PARTS) as [PartTable, string[]][];
+    const remaining = () => {
+      const onSessions = new Set(
+        (
+          db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
+        ).map((c) => c.name)
+      );
+      return parts.flatMap(([, cs]) => cs).filter((c) => onSessions.has(c));
+    };
+    if (remaining().length === 0) return;
+
+    const sessions = (
+      db.prepare(`SELECT COUNT(*) AS n FROM sessions`).get() as { n: number }
+    ).n;
+    // An empty sessions table holds nothing these columns could lose.
+    if (sessions > 0) backupDatabase(db, "drop-moved-session-columns");
+
+    // Immediate, and re-read inside: another process opening the same
+    // database may have run this between the check and the lock.
+    db.transaction(() => {
+      const left = remaining();
+      if (left.length === 0) return;
+      for (const [table, all] of parts) {
+        const columns = all.filter((c) => left.includes(c));
+        if (columns.length === 0) continue;
+        db.exec(
+          `INSERT INTO ${table} (session_id, ${columns.join(", ")})
+           SELECT s.id, ${columns.map((c) => `s.${c}`).join(", ")}
+             FROM sessions s
+            WHERE (${columns.map((c) => hasValue("s", c)).join(" OR ")})
+              AND NOT EXISTS (SELECT 1 FROM ${table} p WHERE p.session_id = s.id)`
+        );
+        db.exec(
+          `UPDATE ${table} SET
+             ${columns.map((c) => `${c} = ${carried(table, c)}`).join(",\n             ")}
+             FROM sessions s WHERE s.id = ${table}.session_id`
+        );
+        db.exec(`DROP TRIGGER IF EXISTS ${table}_from_sessions_ins`);
+        db.exec(`DROP TRIGGER IF EXISTS ${table}_from_sessions_upd`);
+      }
+
+      // merged_at and task_ended_at are stamped where task_status now lives.
+      // A first write of a status inserts the row; a later one updates it.
+      db.exec(`DROP TRIGGER IF EXISTS sessions_task_ended_at`);
+      db.exec(`DROP TRIGGER IF EXISTS sessions_merged_at`);
+      db.exec(`
+        CREATE TRIGGER IF NOT EXISTS session_tasks_ended_at_upd
+          AFTER UPDATE OF task_status ON session_tasks
+          WHEN NEW.task_status IN ('dropped', 'done')
+            AND OLD.task_status IS NOT NEW.task_status
+            AND NEW.task_ended_at IS OLD.task_ended_at
+        BEGIN
+          UPDATE session_tasks SET task_ended_at = datetime('now')
+           WHERE session_id = NEW.session_id;
+        END
+      `);
+      db.exec(`
+        CREATE TRIGGER IF NOT EXISTS session_tasks_ended_at_ins
+          AFTER INSERT ON session_tasks
+          WHEN NEW.task_status IN ('dropped', 'done')
+            AND NEW.task_ended_at IS NULL
+        BEGIN
+          UPDATE session_tasks SET task_ended_at = datetime('now')
+           WHERE session_id = NEW.session_id;
+        END
+      `);
+      db.exec(`
+        CREATE TRIGGER IF NOT EXISTS session_tasks_merged_at_upd
+          AFTER UPDATE OF task_status ON session_tasks
+          WHEN NEW.task_status = 'merged' AND OLD.task_status IS NOT 'merged'
+            -- unless the same statement set it (an import keeps its own)
+            AND NEW.merged_at IS OLD.merged_at
+        BEGIN
+          UPDATE session_tasks SET merged_at = datetime('now')
+           WHERE session_id = NEW.session_id;
+        END
+      `);
+      db.exec(`
+        CREATE TRIGGER IF NOT EXISTS session_tasks_merged_at_ins
+          AFTER INSERT ON session_tasks
+          WHEN NEW.task_status = 'merged' AND NEW.merged_at IS NULL
+        BEGIN
+          UPDATE session_tasks SET merged_at = datetime('now')
+           WHERE session_id = NEW.session_id;
+        END
+      `);
+
+      db.exec(`DROP VIEW IF EXISTS session_rows`);
+      db.exec(`DROP INDEX IF EXISTS idx_sessions_task_status`);
+      db.exec(`DROP INDEX IF EXISTS idx_sessions_moved_from`);
+      db.exec(`DROP INDEX IF EXISTS idx_sessions_quick_of`);
+      for (const column of left)
+        db.exec(`ALTER TABLE sessions DROP COLUMN ${column}`);
+
+      createSessionRowsView(db, PARTS);
+    }).immediate();
+  },
+} satisfies Migration;

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

@@ -0,0 +1,30 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261015T1900_worktree_sweep",
+  up: (db) => {
+    // One row per clean-up run, kept for good, with what it removed and
+    // skipped as JSON; and which sessions' worktrees a run removed, so a
+    // restore can say so. Additive.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS worktree_sweep_runs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        started_at TEXT NOT NULL DEFAULT (datetime('now')),
+        finished_at TEXT,
+        dry_run INTEGER NOT NULL DEFAULT 0,
+        removed INTEGER NOT NULL DEFAULT 0,
+        freed_bytes INTEGER NOT NULL DEFAULT 0,
+        skipped INTEGER NOT NULL DEFAULT 0,
+        details TEXT,
+        error TEXT
+      );
+      CREATE TABLE IF NOT EXISTS session_worktree_sweeps (
+        session_id TEXT PRIMARY KEY,
+        path TEXT NOT NULL,
+        branch TEXT,
+        swept_at TEXT NOT NULL DEFAULT (datetime('now')),
+        run_id INTEGER
+      );
+    `);
+  },
+} satisfies Migration;

package/lib/db/migrations/README.md

@@ -33,3 +33,14 @@ 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, in the order of `SESSION_ROW_COLUMNS`. 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.
+- A destructive step (dropping a column or table) takes a full copy first:
+  `backupDatabase` in `lib/db/backup.ts` (`VACUUM INTO` under
+  `~/.agent-os/backups/`), and throws so the migration stops if it can't.

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