@saadnvd1/agent-os 0.3.596 → 0.3.600

package/app/api/bus/spawn/route.ts

@@ -5,17 +5,14 @@ import { startOrQueue, stampPriority } from "@/lib/tasks/queue";
 import { isPriority } from "@/lib/tasks/schedule-types";
 import { hostIdNamed } from "@/lib/hosts";
 import { startView } from "@/lib/sessions/launch";
-import { db } from "@/lib/db";
-
-// The calling session, when it's an orchestrator: what it starts runs on the
-// implementation model. A made-up `from` can only pick that cheaper role.
-function orchestratorFrom(from: unknown): string | null {
-  if (typeof from !== "string" || !from) return null;
-  const row = db
-    .prepare(`SELECT 1 FROM sessions WHERE id = ? AND role = 'orchestrator'`)
-    .get(from);
-  return row ? from : null;
-}
+import { callerSession, starterOf } from "@/lib/tasks/starter";
+import { callingDevice } from "@/lib/security/device-me";
+import {
+  findPiece,
+  pieceLabel,
+  pieceRefusal,
+  waitingPiecesFor,
+} from "@/lib/plans/claim";
 
 // mode "session" starts an interactive agent; "task" starts one that ends in
 // a PR, or queues it (over the workspace's limit, or with `after`).
@@ -34,8 +31,15 @@ export async function POST(request: NextRequest) {
       priority,
       machine,
       from,
+      cwd,
+      piece,
     } = await request.json();
-    const startedBy = orchestratorFrom(from);
+    // Whoever called: a session (by `from`, else the worktree it runs in) or a person.
+    const starter = starterOf(
+      callerSession({ from, cwd }),
+      callingDevice(request)
+    );
+    const { startedBy } = starter;
     const given = typeof name === "string" ? name : undefined;
     if (after !== undefined && mode !== "task")
       throw new Error("--after works for tasks only");
@@ -47,16 +51,29 @@ export async function POST(request: NextRequest) {
       throw new Error("--priority is urgent, blocking, normal or background");
     if (machine !== undefined && machine !== "mac" && machine !== "any")
       throw new Error('machine is "mac" or "any"');
+    if (piece !== undefined && mode !== "task")
+      throw new Error("--piece works for tasks only");
     if (mode === "task") {
+      const projectId = findProject(String(project ?? "")).id;
+      // A task whose plan has pieces waiting here must say which it builds.
+      const waiting = startedBy ? waitingPiecesFor(startedBy, projectId) : [];
+      let pieceId: number | undefined;
+      if (piece !== undefined) {
+        if (typeof piece !== "string" || !piece.trim())
+          throw new Error("--piece needs a piece name");
+        pieceId = findPiece(waiting, piece).id;
+      } else if (waiting.length)
+        throw new Error(pieceRefusal(waiting, projectId));
       const task = {
-        projectId: findProject(String(project ?? "")).id,
+        projectId,
+        ...starter,
+        pieceId,
         prompt: String(prompt ?? ""),
         name: given,
         model,
         hostId: on ? hostIdNamed(String(on)) : undefined,
         view: startView(view),
         planOnly: planOnly === true ? true : undefined,
-        startedBy,
       };
       const out = await startOrQueue(
         {
@@ -71,9 +88,10 @@ export async function POST(request: NextRequest) {
           return session;
         }
       );
+      const builds = pieceId ? pieceLabel(pieceId) : undefined;
       return "queued" in out
-        ? NextResponse.json({ queued: out.queued }, { status: 202 })
-        : NextResponse.json({ session: out.started }, { status: 201 });
+        ? NextResponse.json({ queued: out.queued, builds }, { status: 202 })
+        : NextResponse.json({ session: out.started, builds }, { status: 201 });
     }
     const session = await spawnSession({
       project: String(project ?? ""),
@@ -81,6 +99,7 @@ export async function POST(request: NextRequest) {
       name: given,
       model,
       startedBy,
+      parentSessionId: starter.parentSessionId,
     });
     return NextResponse.json({ session }, { status: 201 });
   } catch (error) {

package/app/api/lumifyhub/cards/[cardId]/run/route.ts

@@ -3,6 +3,7 @@ import { body, respond } from "@/lib/lumifyhub/http";
 import { lumifyHubId } from "@/lib/lumifyhub/ids";
 import { cardForTask, promptFromCard } from "@/lib/lumifyhub/task-cards";
 import { createTask } from "@/lib/tasks";
+import { callingDevice } from "@/lib/security/device-me";
 
 type RouteParams = { params: Promise<{ cardId: string }> };
 
@@ -20,6 +21,8 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
       prompt: promptFromCard(card),
       name: card.title,
       cardId: card.id,
+      startedVia: "person",
+      startedByDevice: callingDevice(request) ?? undefined,
     });
     return { session };
   });

package/app/api/tasks/route.ts

@@ -85,6 +85,8 @@ export async function POST(request: NextRequest) {
       hostId: typeof hostId === "string" && hostId ? hostId : undefined,
       baseBranch: typeof baseBranch === "string" ? baseBranch : undefined,
       view: startView(view),
+      startedVia: "person" as const,
+      startedByDevice: callingDevice(request) ?? undefined,
     };
     if (id !== undefined) {
       // An orchestrator's task is held for the paired device that sent it,
@@ -105,6 +107,7 @@ export async function POST(request: NextRequest) {
         id,
         ...opts,
         held,
+        startedVia: "remote",
         startedByDevice: device ?? undefined,
       });
       return NextResponse.json({ session }, { status: 201 });

package/app/page.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { isFork } from "@/lib/sessions/fork";
 import { toast } from "sonner";
 
 import { subscribe } from "valtio";
@@ -299,7 +300,7 @@ function HomeContent() {
 
       // Get parent session ID for forking
       let parentSessionId: string | null = null;
-      if (!session.claude_session_id && session.parent_session_id) {
+      if (!session.claude_session_id && isFork(session)) {
         const parentSession = sessions.find(
           (s) => s.id === session.parent_session_id
         );

package/components/SessionList/SessionRow.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { isFork } from "@/lib/sessions/fork";
 import { memo, useState } from "react";
 import { useSnapshot } from "valtio";
 import {
@@ -99,7 +100,7 @@ export const SessionRow = memo(function SessionRow({
                 />
               </span>
             )}
-            {session.parent_session_id && (
+            {isFork(session) && (
               <GitFork className="text-muted-foreground/60 h-3 w-3 shrink-0" />
             )}
           </>

package/lib/agents/spawn.ts

@@ -1,4 +1,5 @@
 import { randomUUID } from "crypto";
+import { orchestratorOf, recordStart } from "../tasks/starter";
 import os from "os";
 import { db, queries, type Session } from "../db";
 import { getProject, getAllProjects } from "../projects";
@@ -35,6 +36,7 @@ export async function spawnSession(opts: {
   // The orchestrator session that starts it: the implementation role's
   // model unless `model` is given.
   startedBy?: string | null;
+  parentSessionId?: string | null;
 }): Promise<Session> {
   const prompt = opts.prompt.trim();
   if (!prompt) throw new Error("Give the new session a prompt");
@@ -46,7 +48,7 @@ export async function spawnSession(opts: {
 
   const id = randomUUID();
   const tmuxName = `claude-${id}`;
-  const routed = opts.startedBy
+  const routed = orchestratorOf(opts.startedBy)
     ? resolveRole("implement", {
         workspaceId: project.workspace_id,
         override: parseOverride(opts.model),
@@ -76,9 +78,19 @@ export async function spawnSession(opts: {
       project.id,
       "local"
     );
-  db.prepare(
-    `UPDATE sessions SET name_source = ?, started_by = ? WHERE id = ?`
-  ).run(naming.source, opts.startedBy ?? null, id);
+  db.prepare(`UPDATE sessions SET name_source = ? WHERE id = ?`).run(
+    naming.source,
+    id
+  );
+  recordStart(id, {
+    startedBy: opts.startedBy ?? null,
+    parentSessionId: opts.parentSessionId ?? opts.startedBy ?? null,
+    startedVia: orchestratorOf(opts.startedBy)
+      ? "orchestrator"
+      : opts.startedBy
+        ? "session"
+        : "person",
+  });
   if (routed) setSessionModel(id, routed);
   void naming.refine?.(id);
   await launchClaude({ sessionId: id, tmuxName, cwd, model, prompt });

package/lib/chat/refresh.ts

@@ -13,7 +13,8 @@
 
 import { db } from "../db";
 import { effectiveModels } from "../models/config";
-import { sessionRole, type ModelRole } from "../models/roles";
+import { type ModelRole } from "../models/roles";
+import { sessionRole } from "../models/session-role";
 import { MAX_REFRESH_TOKENS, MIN_REFRESH_TOKENS } from "./refresh-limits";
 
 export const ORCHESTRATOR_KEY = "orchestrator.refresh_tokens";

package/lib/chat/runner.ts

@@ -41,10 +41,13 @@ import {
   setChatPlan,
 } from "./settings";
 import {
+  endOrphanedTasks,
+  endRunningTasks,
   getItem,
   hasItem,
   itemsOfKind,
   recentTasks,
+  sessionsWithRunningTasks,
   saveItem,
   settle,
 } from "./store";
@@ -167,8 +170,26 @@ function planEnv(sessionId: string): PlanHandoffEnv {
   };
 }
 
+// Tell watchers of tasks that just ended, and drop them from the live count.
+function emitEnded(
+  sessionId: string,
+  live: Live | undefined,
+  ended: ReturnType<typeof endRunningTasks>
+): void {
+  for (const item of ended) {
+    live?.activity.tasks.delete(item.taskId);
+    emit(sessionId, { type: "item", item });
+  }
+}
+
 function onWorkerEvent(sessionId: string, live: Live, e: WorkerEvent): void {
   track(live, e);
+  if (
+    e.type === "item" &&
+    e.item.kind === "tool" &&
+    (e.item.status === "stopped" || e.item.status === "error")
+  )
+    emitEnded(sessionId, live, endOrphanedTasks(sessionId));
   if (e.type === "item" && e.item.kind === "task")
     retireIfStale(sessionId, live);
   if (e.type === "item") {
@@ -297,7 +318,11 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
             );
       },
     };
+    // No worker running: its agent ended, and with it every job it ran.
+    const hadWorker = runningWorkers().includes(sessionId);
     let { client, hello } = await connectWorker(sessionId, spawn, handlers);
+    if (!hadWorker) emitEnded(sessionId, undefined, endRunningTasks(sessionId));
+    emitEnded(sessionId, undefined, endOrphanedTasks(sessionId));
     let activity = restoreActivity(sessionId, hello.state);
     // An idle worker left over from before a redeploy: retire it, and start
     // a fresh one only when a message needs it. One still running background
@@ -316,6 +341,7 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
           { code: RETIRED }
         );
       ({ client, hello } = await connectWorker(sessionId, true, handlers));
+      emitEnded(sessionId, undefined, endRunningTasks(sessionId));
       activity = restoreActivity(sessionId, hello.state);
     }
     live = {
@@ -965,6 +991,9 @@ export async function reattachChats(): Promise<void> {
         })
     )
   );
+  // A task saved as running with no worker behind it has no job either.
+  for (const id of sessionsWithRunningTasks())
+    if (!live.has(id)) endRunningTasks(id);
   // Turns cut off while no worker was left to finish them, then queues.
   // One at a time, and only what was queued recently: a backlog from long
   // ago isn't sent unasked by a restart (it stays on screen to send).

package/lib/chat/store.ts

@@ -235,6 +235,59 @@ export function runningItems<K extends "tool" | "task">(
   ).map((r) => JSON.parse(r.data));
 }
 
+const LOST = "Its agent ended before this finished";
+
+function endTasks(
+  sessionId: string,
+  which: (task: Extract<ChatItem, { kind: "task" }>) => boolean
+): Extract<ChatItem, { kind: "task" }>[] {
+  const ended: Extract<ChatItem, { kind: "task" }>[] = [];
+  for (const task of runningItems(sessionId, "task")) {
+    if (!which(task)) continue;
+    const item = {
+      ...task,
+      status: "stopped" as const,
+      endedAt: Date.now(),
+      summary: task.summary ?? LOST,
+    };
+    saveItem(sessionId, item);
+    ended.push(item);
+  }
+  return ended;
+}
+
+// Its agent is gone (a fresh worker, no worker at restart): nothing it ran
+// in the background is still going. Returns what it ended.
+export const endRunningTasks = (sessionId: string) =>
+  endTasks(sessionId, () => true);
+
+// A task whose tool call was stopped or errored has no job behind it.
+export function endOrphanedTasks(sessionId: string) {
+  const dead = new Set(
+    runningItems(sessionId, "task").flatMap((t) => {
+      const tool = t.toolUseId ? getItem(sessionId, t.toolUseId) : undefined;
+      return tool?.kind === "tool" &&
+        (tool.status === "stopped" || tool.status === "error")
+        ? [t.id]
+        : [];
+    })
+  );
+  return endTasks(sessionId, (t) => dead.has(t.id));
+}
+
+// Chats with a task saved as running.
+export function sessionsWithRunningTasks(): string[] {
+  flushItems();
+  return (
+    db
+      .prepare(
+        `SELECT DISTINCT session_id FROM chat_items WHERE kind = 'task'
+         AND json_extract(data, '$.status') = 'running'`
+      )
+      .all() as { session_id: string }[]
+  ).map((r) => r.session_id);
+}
+
 // Tool calls saved as still running.
 export const runningTools = (sessionId: string) =>
   runningItems(sessionId, "tool");

package/lib/db/migration-types.ts

@@ -0,0 +1,15 @@
+import type Database from "better-sqlite3";
+
+export interface LegacyMigration {
+  id: number;
+  key?: undefined;
+  name: string;
+  up: (db: Database.Database) => void;
+}
+export interface KeyedMigration {
+  key: string;
+  id?: undefined;
+  name?: undefined;
+  up: (db: Database.Database) => void;
+}
+export type Migration = LegacyMigration | KeyedMigration;

package/lib/db/migrations/0001_add_group_path_to_sessions.ts

@@ -0,0 +1,11 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 1,
+  name: "add_group_path_to_sessions",
+  up: (db) => {
+    db.exec(
+      `ALTER TABLE sessions ADD COLUMN group_path TEXT NOT NULL DEFAULT 'sessions'`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0002_add_agent_type_to_sessions.ts

@@ -0,0 +1,11 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 2,
+  name: "add_agent_type_to_sessions",
+  up: (db) => {
+    db.exec(
+      `ALTER TABLE sessions ADD COLUMN agent_type TEXT NOT NULL DEFAULT 'claude'`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0003_add_worktree_columns_to_sessions.ts

@@ -0,0 +1,12 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 3,
+  name: "add_worktree_columns_to_sessions",
+  up: (db) => {
+    db.exec(`ALTER TABLE sessions ADD COLUMN worktree_path TEXT`);
+    db.exec(`ALTER TABLE sessions ADD COLUMN branch_name TEXT`);
+    db.exec(`ALTER TABLE sessions ADD COLUMN base_branch TEXT`);
+    db.exec(`ALTER TABLE sessions ADD COLUMN dev_server_port INTEGER`);
+  },
+} satisfies Migration;

package/lib/db/migrations/0004_add_pr_tracking_to_sessions.ts

@@ -0,0 +1,11 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 4,
+  name: "add_pr_tracking_to_sessions",
+  up: (db) => {
+    db.exec(`ALTER TABLE sessions ADD COLUMN pr_url TEXT`);
+    db.exec(`ALTER TABLE sessions ADD COLUMN pr_number INTEGER`);
+    db.exec(`ALTER TABLE sessions ADD COLUMN pr_status TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/0005_add_group_path_index.ts

@@ -0,0 +1,11 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 5,
+  name: "add_group_path_index",
+  up: (db) => {
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_sessions_group ON sessions(group_path)`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0006_add_orchestration_columns_to_sessions.ts

@@ -0,0 +1,16 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 6,
+  name: "add_orchestration_columns_to_sessions",
+  up: (db) => {
+    db.exec(
+      `ALTER TABLE sessions ADD COLUMN conductor_session_id TEXT REFERENCES sessions(id)`
+    );
+    db.exec(`ALTER TABLE sessions ADD COLUMN worker_task TEXT`);
+    db.exec(`ALTER TABLE sessions ADD COLUMN worker_status TEXT`);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_sessions_conductor ON sessions(conductor_session_id)`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0007_add_auto_approve_to_sessions.ts

@@ -0,0 +1,11 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 7,
+  name: "add_auto_approve_to_sessions",
+  up: (db) => {
+    db.exec(
+      `ALTER TABLE sessions ADD COLUMN auto_approve INTEGER NOT NULL DEFAULT 0`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0008_add_dev_server_columns.ts

@@ -0,0 +1,19 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 8,
+  name: "add_dev_server_columns",
+  up: (db) => {
+    db.exec(
+      `ALTER TABLE dev_servers ADD COLUMN type TEXT NOT NULL DEFAULT 'node'`
+    );
+    db.exec(`ALTER TABLE dev_servers ADD COLUMN name TEXT NOT NULL DEFAULT ''`);
+    db.exec(
+      `ALTER TABLE dev_servers ADD COLUMN command TEXT NOT NULL DEFAULT ''`
+    );
+    db.exec(`ALTER TABLE dev_servers ADD COLUMN pid INTEGER`);
+    db.exec(
+      `ALTER TABLE dev_servers ADD COLUMN working_directory TEXT NOT NULL DEFAULT ''`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0009_add_project_id_to_sessions.ts

@@ -0,0 +1,17 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 9,
+  name: "add_project_id_to_sessions",
+  up: (db) => {
+    db.exec(
+      `ALTER TABLE sessions ADD COLUMN project_id TEXT REFERENCES projects(id)`
+    );
+    db.exec(
+      `UPDATE sessions SET project_id = 'uncategorized' WHERE project_id IS NULL`
+    );
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id)`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0010_add_project_id_to_dev_servers.ts

@@ -0,0 +1,36 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 10,
+  name: "add_project_id_to_dev_servers",
+  up: (db) => {
+    // Check if column exists first
+    const cols = db.prepare(`PRAGMA table_info(dev_servers)`).all() as {
+      name: string;
+    }[];
+    if (cols.some((c) => c.name === "project_id")) return;
+
+    db.exec(
+      `ALTER TABLE dev_servers ADD COLUMN project_id TEXT REFERENCES projects(id)`
+    );
+    // Migrate from session_id if it exists
+    const hasSessionId = cols.some((c) => c.name === "session_id");
+    if (hasSessionId) {
+      db.exec(`
+          UPDATE dev_servers
+          SET project_id = (
+            SELECT COALESCE(s.project_id, 'uncategorized')
+            FROM sessions s
+            WHERE s.id = dev_servers.session_id
+          )
+          WHERE project_id IS NULL
+        `);
+    }
+    db.exec(
+      `UPDATE dev_servers SET project_id = 'uncategorized' WHERE project_id IS NULL`
+    );
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_dev_servers_project ON dev_servers(project_id)`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0011_add_tmux_name_to_sessions.ts

@@ -0,0 +1,13 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 11,
+  name: "add_tmux_name_to_sessions",
+  up: (db) => {
+    db.exec(`ALTER TABLE sessions ADD COLUMN tmux_name TEXT`);
+    // Backfill existing sessions with computed tmux name
+    db.exec(
+      `UPDATE sessions SET tmux_name = agent_type || '-' || id WHERE tmux_name IS NULL`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0012_add_initial_prompt_to_projects.ts

@@ -0,0 +1,9 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 12,
+  name: "add_initial_prompt_to_projects",
+  up: (db) => {
+    db.exec(`ALTER TABLE projects ADD COLUMN initial_prompt TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/0013_add_project_repositories_table.ts

@@ -0,0 +1,22 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 13,
+  name: "add_project_repositories_table",
+  up: (db) => {
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS project_repositories (
+          id TEXT PRIMARY KEY,
+          project_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          path TEXT NOT NULL,
+          is_primary INTEGER NOT NULL DEFAULT 0,
+          sort_order INTEGER NOT NULL DEFAULT 0,
+          FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+        )
+      `);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_project_repositories_project ON project_repositories(project_id)`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0014_add_hosts.ts

@@ -0,0 +1,23 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 14,
+  name: "add_hosts",
+  up: (db) => {
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS hosts (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          ssh_target TEXT NOT NULL,
+          sort_order INTEGER NOT NULL DEFAULT 0,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )
+      `);
+    db.exec(
+      `ALTER TABLE projects ADD COLUMN host_id TEXT NOT NULL DEFAULT 'local'`
+    );
+    db.exec(
+      `ALTER TABLE sessions ADD COLUMN host_id TEXT NOT NULL DEFAULT 'local'`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0015_add_workspaces.ts

@@ -0,0 +1,18 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 15,
+  name: "add_workspaces",
+  up: (db) => {
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS workspaces (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          sort_order INTEGER NOT NULL DEFAULT 0,
+          collapsed INTEGER NOT NULL DEFAULT 0,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )
+      `);
+    db.exec(`ALTER TABLE projects ADD COLUMN workspace_id TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/0016_add_task_columns_to_sessions.ts

@@ -0,0 +1,13 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 16,
+  name: "add_task_columns_to_sessions",
+  up: (db) => {
+    db.exec(`ALTER TABLE sessions ADD COLUMN task_prompt TEXT`);
+    db.exec(`ALTER TABLE sessions ADD COLUMN task_status TEXT`);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_sessions_task_status ON sessions(task_status)`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0017_add_bus_messages.ts

@@ -0,0 +1,24 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 17,
+  name: "add_bus_messages",
+  up: (db) => {
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS bus_messages (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          from_id TEXT,
+          from_name TEXT NOT NULL,
+          to_id TEXT NOT NULL,
+          to_name TEXT NOT NULL,
+          body TEXT NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          delivered_at TEXT,
+          read_at TEXT
+        )
+      `);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_bus_to ON bus_messages(to_id, read_at)`
+    );
+  },
+} satisfies Migration;