@openparachute/agent 0.1.2 → 0.2.2

package/src/db/schema.ts

@@ -1,258 +0,0 @@
-/**
- * Reference copy of the current v2 schema.
- * Read this to understand the DB structure.
- * Actual creation is done by migrations — do not use this at runtime.
- */
-
-export const SCHEMA = `
--- Agent workspaces: folder, skills, CLAUDE.md.
--- All workspaces are equal; privilege lives on users, not groups.
--- Container config (mcpServers, packages, imageTag, additionalMounts) lives
--- in groups/<folder>/container.json on disk, not in the DB.
-CREATE TABLE agent_groups (
-  id               TEXT PRIMARY KEY,
-  name             TEXT NOT NULL,
-  folder           TEXT NOT NULL UNIQUE,
-  agent_provider   TEXT,
-  created_at       TEXT NOT NULL
-);
-
--- Platform groups/channels. unknown_sender_policy governs what happens
--- when a sender we've never seen before posts in this chat.
--- The column DEFAULT is "strict" (inherited from migration 001), but it
--- only matters if something inserts without specifying the field, which no
--- current callsite does. Router auto-create hardcodes "request_approval"
--- (see src/router.ts:151); setup scripts pick per context.
-CREATE TABLE messaging_groups (
-  id                    TEXT PRIMARY KEY,
-  channel_type          TEXT NOT NULL,
-  platform_id           TEXT NOT NULL,
-  name                  TEXT,
-  is_group              INTEGER DEFAULT 0,
-  unknown_sender_policy TEXT NOT NULL DEFAULT 'strict',
-                        -- 'strict' | 'request_approval' | 'public'
-  created_at            TEXT NOT NULL,
-  UNIQUE(channel_type, platform_id)
-);
-
--- Which agent groups handle which messaging groups.
--- engage_mode / engage_pattern / sender_scope / ignored_message_policy are
--- the four orthogonal axes that together replace v1's opaque trigger_rules
--- JSON + response_scope enum. See docs/v1-vs-v2/ACTION-ITEMS.md item 1.
-CREATE TABLE messaging_group_agents (
-  id                     TEXT PRIMARY KEY,
-  messaging_group_id     TEXT NOT NULL REFERENCES messaging_groups(id),
-  agent_group_id         TEXT NOT NULL REFERENCES agent_groups(id),
-  engage_mode            TEXT NOT NULL DEFAULT 'mention',
-                         -- 'pattern' | 'mention' | 'mention-sticky'
-  engage_pattern         TEXT,   -- regex; required when engage_mode='pattern';
-                                 -- '.' means "match every message" (the "always" flavor)
-  sender_scope           TEXT NOT NULL DEFAULT 'all',    -- 'all' | 'known'
-  ignored_message_policy TEXT NOT NULL DEFAULT 'drop',   -- 'drop' | 'accumulate'
-  session_mode           TEXT DEFAULT 'shared',
-  priority               INTEGER DEFAULT 0,
-  created_at             TEXT NOT NULL,
-  UNIQUE(messaging_group_id, agent_group_id)
-);
-
--- Users are messaging-platform identifiers, namespaced: "phone:+1555...",
--- "tg:123", "discord:456", "email:a@x.com". A single human can own multiple
--- user rows if they have identifiers on unrelated channels (no linking yet).
-CREATE TABLE users (
-  id           TEXT PRIMARY KEY,
-  kind         TEXT NOT NULL,
-  display_name TEXT,
-  created_at   TEXT NOT NULL
-);
-
--- Role grants on users. Privilege is user-level, not group-level.
---   role ∈ {owner, admin}
---   owner: always global (agent_group_id IS NULL)
---   admin: agent_group_id NULL = global, else scoped to that agent group
--- Invariant: admin @ A implies membership in A (no row needed).
-CREATE TABLE user_roles (
-  user_id        TEXT NOT NULL REFERENCES users(id),
-  role           TEXT NOT NULL,
-  agent_group_id TEXT REFERENCES agent_groups(id),
-  granted_by     TEXT REFERENCES users(id),
-  granted_at     TEXT NOT NULL,
-  PRIMARY KEY (user_id, role, agent_group_id)
-);
-CREATE INDEX idx_user_roles_scope ON user_roles(agent_group_id, role);
-
--- "Known" membership in an agent group. Required for an unprivileged user
--- to interact with a workspace. Admin @ A is implicitly a member of A.
-CREATE TABLE agent_group_members (
-  user_id        TEXT NOT NULL REFERENCES users(id),
-  agent_group_id TEXT NOT NULL REFERENCES agent_groups(id),
-  added_by       TEXT REFERENCES users(id),
-  added_at       TEXT NOT NULL,
-  PRIMARY KEY (user_id, agent_group_id)
-);
-
--- Cached mapping from (user, channel) to the DM messaging group. Lets the
--- host initiate cold DMs (pairing, approvals) without reprobing the
--- platform API on every send. Populated lazily by ensureUserDm().
-CREATE TABLE user_dms (
-  user_id            TEXT NOT NULL REFERENCES users(id),
-  channel_type       TEXT NOT NULL,
-  messaging_group_id TEXT NOT NULL REFERENCES messaging_groups(id),
-  resolved_at        TEXT NOT NULL,
-  PRIMARY KEY (user_id, channel_type)
-);
-
--- Sessions: one folder = one session = one container when running
-CREATE TABLE sessions (
-  id                 TEXT PRIMARY KEY,
-  agent_group_id     TEXT NOT NULL REFERENCES agent_groups(id),
-  messaging_group_id TEXT REFERENCES messaging_groups(id),
-  thread_id          TEXT,
-  agent_provider     TEXT,
-  status             TEXT DEFAULT 'active',
-  container_status   TEXT DEFAULT 'stopped',
-  last_active        TEXT,
-  created_at         TEXT NOT NULL
-);
-CREATE INDEX idx_sessions_agent_group ON sessions(agent_group_id);
-CREATE INDEX idx_sessions_lookup ON sessions(messaging_group_id, thread_id);
-
--- Pending interactive questions
-CREATE TABLE pending_questions (
-  question_id    TEXT PRIMARY KEY,
-  session_id     TEXT NOT NULL REFERENCES sessions(id),
-  message_out_id TEXT NOT NULL,
-  platform_id    TEXT,
-  channel_type   TEXT,
-  thread_id      TEXT,
-  title          TEXT NOT NULL,
-  options_json   TEXT NOT NULL,
-  created_at     TEXT NOT NULL
-);
-
--- Pending approvals for unknown senders (unknown_sender_policy='request_approval').
--- In-flight dedup via UNIQUE(messaging_group_id, sender_identity): a second
--- message from the same unknown sender while a card is pending is silently
--- dropped instead of spamming the admin.
-CREATE TABLE pending_sender_approvals (
-  id                 TEXT PRIMARY KEY,
-  messaging_group_id TEXT NOT NULL REFERENCES messaging_groups(id),
-  agent_group_id     TEXT NOT NULL REFERENCES agent_groups(id),
-  sender_identity    TEXT NOT NULL,    -- namespaced user id (channel_type:handle)
-  sender_name        TEXT,
-  original_message   TEXT NOT NULL,    -- JSON of the original InboundEvent
-  approver_user_id   TEXT NOT NULL,
-  created_at         TEXT NOT NULL,
-  UNIQUE(messaging_group_id, sender_identity)
-);
-`;
-
-/**
- * Session DB schemas — split into two files so each has exactly one writer.
- * This eliminates SQLite write contention across the host-container mount boundary.
- *
- *   inbound.db  — host writes, container reads (read-only mount or open read-only)
- *   outbound.db — container writes, host reads (read-only open)
- */
-
-/** Host-owned: inbound messages + delivery tracking + destination map. */
-export const INBOUND_SCHEMA = `
-CREATE TABLE IF NOT EXISTS messages_in (
-  id             TEXT PRIMARY KEY,
-  seq            INTEGER UNIQUE,
-  kind           TEXT NOT NULL,
-  timestamp      TEXT NOT NULL,
-  status         TEXT DEFAULT 'pending',
-  process_after  TEXT,
-  recurrence     TEXT,
-  series_id      TEXT,
-  tries          INTEGER DEFAULT 0,
-  trigger        INTEGER NOT NULL DEFAULT 1,
-                 -- 0 = accumulated context (don't wake), 1 = wake agent
-  platform_id    TEXT,
-  channel_type   TEXT,
-  thread_id      TEXT,
-  content        TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_messages_in_series ON messages_in(series_id);
-
--- Host tracks delivery outcomes for messages_out IDs.
--- Avoids writing to outbound.db (container-owned).
-CREATE TABLE IF NOT EXISTS delivered (
-  message_out_id      TEXT PRIMARY KEY,
-  platform_message_id TEXT,
-  status              TEXT NOT NULL DEFAULT 'delivered',
-  delivered_at        TEXT NOT NULL
-);
-
--- Destination map for this session's agent.
--- Host overwrites on every container wake AND on demand (rewires, new child
--- agents, etc.). Container queries this live on every lookup, so changes
--- take effect mid-session without requiring a container restart.
-CREATE TABLE IF NOT EXISTS destinations (
-  name            TEXT PRIMARY KEY,
-  display_name    TEXT,
-  type            TEXT NOT NULL,   -- 'channel' | 'agent'
-  channel_type    TEXT,            -- for type='channel'
-  platform_id     TEXT,            -- for type='channel'
-  agent_group_id  TEXT             -- for type='agent'
-);
-
--- Default reply routing for this session. Single-row table (id=1).
--- Host overwrites on every container wake from the session's messaging_group
--- and thread_id. Container reads it in send_message / ask_user_question to
--- default the channel/thread of outbound messages when the agent doesn't
--- specify an explicit destination.
-CREATE TABLE IF NOT EXISTS session_routing (
-  id           INTEGER PRIMARY KEY CHECK (id = 1),
-  channel_type TEXT,
-  platform_id  TEXT,
-  thread_id    TEXT
-);
-`;
-
-/** Container-owned: outbound messages + processing acknowledgments. */
-export const OUTBOUND_SCHEMA = `
-CREATE TABLE IF NOT EXISTS messages_out (
-  id             TEXT PRIMARY KEY,
-  seq            INTEGER UNIQUE,
-  in_reply_to    TEXT,
-  timestamp      TEXT NOT NULL,
-  deliver_after  TEXT,
-  recurrence     TEXT,
-  kind           TEXT NOT NULL,
-  platform_id    TEXT,
-  channel_type   TEXT,
-  thread_id      TEXT,
-  content        TEXT NOT NULL
-);
-
--- Container tracks processing status here instead of updating messages_in.
--- Host reads this to know which messages have been processed.
--- On container startup, stale 'processing' entries are cleared (crash recovery).
-CREATE TABLE IF NOT EXISTS processing_ack (
-  message_id     TEXT PRIMARY KEY,
-  status         TEXT NOT NULL,
-  status_changed TEXT NOT NULL
-);
-
--- Persistent key/value state owned by the container. Used (among other things)
--- to store the SDK session ID so the agent's conversation resumes across
--- container restarts. Cleared by /clear.
-CREATE TABLE IF NOT EXISTS session_state (
-  key        TEXT PRIMARY KEY,
-  value      TEXT NOT NULL,
-  updated_at TEXT NOT NULL
-);
-
--- Current tool-in-flight state. Single-row table (id=1). Container writes on
--- PreToolUse and clears on PostToolUse / PostToolUseFailure. Host reads in the
--- sweep to extend the stuck-tolerance window when Bash is running with a
--- declared timeout > 60s (long-running scripts shouldn't be flagged as stuck).
-CREATE TABLE IF NOT EXISTS container_state (
-  id                       INTEGER PRIMARY KEY CHECK (id = 1),
-  current_tool             TEXT,
-  tool_declared_timeout_ms INTEGER,
-  tool_started_at          TEXT,
-  updated_at               TEXT NOT NULL
-);
-`;

package/src/db/session-db.test.ts

@@ -1,93 +0,0 @@
-/**
- * Tests for core per-session messages_in schema maintenance.
- *
- * Task-specific DB tests (insertTask, cancel/pause/resume, updateTask,
- * insertRecurrence) live in `src/modules/scheduling/db.test.ts` with the
- * rest of the scheduling module.
- */
-import { openDb } from './connection.js';
-import fs from 'fs';
-import path from 'path';
-import { describe, it, expect, afterEach } from 'vitest';
-
-import { ensureSchema, insertMessage, migrateMessagesInTable } from './session-db.js';
-
-const TEST_DIR = '/tmp/paraclaw-session-db-test';
-const DB_PATH = path.join(TEST_DIR, 'inbound.db');
-
-afterEach(() => {
-  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-});
-
-describe('migrateMessagesInTable', () => {
-  it('backfills series_id = id on legacy rows and is idempotent', () => {
-    if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-    fs.mkdirSync(TEST_DIR, { recursive: true });
-
-    // Build a legacy inbound.db WITHOUT series_id to simulate a pre-fix install.
-    const db = openDb(DB_PATH);
-    db.exec(`
-      CREATE TABLE messages_in (
-        id             TEXT PRIMARY KEY,
-        seq            INTEGER UNIQUE,
-        kind           TEXT NOT NULL,
-        timestamp      TEXT NOT NULL,
-        status         TEXT DEFAULT 'pending',
-        process_after  TEXT,
-        recurrence     TEXT,
-        tries          INTEGER DEFAULT 0,
-        platform_id    TEXT,
-        channel_type   TEXT,
-        thread_id      TEXT,
-        content        TEXT NOT NULL
-      );
-    `);
-    db.prepare(
-      "INSERT INTO messages_in (id, seq, kind, timestamp, status, content) VALUES (?, ?, 'task', datetime('now'), 'pending', '{}')",
-    ).run('legacy-1', 2);
-
-    migrateMessagesInTable(db);
-    migrateMessagesInTable(db); // idempotent
-
-    const row = db.prepare('SELECT series_id FROM messages_in WHERE id = ?').get('legacy-1') as {
-      series_id: string;
-    };
-    expect(row.series_id).toBe('legacy-1');
-    db.close();
-  });
-});
-
-describe('insertMessage', () => {
-  it('returns inserted=true on first write, inserted=false on duplicate id (paraclaw#92)', () => {
-    if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-    fs.mkdirSync(TEST_DIR, { recursive: true });
-
-    ensureSchema(DB_PATH, 'inbound');
-    const db = openDb(DB_PATH);
-
-    const args = {
-      id: 'msg-dup-1:ag-1',
-      kind: 'chat' as const,
-      timestamp: new Date().toISOString(),
-      platformId: 'telegram:bot:chat',
-      channelType: 'telegram',
-      threadId: null,
-      content: '{"text":"hi"}',
-      processAfter: null,
-      recurrence: null,
-    };
-
-    const first = insertMessage(db, args);
-    expect(first.inserted).toBe(true);
-
-    // Duplicate dispatch — same id arrives again (sender-approval replay
-    // racing with re-emitted chat-sdk event, or platform getUpdates retry).
-    const second = insertMessage(db, args);
-    expect(second.inserted).toBe(false);
-
-    const count = (db.prepare('SELECT COUNT(*) AS n FROM messages_in WHERE id = ?').get(args.id) as { n: number }).n;
-    expect(count).toBe(1);
-
-    db.close();
-  });
-});

package/src/db/session-db.ts

@@ -1,325 +0,0 @@
-/**
- * SQL operations on per-session inbound/outbound DBs.
- *
- * These are NOT the central app DB — they're the cross-mount SQLite files
- * shared between host and container. Callers own the connection lifecycle
- * (open-write-close per op). See session-manager.ts header for invariants.
- */
-import { type Database, openDb } from './connection.js';
-import { INBOUND_SCHEMA, OUTBOUND_SCHEMA } from './schema.js';
-
-/** Apply the inbound or outbound schema to a DB file. Idempotent. */
-export function ensureSchema(dbPath: string, schema: 'inbound' | 'outbound'): void {
-  const db = openDb(dbPath);
-  db.pragma('journal_mode = DELETE');
-  db.exec(schema === 'inbound' ? INBOUND_SCHEMA : OUTBOUND_SCHEMA);
-  db.close();
-}
-
-/** Open the inbound DB for a session (host reads/writes). */
-export function openInboundDb(dbPath: string): Database {
-  const db = openDb(dbPath);
-  db.pragma('journal_mode = DELETE');
-  db.pragma('busy_timeout = 5000');
-  return db;
-}
-
-/** Open the outbound DB for a session (host reads only). */
-export function openOutboundDb(dbPath: string): Database {
-  const db = openDb(dbPath, { readonly: true });
-  db.pragma('busy_timeout = 5000');
-  return db;
-}
-
-export function upsertSessionRouting(
-  db: Database,
-  routing: { channel_type: string | null; platform_id: string | null; thread_id: string | null },
-): void {
-  db.prepare(
-    `INSERT INTO session_routing (id, channel_type, platform_id, thread_id)
-     VALUES (1, @channel_type, @platform_id, @thread_id)
-     ON CONFLICT(id) DO UPDATE SET
-       channel_type = excluded.channel_type,
-       platform_id  = excluded.platform_id,
-       thread_id    = excluded.thread_id`,
-  ).run(routing);
-}
-
-export interface DestinationRow {
-  name: string;
-  display_name: string | null;
-  type: 'channel' | 'agent';
-  channel_type: string | null;
-  platform_id: string | null;
-  agent_group_id: string | null;
-}
-
-export function replaceDestinations(db: Database, entries: DestinationRow[]): void {
-  const tx = db.transaction((rows: DestinationRow[]) => {
-    db.prepare('DELETE FROM destinations').run();
-    const stmt = db.prepare(
-      `INSERT INTO destinations (name, display_name, type, channel_type, platform_id, agent_group_id)
-       VALUES (@name, @display_name, @type, @channel_type, @platform_id, @agent_group_id)`,
-    );
-    for (const row of rows) stmt.run(row);
-  });
-  tx(entries);
-}
-
-// ---------------------------------------------------------------------------
-// messages_in
-// ---------------------------------------------------------------------------
-
-/**
- * Next even seq number for host-owned inbound.db.
- *
- * Exported so the scheduling module's task helpers can maintain the
- * host-writes-even-seq invariant without duplicating the logic. Not part of
- * the general public API — imported by `src/modules/scheduling/db.ts` only.
- */
-export function nextEvenSeq(db: Database): number {
-  const maxSeq = (db.prepare('SELECT COALESCE(MAX(seq), 0) AS m FROM messages_in').get() as { m: number }).m;
-  return maxSeq < 2 ? 2 : maxSeq + 2 - (maxSeq % 2);
-}
-
-export function insertMessage(
-  db: Database,
-  message: {
-    id: string;
-    kind: string;
-    timestamp: string;
-    platformId: string | null;
-    channelType: string | null;
-    threadId: string | null;
-    content: string;
-    processAfter: string | null;
-    recurrence: string | null;
-    /**
-     * 1 = wake the agent (default); 0 = accumulate as context only.
-     * Host countDueMessages gates on this; container reads everything.
-     */
-    trigger?: 0 | 1;
-  },
-): { inserted: boolean } {
-  // ON CONFLICT(id) DO NOTHING: the same `event.message.id` can legitimately
-  // arrive twice for one (session, agent) pair — sender-approval replay
-  // racing with a re-dispatched chat-sdk event, or a Telegram getUpdates
-  // retry. The id is canonical, so a duplicate is the SAME message; treat
-  // it as idempotent rather than crashing the inbound path. Targeted to
-  // (id) so an unrelated UNIQUE(seq) collision still surfaces.
-  const info = db
-    .prepare(
-      `INSERT INTO messages_in (id, seq, kind, timestamp, status, platform_id, channel_type, thread_id, content, process_after, recurrence, series_id, trigger)
-       VALUES (@id, @seq, @kind, @timestamp, 'pending', @platformId, @channelType, @threadId, @content, @processAfter, @recurrence, @id, @trigger)
-       ON CONFLICT(id) DO NOTHING`,
-    )
-    .run({
-      ...message,
-      trigger: message.trigger ?? 1,
-      seq: nextEvenSeq(db),
-    });
-  return { inserted: info.changes > 0 };
-}
-
-export function countDueMessages(db: Database): number {
-  return (
-    db
-      .prepare(
-        `SELECT COUNT(*) as count FROM messages_in
-       WHERE status = 'pending'
-         AND trigger = 1
-         AND (process_after IS NULL OR datetime(process_after) <= datetime('now'))`,
-      )
-      .get() as { count: number }
-  ).count;
-}
-
-export function markMessageFailed(db: Database, messageId: string): void {
-  db.prepare("UPDATE messages_in SET status = 'failed' WHERE id = ?").run(messageId);
-}
-
-export function retryWithBackoff(db: Database, messageId: string, backoffSec: number): void {
-  db.prepare(
-    `UPDATE messages_in SET tries = tries + 1, process_after = datetime('now', '+${backoffSec} seconds') WHERE id = ?`,
-  ).run(messageId);
-}
-
-export function getMessageForRetry(
-  db: Database,
-  messageId: string,
-  status: string,
-): { id: string; tries: number; processAfter: string | null } | undefined {
-  return db
-    .prepare('SELECT id, tries, process_after as processAfter FROM messages_in WHERE id = ? AND status = ?')
-    .get(messageId, status) as { id: string; tries: number; processAfter: string | null } | undefined;
-}
-
-export function syncProcessingAcks(inDb: Database, outDb: Database): void {
-  const completed = outDb
-    .prepare("SELECT message_id FROM processing_ack WHERE status IN ('completed', 'failed')")
-    .all() as Array<{ message_id: string }>;
-
-  if (completed.length === 0) return;
-
-  const updateStmt = inDb.prepare("UPDATE messages_in SET status = 'completed' WHERE id = ? AND status != 'completed'");
-  inDb.transaction(() => {
-    for (const { message_id } of completed) {
-      updateStmt.run(message_id);
-    }
-  })();
-}
-
-export function getStuckProcessingIds(outDb: Database): string[] {
-  return (
-    outDb.prepare("SELECT message_id FROM processing_ack WHERE status = 'processing'").all() as Array<{
-      message_id: string;
-    }>
-  ).map((r) => r.message_id);
-}
-
-export interface ProcessingClaim {
-  message_id: string;
-  status_changed: string;
-}
-
-/** Return processing_ack rows still in 'processing' with their claim timestamps. */
-export function getProcessingClaims(outDb: Database): ProcessingClaim[] {
-  return outDb
-    .prepare("SELECT message_id, status_changed FROM processing_ack WHERE status = 'processing'")
-    .all() as ProcessingClaim[];
-}
-
-export interface ContainerState {
-  current_tool: string | null;
-  tool_declared_timeout_ms: number | null;
-  tool_started_at: string | null;
-}
-
-/**
- * Read the container's current tool-in-flight state, if any. Returns null
- * when either the table doesn't exist yet (older session DB) or no tool is
- * active. Host sweep reads this to widen stuck-detection tolerance while
- * Bash is running with a long declared timeout.
- */
-export function getContainerState(outDb: Database): ContainerState | null {
-  try {
-    const row = outDb
-      .prepare(
-        `SELECT current_tool, tool_declared_timeout_ms, tool_started_at
-           FROM container_state WHERE id = 1`,
-      )
-      .get() as ContainerState | undefined;
-    return row ?? null;
-  } catch {
-    // Table not present on older session DBs — treat as "no tool in flight".
-    return null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// messages_out (read-only from host)
-// ---------------------------------------------------------------------------
-
-export interface OutboundMessage {
-  id: string;
-  kind: string;
-  platform_id: string | null;
-  channel_type: string | null;
-  thread_id: string | null;
-  content: string;
-}
-
-export function getDueOutboundMessages(db: Database): OutboundMessage[] {
-  return db
-    .prepare(
-      `SELECT * FROM messages_out
-       WHERE (deliver_after IS NULL OR deliver_after <= datetime('now'))
-       ORDER BY timestamp ASC`,
-    )
-    .all() as OutboundMessage[];
-}
-
-// ---------------------------------------------------------------------------
-// delivered
-// ---------------------------------------------------------------------------
-
-export function getDeliveredIds(db: Database): Set<string> {
-  return new Set(
-    (db.prepare('SELECT message_out_id FROM delivered').all() as Array<{ message_out_id: string }>).map(
-      (r) => r.message_out_id,
-    ),
-  );
-}
-
-export function markDelivered(db: Database, messageOutId: string, platformMessageId: string | null): void {
-  db.prepare(
-    "INSERT OR IGNORE INTO delivered (message_out_id, platform_message_id, status, delivered_at) VALUES (?, ?, 'delivered', datetime('now'))",
-  ).run(messageOutId, platformMessageId ?? null);
-}
-
-export function markDeliveryFailed(db: Database, messageOutId: string): void {
-  db.prepare(
-    "INSERT OR IGNORE INTO delivered (message_out_id, platform_message_id, status, delivered_at) VALUES (?, NULL, 'failed', datetime('now'))",
-  ).run(messageOutId);
-}
-
-/** Ensure the delivered table has columns added after initial schema. */
-export function migrateDeliveredTable(db: Database): void {
-  const cols = new Set(
-    (db.prepare("PRAGMA table_info('delivered')").all() as Array<{ name: string }>).map((c) => c.name),
-  );
-  if (!cols.has('platform_message_id')) {
-    db.prepare('ALTER TABLE delivered ADD COLUMN platform_message_id TEXT').run();
-  }
-  if (!cols.has('status')) {
-    db.prepare("ALTER TABLE delivered ADD COLUMN status TEXT NOT NULL DEFAULT 'delivered'").run();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// activity (read-only from host)
-// ---------------------------------------------------------------------------
-
-export interface OutboundActivityRow {
-  seq: number;
-  ts: string;
-  kind: string;
-  target: string | null;
-  summary: string | null;
-}
-
-/**
- * Read activity rows the host hasn't yet merged. Returns rows ordered by
- * seq ascending so the merge runs in chronological order and the cursor
- * advances monotonically. Returns [] (without throwing) if the outbound
- * DB pre-dates the activity table — old session DBs simply won't emit
- * activity until the next container reboot creates the table on demand.
- */
-export function getOutboundActivity(db: Database, sinceSeq: number): OutboundActivityRow[] {
-  try {
-    return db
-      .prepare(`SELECT seq, ts, kind, target, summary FROM activity WHERE seq > ? ORDER BY seq ASC`)
-      .all(sinceSeq) as OutboundActivityRow[];
-  } catch {
-    return [];
-  }
-}
-
-// Adds columns added to messages_in after the initial v2 schema to
-// pre-existing session DBs. No-op on fresh installs where the columns are
-// in the baseline schema. Backfills existing rows so invariants hold.
-export function migrateMessagesInTable(db: Database): void {
-  const cols = new Set(
-    (db.prepare("PRAGMA table_info('messages_in')").all() as Array<{ name: string }>).map((c) => c.name),
-  );
-  if (!cols.has('series_id')) {
-    db.prepare('ALTER TABLE messages_in ADD COLUMN series_id TEXT').run();
-    db.prepare('UPDATE messages_in SET series_id = id WHERE series_id IS NULL').run();
-    db.prepare('CREATE INDEX IF NOT EXISTS idx_messages_in_series ON messages_in(series_id)').run();
-  }
-  if (!cols.has('trigger')) {
-    // All pre-existing rows got written with the old "every inbound wakes
-    // the agent" semantics, so backfill 1 and default 1 for new inserts.
-    db.prepare('ALTER TABLE messages_in ADD COLUMN trigger INTEGER NOT NULL DEFAULT 1').run();
-  }
-}