@saadnvd1/agent-os 0.3.595 → 0.3.597

package/lib/db/migrations/0051_chat_queue_sent_by.ts

@@ -0,0 +1,16 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  // 50 is taken by queued tasks, landing separately.
+  id: 51,
+  name: "chat_queue_sent_by",
+  up: (db) => {
+    // Who sent a queued message the reader didn't type (lib/chat/events
+    // SentBy, as JSON), so it still shows as theirs once it's sent.
+    const columns = db.prepare(`PRAGMA table_info(chat_queue)`).all() as {
+      name: string;
+    }[];
+    if (!columns.some((c) => c.name === "sent_by"))
+      db.exec(`ALTER TABLE chat_queue ADD COLUMN sent_by TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/0052_sessions_chat_restarted.ts

@@ -0,0 +1,17 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 52,
+  name: "sessions_chat_restarted",
+  up: (db) => {
+    // Set by a chat worker that retired cleanly after a deploy; the next
+    // worker tells the agent so with its first message, then clears it.
+    const columns = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+      name: string;
+    }[];
+    if (!columns.some((c) => c.name === "chat_restarted"))
+      db.exec(
+        `ALTER TABLE sessions ADD COLUMN chat_restarted INTEGER NOT NULL DEFAULT 0`
+      );
+  },
+} satisfies Migration;

package/lib/db/migrations/0053_brief_amendments_failure_sha_ask_raised_by.ts

@@ -0,0 +1,37 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 53,
+  name: "brief_amendments_failure_sha_ask_raised_by",
+  up: (db) => {
+    // Scope changes the orchestrator records on a task after it started
+    // (send with scope_change); its review judges against them.
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS brief_amendments (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          workspace_id TEXT NOT NULL,
+          text TEXT NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_brief_amendments_session
+          ON brief_amendments(session_id);
+      `);
+    // The commit a stored verdict's failure was counted for, so reading
+    // the same verdict again isn't a second failure.
+    const columns = db
+      .prepare(`PRAGMA table_info(orchestrator_gate_failures)`)
+      .all() as { name: string }[];
+    if (!columns.some((c) => c.name === "last_sha"))
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failures ADD COLUMN last_sha TEXT`
+      );
+    // Who raised a merge ask: the orchestrator may refresh its own, never
+    // one the gates raised.
+    const asks = db.prepare(`PRAGMA table_info(orchestrator_asks)`).all() as {
+      name: string;
+    }[];
+    if (!asks.some((c) => c.name === "raised_by"))
+      db.exec(`ALTER TABLE orchestrator_asks ADD COLUMN raised_by TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/0054_sessions_chat_tools_digest.ts

@@ -0,0 +1,15 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 54,
+  name: "sessions_chat_tools_digest",
+  up: (db) => {
+    // The tools a chat worker last gave the agent (an orchestrator's), so
+    // the next one says they changed only when they did.
+    const columns = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+      name: string;
+    }[];
+    if (!columns.some((c) => c.name === "chat_tools_digest"))
+      db.exec(`ALTER TABLE sessions ADD COLUMN chat_tools_digest TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/0055_sessions_merge_armed_and_rebase.ts

@@ -0,0 +1,25 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 55,
+  name: "sessions_merge_armed_and_rebase",
+  up: (db) => {
+    // merge_armed_at: AgentOS merges the task's PR once every gate
+    // passes (orchestrator/armed.ts); merge_armed_seen: the failure it
+    // last reported. rebased_from/to: the heads an automatic rebase onto
+    // the base moved the branch between, for the code-review gate.
+    // rebase_asked_head: the head the task was last asked to rebase.
+    const columns = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+      name: string;
+    }[];
+    for (const name of [
+      "merge_armed_at",
+      "merge_armed_seen",
+      "rebased_from",
+      "rebased_to",
+      "rebase_asked_head",
+    ])
+      if (!columns.some((c) => c.name === name))
+        db.exec(`ALTER TABLE sessions ADD COLUMN ${name} TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/0056_orchestrator_rules.ts

@@ -0,0 +1,39 @@
+import type { Migration } from "../migration-types";
+import { installChangeTriggers, TABLES_WATCHED_56 } from "../changes";
+
+export default {
+  id: 56,
+  name: "orchestrator_rules",
+  up: (db) => {
+    // Standing rules an orchestrator keeps across fresh starts
+    // (lib/orchestrator/rules.ts): written by it or by Saad, never
+    // deleted, only marked removed.
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS orchestrator_rules (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          workspace_id TEXT NOT NULL,
+          text TEXT NOT NULL,
+          added_by TEXT NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+          removed_at TEXT,
+          removed_by TEXT
+        )
+      `);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_orchestrator_rules
+         ON orchestrator_rules(workspace_id, removed_at, id)`
+    );
+    // Its last worker ended the conversation at the context threshold:
+    // the tokens it had reached (0 otherwise). The next one starts a new
+    // one and tells the agent so.
+    const columns = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+      name: string;
+    }[];
+    if (!columns.some((c) => c.name === "chat_refreshed"))
+      db.exec(
+        `ALTER TABLE sessions ADD COLUMN chat_refreshed INTEGER NOT NULL DEFAULT 0`
+      );
+    installChangeTriggers(db, TABLES_WATCHED_56);
+  },
+} satisfies Migration;

package/lib/db/migrations/0057_task_pr_wakes.ts

@@ -0,0 +1,34 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 57,
+  name: "task_pr_wakes",
+  up: (db) => {
+    // What a task's agent was told about its PR (orchestrator/pr-wake.ts),
+    // one row per failing head or review/comment id, claimed before the
+    // message goes. kind: check, review or comment (comments are capped).
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS task_pr_wakes (
+          session_id TEXT NOT NULL,
+          key TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          PRIMARY KEY (session_id, key)
+        );
+      `);
+    // pr_wake_since: reviews and comments older than this are taken as
+    // known when a task's PR is first watched.
+    const sessions = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+      name: string;
+    }[];
+    if (!sessions.some((c) => c.name === "pr_wake_since"))
+      db.exec(`ALTER TABLE sessions ADD COLUMN pr_wake_since TEXT`);
+    const workspaces = db.prepare(`PRAGMA table_info(workspaces)`).all() as {
+      name: string;
+    }[];
+    if (!workspaces.some((c) => c.name === "wake_tasks_on_pr"))
+      db.exec(
+        `ALTER TABLE workspaces ADD COLUMN wake_tasks_on_pr INTEGER NOT NULL DEFAULT 1`
+      );
+  },
+} satisfies Migration;

package/lib/db/migrations/0058_away_mode.ts

@@ -0,0 +1,71 @@
+import type { Migration } from "../migration-types";
+import { installChangeTriggers, TABLES_WATCHED_58 } from "../changes";
+
+export default {
+  id: 58,
+  name: "away_mode",
+  up: (db) => {
+    // Saad's Away mode (lib/away): one row per time he stepped away. The
+    // report is built from the database when it ends and kept here.
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS away_periods (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          set_by TEXT NOT NULL,
+          started_at TEXT NOT NULL DEFAULT (datetime('now')),
+          expires_at TEXT,
+          ended_at TEXT,
+          ended_by TEXT,
+          last_sweep_at TEXT,
+          asks_notified_at TEXT,
+          report TEXT,
+          report_seen_at TEXT
+        )
+      `);
+    // What the away sweep did, once per key per period: a nudge, a
+    // request to commit, a review run again, a deploy checked.
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS away_actions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          away_id INTEGER NOT NULL,
+          workspace_id TEXT NOT NULL,
+          subject TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          key TEXT NOT NULL,
+          detail TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          UNIQUE (away_id, key)
+        )
+      `);
+    // When a task merged, whichever path merged it.
+    const columns = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+      name: string;
+    }[];
+    if (!columns.some((c) => c.name === "merged_at"))
+      db.exec(`ALTER TABLE sessions ADD COLUMN merged_at TEXT`);
+    // When a task ended without a merge (dropped, or done with no PR or
+    // its PR closed).
+    if (!columns.some((c) => c.name === "task_ended_at"))
+      db.exec(`ALTER TABLE sessions ADD COLUMN task_ended_at TEXT`);
+    db.exec(`
+        CREATE TRIGGER IF NOT EXISTS sessions_task_ended_at
+          AFTER UPDATE OF task_status ON sessions
+          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 sessions SET task_ended_at = datetime('now') WHERE id = NEW.id;
+        END
+      `);
+    db.exec(`
+        CREATE TRIGGER IF NOT EXISTS sessions_merged_at
+          AFTER UPDATE OF task_status ON sessions
+          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 sessions SET merged_at = datetime('now') WHERE id = NEW.id;
+        END
+      `);
+    installChangeTriggers(db, TABLES_WATCHED_58);
+  },
+} satisfies Migration;

package/lib/db/migrations/0059_gate_failure_commits.ts

@@ -0,0 +1,33 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 59,
+  name: "gate_failure_commits",
+  up: (db) => {
+    // Each head a gate failed on, once: a gate's failure counts once per
+    // commit however many times that commit is judged (the armed watcher,
+    // CI finishing, sign_off, done, land), and the second commit it fails
+    // on goes to Saad. The key is what makes it once, across restarts and
+    // concurrent evaluations.
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS orchestrator_gate_failure_commits (
+          session_id TEXT NOT NULL,
+          gate TEXT NOT NULL,
+          sha TEXT NOT NULL,
+          workspace_id TEXT NOT NULL,
+          reason TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          PRIMARY KEY (session_id, gate, sha)
+        );
+        INSERT OR IGNORE INTO orchestrator_gate_failure_commits (session_id, gate, sha, workspace_id, reason)
+          SELECT session_id, gate, last_sha, workspace_id, last_reason
+          FROM orchestrator_gate_failures WHERE last_sha IS NOT NULL;
+        CREATE TRIGGER IF NOT EXISTS gate_failures_clear_commits
+          AFTER DELETE ON orchestrator_gate_failures
+        BEGIN
+          DELETE FROM orchestrator_gate_failure_commits
+            WHERE session_id = OLD.session_id AND gate = OLD.gate;
+        END;
+      `);
+  },
+} satisfies Migration;

package/lib/db/migrations/0060_check_runs_and_compactions.ts

@@ -0,0 +1,44 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 60,
+  name: "check_runs_and_compactions",
+  up: (db) => {
+    // What each run of the independent reviewer and the scope check cost,
+    // from its claude -p result: it leaves no transcript, so this is the
+    // only record. And each compaction a chat's agent made, so tokens per
+    // task can be compared before and after the threshold moved.
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS check_runs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          workspace_id TEXT NOT NULL,
+          session_id TEXT NOT NULL,
+          label TEXT NOT NULL,
+          pr_number INTEGER,
+          sha TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          model TEXT,
+          input_tokens INTEGER NOT NULL,
+          cache_write_tokens INTEGER NOT NULL,
+          cache_read_tokens INTEGER NOT NULL,
+          output_tokens INTEGER NOT NULL,
+          cost_usd REAL NOT NULL,
+          duration_ms INTEGER,
+          at INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_check_runs_at ON check_runs(at);
+        CREATE INDEX IF NOT EXISTS idx_check_runs_sha ON check_runs(session_id, sha, kind);
+        CREATE TABLE IF NOT EXISTS chat_compactions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          session_name TEXT NOT NULL,
+          workspace_id TEXT,
+          at INTEGER NOT NULL,
+          trigger TEXT NOT NULL,
+          before_tokens INTEGER,
+          after_tokens INTEGER
+        );
+        CREATE INDEX IF NOT EXISTS idx_chat_compactions_at ON chat_compactions(at);
+      `);
+  },
+} satisfies Migration;

package/lib/db/migrations/0061_model_routing.ts

@@ -0,0 +1,30 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 61,
+  name: "model_routing",
+  // One transaction, so a crash part-way leaves nothing to skip as
+  // "duplicate column" on the next start.
+  up: (db) =>
+    db.transaction(() => {
+      // What a session runs on beyond the model name: its provider (NULL is
+      // Anthropic), a task's own models by role (JSON), and a task's plan
+      // step (planning, then implementing). Each turn keeps the model,
+      // provider and role it ran as, how long it took, and the plan's 5-hour
+      // window when it ended, so spend compares by model. A check run keeps the
+      // provider its model came from.
+      for (const col of [
+        `ALTER TABLE sessions ADD COLUMN model_provider TEXT`,
+        `ALTER TABLE sessions ADD COLUMN model_overrides TEXT`,
+        `ALTER TABLE sessions ADD COLUMN plan_phase TEXT`,
+        `ALTER TABLE task_queue ADD COLUMN model_overrides TEXT`,
+        `ALTER TABLE chat_turns ADD COLUMN model TEXT`,
+        `ALTER TABLE chat_turns ADD COLUMN provider TEXT`,
+        `ALTER TABLE chat_turns ADD COLUMN role TEXT`,
+        `ALTER TABLE chat_turns ADD COLUMN duration_ms INTEGER`,
+        `ALTER TABLE chat_turns ADD COLUMN window_pct REAL`,
+        `ALTER TABLE check_runs ADD COLUMN provider TEXT`,
+      ])
+        db.exec(col);
+    })(),
+} satisfies Migration;

package/lib/db/migrations/0062_sessions_quick_of.ts

@@ -0,0 +1,19 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 62,
+  name: "sessions_quick_of",
+  up: (db) => {
+    // A quick change (orchestrator/quick.ts): a task row with no agent,
+    // whose worktree the orchestrator with this session id edits itself.
+    // Set only by quick_change; the code-review gate reads it.
+    const columns = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+      name: string;
+    }[];
+    if (!columns.some((c) => c.name === "quick_of"))
+      db.exec(`ALTER TABLE sessions ADD COLUMN quick_of TEXT`);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_sessions_quick_of ON sessions(quick_of) WHERE quick_of IS NOT NULL`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0063_one_off_schedules.ts

@@ -0,0 +1,16 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 63,
+  name: "one_off_schedules",
+  up: (db) =>
+    db.transaction(() => {
+      // A one-off has a run time (epoch ms, UTC) and no cron; done_at is
+      // set once its single run settles. Recurring rows leave both NULL.
+      db.exec(`ALTER TABLE schedules ADD COLUMN run_at INTEGER`);
+      db.exec(`ALTER TABLE schedules ADD COLUMN done_at INTEGER`);
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_schedules_run_at ON schedules(run_at) WHERE run_at IS NOT NULL`
+      );
+    })(),
+} satisfies Migration;

package/lib/db/migrations/0064_chat_compactions_phase.ts

@@ -0,0 +1,15 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 64,
+  name: "chat_compactions_phase",
+  up: (db) => {
+    // Whether the agent compacted itself mid-turn or AgentOS (or a typed
+    // /compact) did between turns; null on rows from before.
+    const columns = db.prepare(`PRAGMA table_info(chat_compactions)`).all() as {
+      name: string;
+    }[];
+    if (!columns.some((c) => c.name === "phase"))
+      db.exec(`ALTER TABLE chat_compactions ADD COLUMN phase TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/0065_orchestrator_triage.ts

@@ -0,0 +1,23 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 65,
+  name: "orchestrator_triage",
+  up: (db) => {
+    // started_by: the orchestrator session that started this one (null: a
+    // person). plan_decided: 1 planned, 0 no plan, null not stated.
+    const add = (table: string, col: string, type: string) => {
+      const columns = db.prepare(`PRAGMA table_info(${table})`).all() as {
+        name: string;
+      }[];
+      if (!columns.some((c) => c.name === col))
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${type}`);
+    };
+    add("sessions", "started_by", "TEXT");
+    add("sessions", "plan_decided", "INTEGER");
+    add("sessions", "plan_reason", "TEXT");
+    add("task_queue", "plan", "INTEGER");
+    add("task_queue", "plan_reason", "TEXT");
+    add("task_queue", "started_by", "TEXT");
+  },
+} satisfies Migration;

package/lib/db/migrations/0066_workspace_orch_mcp_servers.ts

@@ -0,0 +1,16 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 66,
+  name: "workspace_orch_mcp_servers",
+  up: (db) => {
+    // The MCP servers (by name) a workspace's orchestrator may use.
+    const columns = db.prepare(`PRAGMA table_info(workspaces)`).all() as {
+      name: string;
+    }[];
+    if (!columns.some((c) => c.name === "orch_mcp_servers"))
+      db.exec(
+        `ALTER TABLE workspaces ADD COLUMN orch_mcp_servers TEXT NOT NULL DEFAULT '["linear"]'`
+      );
+  },
+} satisfies Migration;

package/lib/db/migrations/0067_orchestrator_event_log_suppressed.ts

@@ -0,0 +1,14 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 67,
+  name: "orchestrator_event_log_suppressed",
+  up: (db) => {
+    // A capped event is logged as suppressed so a drop leaves a trace.
+    const columns = db
+      .prepare(`PRAGMA table_info(orchestrator_event_log)`)
+      .all() as { name: string }[];
+    if (!columns.some((c) => c.name === "suppressed"))
+      db.exec(`ALTER TABLE orchestrator_event_log ADD COLUMN suppressed TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/0068_usage_calls_and_rollups.ts

@@ -0,0 +1,74 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 68,
+  name: "usage_calls_and_rollups",
+  up: (db) => {
+    // One row per Claude response (or per one-shot run), the daily rollups
+    // computed from them, the ratchet's baseline and the limit readings.
+    db.transaction(() => {
+      db.exec(`
+          CREATE TABLE IF NOT EXISTS usage_calls (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            call_key TEXT NOT NULL UNIQUE,
+            at INTEGER NOT NULL,
+            session_id TEXT,
+            task_id TEXT,
+            workspace_id TEXT,
+            project_id TEXT,
+            session_name TEXT,
+            role TEXT,
+            kind TEXT NOT NULL,
+            agent_type TEXT,
+            model TEXT,
+            provider TEXT,
+            input_tokens INTEGER NOT NULL DEFAULT 0,
+            cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+            cache_write_5m_tokens INTEGER NOT NULL DEFAULT 0,
+            cache_write_1h_tokens INTEGER NOT NULL DEFAULT 0,
+            output_tokens INTEGER NOT NULL DEFAULT 0,
+            ctx_tokens INTEGER,
+            source TEXT NOT NULL
+          );
+          CREATE INDEX IF NOT EXISTS idx_usage_calls_at ON usage_calls(at);
+          CREATE INDEX IF NOT EXISTS idx_usage_calls_task ON usage_calls(task_id);
+          CREATE INDEX IF NOT EXISTS idx_usage_calls_session ON usage_calls(session_id);
+          CREATE TABLE IF NOT EXISTS rate_limit_readings (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            at INTEGER NOT NULL,
+            window TEXT NOT NULL,
+            utilization REAL NOT NULL,
+            raw REAL,
+            resets_at INTEGER,
+            status TEXT,
+            session_id TEXT,
+            source TEXT NOT NULL
+          );
+          CREATE INDEX IF NOT EXISTS idx_rate_limit_readings ON rate_limit_readings(window, at);
+          CREATE TABLE IF NOT EXISTS usage_rollups (
+            day TEXT PRIMARY KEY,
+            data TEXT NOT NULL,
+            final INTEGER NOT NULL DEFAULT 0,
+            computed_at INTEGER NOT NULL
+          );
+          CREATE TABLE IF NOT EXISTS usage_baseline (
+            metric TEXT PRIMARY KEY,
+            value REAL NOT NULL,
+            set_at INTEGER NOT NULL,
+            supporting TEXT
+          );
+          CREATE TABLE IF NOT EXISTS usage_alerts (
+            kind TEXT PRIMARY KEY,
+            opened_at INTEGER NOT NULL,
+            cleared_at INTEGER,
+            message TEXT NOT NULL
+          );
+          CREATE TABLE IF NOT EXISTS usage_import_offsets (
+            path TEXT PRIMARY KEY,
+            offset INTEGER NOT NULL,
+            mtime INTEGER NOT NULL
+          );
+        `);
+    })();
+  },
+} satisfies Migration;

package/lib/db/migrations/0069_session_logs.ts

@@ -0,0 +1,26 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 69,
+  name: "session_logs",
+  up: (db) => {
+    // One log per merged task, written by AgentOS from data it already
+    // holds (lib/session-logs). Never deleted: the database is the record,
+    // the markdown file on disk is a copy.
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS session_logs (
+          session_id TEXT PRIMARY KEY,
+          project_id TEXT,
+          workspace_id TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          markdown TEXT NOT NULL,
+          data TEXT NOT NULL,
+          file_path TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_session_logs_project
+          ON session_logs(project_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_session_logs_workspace
+          ON session_logs(workspace_id, created_at);
+      `);
+  },
+} satisfies Migration;

package/lib/db/migrations/0070_chat_items_running.ts

@@ -0,0 +1,15 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 70,
+  name: "chat_items_running",
+  up: (db) => {
+    // What is still running (tools, background tasks) is read on every
+    // attach; the index holds only those rows, so it's a lookup, not a
+    // scan that parses every tool output of a long conversation.
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_chat_items_running ON chat_items(session_id, kind, seq)
+         WHERE json_extract(data, '$.status') = 'running'`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0071_devices_push.ts

@@ -0,0 +1,29 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 71,
+  name: "devices_push",
+  up: (db) => {
+    // Push belongs to a paired device, so revoking the device clears it.
+    // push_categories is a JSON array; NULL means the defaults.
+    // Each column checked, so a run cut off part way can be run again.
+    const have = new Set(
+      (
+        db.prepare(`PRAGMA table_info(devices)`).all() as { name: string }[]
+      ).map((c) => c.name)
+    );
+    for (const col of [
+      "push_token",
+      "push_platform",
+      "push_environment",
+      "push_categories",
+      "push_updated_at",
+      "push_last_error",
+    ])
+      if (!have.has(col)) db.exec(`ALTER TABLE devices ADD COLUMN ${col} TEXT`);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_devices_push_token ON devices(push_token)
+         WHERE push_token IS NOT NULL`
+    );
+  },
+} satisfies Migration;

package/lib/db/migrations/0072_push_outbox.ts

@@ -0,0 +1,33 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  id: 72,
+  name: "push_outbox",
+  up: (db) => {
+    // One row per (event, device). device_id is '' for a row folded into
+    // the Away digest. state: pending, sending, sent, failed, gone,
+    // capped, superseded, folded, digested.
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS push_outbox (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          event_key TEXT NOT NULL,
+          device_id TEXT NOT NULL,
+          category TEXT NOT NULL,
+          level TEXT NOT NULL,
+          payload TEXT NOT NULL,
+          collapse_id TEXT,
+          state TEXT NOT NULL,
+          attempts INTEGER NOT NULL DEFAULT 0,
+          next_attempt_at INTEGER NOT NULL,
+          created_at INTEGER NOT NULL,
+          sent_at INTEGER,
+          error TEXT,
+          fallback_source TEXT,
+          fallback_text TEXT,
+          UNIQUE(event_key, device_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_push_outbox_due ON push_outbox(state, next_attempt_at);
+        CREATE INDEX IF NOT EXISTS idx_push_outbox_device ON push_outbox(device_id, sent_at);
+      `);
+  },
+} satisfies Migration;