@lensagent/core 0.1.0

package/dist/store/store.js

@@ -0,0 +1,2554 @@
+import { digest, id, json, now, parseJson } from '../core/codec.js';
+import { fail } from '../core/domain.js';
+import { policyPrompt } from '../runtime/policy.js';
+export class Store {
+    #database;
+    #events;
+    #eventLog;
+    constructor(database, events, eventLog) {
+        this.#database = database;
+        this.#events = events;
+        this.#eventLog = eventLog;
+    }
+    async close() {
+        await this.#eventLog?.close();
+        this.#database.close();
+    }
+    instance() {
+        return doc(this.#one('SELECT * FROM instance WHERE id = 1'));
+    }
+    stateRevision() {
+        return Number(this.#one('SELECT state_revision FROM instance WHERE id = 1').state_revision);
+    }
+    ingressReplay(input) {
+        return this.#ingressReplay(input);
+    }
+    recover() {
+        const interrupted = [];
+        const transaction = this.#database.transaction(() => {
+            const timestamp = now();
+            const compactionRunIds = new Set(this.#all(`
+        SELECT DISTINCT r.id FROM model_attempts ma
+        JOIN steps s ON s.id = ma.step_id
+        JOIN runs r ON r.id = s.run_id
+        WHERE ma.kind = 'compaction' AND ma.state IN ('PREPARED', 'RUNNING')
+      `).map((row) => String(row.id)));
+            const interruptedAgentIds = new Set(this.#all(`SELECT DISTINCT agent_id FROM runs WHERE state IN ('RUNNING', 'WAITING')`).map((row) => String(row.agent_id)));
+            const attempts = this.#all("SELECT id FROM model_attempts WHERE state IN ('PREPARED', 'RUNNING')");
+            for (const row of attempts)
+                interrupted.push({ type: 'model_attempt', id: String(row.id) });
+            this.#database.prepare(`UPDATE model_attempts SET state = 'TERMINAL', outcome = 'interrupted', error_code = 'PROCESS_INTERRUPTED', updated_at = ? WHERE state IN ('PREPARED', 'RUNNING')`).run(timestamp);
+            const calls = this.#all(`SELECT id, state FROM calls WHERE state = 'RUNNING' OR (step_id IS NOT NULL AND state IN ('WAITING', 'QUEUED'))`);
+            for (const row of calls) {
+                const callId = String(row.id);
+                interrupted.push({ type: 'call', id: callId });
+                const running = row.state === 'RUNNING';
+                const outcome = running ? 'interrupted' : 'cancelled';
+                const errorCode = running ? 'PROCESS_INTERRUPTED' : 'RECOVERY_CANCELLED';
+                this.#database.prepare(`UPDATE calls SET state = 'TERMINAL', outcome = ?, outcome_unknown = ?, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                    .run(outcome, running ? 1 : 0, timestamp, callId);
+                this.#database.prepare(`INSERT OR IGNORE INTO results(id, call_id, outcome, content_json, error_code, error_message, created_at) VALUES (?, ?, ?, '{}', ?, 'The Agent workflow was interrupted by process shutdown.', ?)`)
+                    .run(id('result'), callId, outcome, errorCode, timestamp);
+            }
+            const ledgerSteps = this.#all(`SELECT DISTINCT s.id, r.agent_id FROM steps s JOIN runs r ON r.id = s.run_id JOIN calls c ON c.step_id = s.id WHERE s.state IN ('RUNNING', 'WAITING')`);
+            for (const row of ledgerSteps) {
+                const stepId = String(row.id);
+                const agentId = String(row.agent_id);
+                const entries = this.#all(`SELECT c.id, c.capability_id, c.call_ordinal, c.outcome, c.outcome_unknown, r.content_json, r.error_code FROM calls c LEFT JOIN results r ON r.call_id = c.id WHERE c.step_id = ? ORDER BY c.call_ordinal, c.id`, stepId)
+                    .map((entry) => ({
+                    call_id: String(entry.id),
+                    capability_id: String(entry.capability_id),
+                    call_ordinal: Number(entry.call_ordinal),
+                    outcome: typeof entry.outcome === 'string' ? entry.outcome : null,
+                    outcome_unknown: Number(entry.outcome_unknown) === 1,
+                    content: typeof entry.content_json === 'string' ? parseJson(entry.content_json) : null,
+                    error_code: typeof entry.error_code === 'string' ? entry.error_code : null
+                }));
+                const content = json({ version: 'failed-attempt-side-effect-ledger-v1', step_id: stepId, calls: entries });
+                const ledgerId = id('ledger');
+                const ids = { messageId: id('message'), contextId: id('context'), turnGroupId: id('turn') };
+                this.#database.prepare('INSERT INTO side_effect_ledgers(id, step_id, content, created_at) VALUES (?, ?, ?, ?)').run(ledgerId, stepId, content, timestamp);
+                this.#insertContextMessage(agentId, 'system', content, ids, timestamp, 'ledger');
+                interrupted.push({ type: 'side_effect_ledger', id: ledgerId }, { type: 'context_item', id: ids.contextId });
+            }
+            const steps = this.#all("SELECT id FROM steps WHERE state IN ('RUNNING', 'WAITING')");
+            for (const row of steps) {
+                const stepId = String(row.id);
+                const runId = String(this.#require('steps', stepId).run_id);
+                const compactionFailed = compactionRunIds.has(runId);
+                interrupted.push({ type: 'step', id: stepId });
+                this.#database.prepare(`UPDATE steps SET state = 'TERMINAL', outcome = ?, error_code = ?, updated_at = ? WHERE id = ?`)
+                    .run(compactionFailed ? 'failed' : 'interrupted', compactionFailed ? 'COMPACTION_FAILED' : 'PROCESS_INTERRUPTED', timestamp, stepId);
+            }
+            this.#database.prepare(`UPDATE context_turn_groups SET state = 'ABORTED', revision = revision + 1, completed_at = ? WHERE state = 'OPEN'`).run(timestamp);
+            const runs = this.#all("SELECT id FROM runs WHERE state IN ('RUNNING', 'WAITING')");
+            for (const row of runs) {
+                const runId = String(row.id);
+                const compactionFailed = compactionRunIds.has(runId);
+                interrupted.push({ type: 'run', id: runId });
+                this.#database.prepare(`UPDATE runs SET state = 'TERMINAL', outcome = ?, error_code = ?, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                    .run(compactionFailed ? 'failed' : 'interrupted', compactionFailed ? 'COMPACTION_FAILED' : 'PROCESS_INTERRUPTED', timestamp, runId);
+            }
+            for (const agentId of interruptedAgentIds) {
+                this.#database.prepare(`UPDATE agents SET state = 'IDLE', revision = revision + 1, updated_at = ? WHERE id = ?`).run(timestamp, agentId);
+                interrupted.push({ type: 'agent', id: agentId });
+            }
+            if (interrupted.length > 0)
+                this.#database.prepare('UPDATE instance SET state_revision = state_revision + 1 WHERE id = 1').run();
+        });
+        transaction();
+        return interrupted;
+    }
+    /**
+     * 02A `ProjectPageQuery.archive`: `active` hides archived Projects, `archived` shows only those,
+     * `all` shows both. The Route previously read a differently spelled parameter, so the documented
+     * one silently had no effect and archived Projects were unreachable through the API.
+     */
+    listProjects(options, archive = 'active') {
+        const clause = archive === 'all' ? '1 = 1' : archive === 'archived' ? 'archived_at IS NOT NULL' : 'archived_at IS NULL';
+        return this.#page(`SELECT * FROM projects WHERE ${clause}`, [], options);
+    }
+    defaultProject() {
+        const row = this.#database.prepare(`SELECT * FROM projects WHERE archived_at IS NULL ORDER BY created_at, id LIMIT 1`).get();
+        return row === undefined ? null : doc(row);
+    }
+    getProject(projectId) {
+        return doc(this.#require('projects', projectId));
+    }
+    createProject(name, paths) {
+        const projectId = id('project');
+        const workspaceId = id('workspace');
+        const timestamp = now();
+        return this.#write(projectId, refs(['project', projectId], ['workspace', workspaceId]), () => {
+            this.#database.prepare(`INSERT INTO projects(id, name, archived_at, revision, created_at, updated_at) VALUES (?, ?, NULL, 0, ?, ?)`)
+                .run(projectId, name, timestamp, timestamp);
+            this.#database.prepare(`INSERT INTO workspaces(id, project_id, name, is_default, revision, created_at, updated_at) VALUES (?, ?, 'Default', 1, 0, ?, ?)`)
+                .run(workspaceId, projectId, timestamp, timestamp);
+            this.#replaceWorkspacePaths(workspaceId, paths);
+            return this.getProject(projectId);
+        });
+    }
+    updateProject(projectId, expectedRevision, name) {
+        return this.#write(projectId, refs(['project', projectId]), () => {
+            this.#expect(this.#require('projects', projectId), expectedRevision);
+            this.#database.prepare('UPDATE projects SET name = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(name, now(), projectId);
+            return this.getProject(projectId);
+        });
+    }
+    archiveProject(projectId, expectedRevision, archived) {
+        return this.#write(projectId, refs(['project', projectId]), () => {
+            this.#expect(this.#require('projects', projectId), expectedRevision);
+            if (archived && this.#count(`SELECT COUNT(*) AS count FROM calls WHERE project_id = ? AND state IN ('WAITING', 'QUEUED', 'RUNNING')`, projectId) > 0) {
+                fail('PROJECT_BUSY', 409, 'The Project has active Calls.');
+            }
+            this.#database.prepare('UPDATE projects SET archived_at = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(archived ? now() : null, now(), projectId);
+            return this.getProject(projectId);
+        });
+    }
+    listWorkspaces(projectId) {
+        this.#require('projects', projectId);
+        return this.#all('SELECT * FROM workspaces WHERE project_id = ? ORDER BY is_default DESC, name, id', projectId).map((row) => this.#workspace(row));
+    }
+    /**
+     * The ordered folder set a Call may reach: every Workspace in the Project, with the Call's own
+     * Workspace first.
+     *
+     * The bound Workspace leads because the first path is the primary one that relative paths resolve
+     * against, so an Agent's own folder stays the default target while the rest of the Project becomes
+     * readable. Paths are deduplicated: the same folder may appear in more than one Workspace, and a
+     * repeated root would make the Executor walk it twice.
+     */
+    projectWorkspacePaths(projectId, workspaceId) {
+        const bound = this.getWorkspace(projectId, workspaceId);
+        const ordered = [bound, ...this.listWorkspaces(projectId).filter((workspace) => workspace.id !== bound.id)];
+        const seen = new Set();
+        const paths = [];
+        for (const workspace of ordered) {
+            const value = workspace.paths;
+            if (!Array.isArray(value))
+                continue;
+            for (const entry of value) {
+                if (typeof entry !== 'string' || seen.has(entry))
+                    continue;
+                seen.add(entry);
+                paths.push(entry);
+            }
+        }
+        return paths;
+    }
+    getWorkspace(projectId, workspaceId) {
+        const row = this.#require('workspaces', workspaceId);
+        owned(row, 'project_id', projectId);
+        return this.#workspace(row);
+    }
+    createWorkspace(projectId, name, paths, makeDefault) {
+        const workspaceId = id('workspace');
+        const timestamp = now();
+        return this.#write(projectId, refs(['workspace', workspaceId]), () => {
+            this.#activeProject(projectId);
+            if (makeDefault)
+                this.#database.prepare('UPDATE workspaces SET is_default = 0 WHERE project_id = ?').run(projectId);
+            // `UNIQUE(project_id, name)` is a rejected input, not a storage failure. Left to escape it
+            // surfaced as INTERNAL_ERROR 500 marked retryable, which told the caller to repeat a request
+            // that can never succeed and blamed the Server for the client's name.
+            uniqueName(name, () => {
+                this.#database.prepare(`INSERT INTO workspaces(id, project_id, name, is_default, revision, created_at, updated_at) VALUES (?, ?, ?, ?, 0, ?, ?)`)
+                    .run(workspaceId, projectId, name, makeDefault ? 1 : 0, timestamp, timestamp);
+            });
+            this.#replaceWorkspacePaths(workspaceId, paths);
+            return this.getWorkspace(projectId, workspaceId);
+        });
+    }
+    updateWorkspace(projectId, workspaceId, expectedRevision, name, paths, makeDefault) {
+        return this.#write(projectId, refs(['workspace', workspaceId]), () => {
+            const current = this.#require('workspaces', workspaceId);
+            owned(current, 'project_id', projectId);
+            this.#expect(current, expectedRevision);
+            if (!makeDefault && Number(current.is_default) === 1)
+                fail('DEFAULT_WORKSPACE_REQUIRED', 409, 'Select another default Workspace first.');
+            if (makeDefault)
+                this.#database.prepare('UPDATE workspaces SET is_default = 0 WHERE project_id = ?').run(projectId);
+            uniqueName(name, () => {
+                this.#database.prepare(`UPDATE workspaces SET name = ?, is_default = ?, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                    .run(name, makeDefault ? 1 : 0, now(), workspaceId);
+            });
+            this.#replaceWorkspacePaths(workspaceId, paths);
+            return this.getWorkspace(projectId, workspaceId);
+        });
+    }
+    deleteWorkspace(projectId, workspaceId, expectedRevision) {
+        this.#write(projectId, refs(['workspace', workspaceId]), () => {
+            const current = this.#require('workspaces', workspaceId);
+            owned(current, 'project_id', projectId);
+            this.#expect(current, expectedRevision);
+            if (Number(current.is_default) === 1)
+                fail('DEFAULT_WORKSPACE_REQUIRED', 409, 'The default Workspace cannot be deleted.');
+            // Agents and Calls reference a Workspace with ON DELETE RESTRICT, so history holds it in
+            // place. 07 documents that as `WORKSPACE_NOT_DELETABLE`; left to escape, the foreign key
+            // surfaced as INTERNAL_ERROR 500 and told the caller nothing about what still refers to it.
+            const agents = this.#count('SELECT COUNT(*) AS count FROM agents WHERE workspace_id = ?', workspaceId);
+            const calls = this.#count('SELECT COUNT(*) AS count FROM calls WHERE workspace_id = ?', workspaceId);
+            if (agents > 0 || calls > 0) {
+                fail('WORKSPACE_NOT_DELETABLE', 409, agents > 0
+                    ? `The Workspace is still bound to ${agents} Agent${agents === 1 ? '' : 's'}.`
+                    : `The Workspace is referenced by ${calls} Call${calls === 1 ? '' : 's'} in history.`);
+            }
+            this.#database.prepare('DELETE FROM workspaces WHERE id = ?').run(workspaceId);
+        });
+    }
+    listTasks(projectId, options, archived = false) {
+        this.#require('projects', projectId);
+        const page = this.#page(`SELECT * FROM tasks WHERE project_id = ? AND (? = 1 OR archived_at IS NULL)`, [projectId, archived ? 1 : 0], options);
+        const workspaces = this.#taskWorkspaceIds(page.items.map((task) => stringField(task.id)));
+        return {
+            ...page,
+            items: page.items.map((task) => ({
+                ...task,
+                workspace_ids: workspaces.get(stringField(task.id)) ?? [],
+                // Documented as nullable; retention has no per-Task column, so it is always absent today.
+                purge_after: task.purge_after ?? null
+            }))
+        };
+    }
+    listAllTasks(projectId, options, archived = false) {
+        return this.listTasks(projectId, options, archived);
+    }
+    getTask(projectId, taskId) {
+        const row = this.#require('tasks', taskId);
+        owned(row, 'project_id', projectId);
+        return {
+            ...doc(row),
+            workspace_ids: this.#taskWorkspaceIds([taskId]).get(taskId) ?? [],
+            purge_after: doc(row).purge_after ?? null
+        };
+    }
+    /**
+     * A Project's Task/Session totals. `Page` carries no total, so without this a client had to walk
+     * every page to show a count.
+     */
+    projectDetail(projectId) {
+        const project = this.getProject(projectId);
+        return {
+            project,
+            task_count: this.#count('SELECT COUNT(*) AS count FROM tasks WHERE project_id = ?', projectId),
+            active_task_count: this.#count('SELECT COUNT(*) AS count FROM tasks WHERE project_id = ? AND archived_at IS NULL', projectId),
+            session_count: this.#count('SELECT COUNT(*) AS count FROM sessions s JOIN tasks t ON t.id = s.task_id WHERE t.project_id = ?', projectId)
+        };
+    }
+    /**
+     * 02A `TaskDetail`. The Route returned a bare `TaskSummary`, so a client reading `task.title`
+     * dereferenced `undefined` and the view crashed. Counts are derived, not stored.
+     */
+    taskDetail(projectId, taskId) {
+        const task = this.getTask(projectId, taskId);
+        return {
+            task,
+            root_agent_count: this.#count('SELECT COUNT(*) AS count FROM agents WHERE task_id = ? AND parent_agent_id IS NULL', taskId),
+            total_agent_count: this.#count('SELECT COUNT(*) AS count FROM agents WHERE task_id = ?', taskId),
+            active_run_count: this.#count(`SELECT COUNT(*) AS count FROM runs r JOIN agents a ON a.id = r.agent_id
+         WHERE a.task_id = ? AND r.state <> 'TERMINAL'`, taskId)
+        };
+    }
+    createTask(projectId, title) {
+        const taskId = id('task');
+        const timestamp = now();
+        return this.#write(projectId, refs(['task', taskId]), () => {
+            this.#activeProject(projectId);
+            this.#database.prepare(`INSERT INTO tasks(id, project_id, title, archived_at, revision, created_at, updated_at) VALUES (?, ?, ?, NULL, 0, ?, ?)`)
+                .run(taskId, projectId, title, timestamp, timestamp);
+            return this.getTask(projectId, taskId);
+        });
+    }
+    updateTask(projectId, taskId, expectedRevision, title) {
+        return this.#write(projectId, refs(['task', taskId]), () => {
+            const current = this.#require('tasks', taskId);
+            owned(current, 'project_id', projectId);
+            this.#expect(current, expectedRevision);
+            this.#database.prepare('UPDATE tasks SET title = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(title, now(), taskId);
+            return this.getTask(projectId, taskId);
+        });
+    }
+    archiveTask(projectId, taskId, expectedRevision, archived) {
+        return this.#write(projectId, refs(['task', taskId]), () => {
+            const current = this.#require('tasks', taskId);
+            owned(current, 'project_id', projectId);
+            this.#expect(current, expectedRevision);
+            if (archived && this.#count(`SELECT COUNT(*) AS count FROM runs r JOIN agents a ON a.id = r.agent_id WHERE a.task_id = ? AND r.state != 'TERMINAL'`, taskId) > 0) {
+                fail('TASK_BUSY', 409, 'The Task has active Runs.');
+            }
+            this.#database.prepare('UPDATE tasks SET archived_at = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(archived ? now() : null, now(), taskId);
+            return this.getTask(projectId, taskId);
+        });
+    }
+    deleteTask(projectId, taskId, expectedRevision) {
+        return this.#write(projectId, refs(['task', taskId]), () => {
+            const current = this.#require('tasks', taskId);
+            owned(current, 'project_id', projectId);
+            this.#expect(current, expectedRevision);
+            if (current.archived_at === null)
+                fail('TASK_NOT_ARCHIVED', 409, 'Archive the Task before deleting it.');
+            return this.#purgeTaskRows([taskId]);
+        });
+    }
+    listSessions(projectId, taskId, options, archived = false) {
+        this.getTask(projectId, taskId);
+        const page = this.#page(`SELECT * FROM sessions WHERE task_id = ? AND (? = 1 OR archived_at IS NULL)`, [taskId, archived ? 1 : 0], options);
+        return { ...page, items: page.items.map((session) => this.#sessionSummary(session, projectId)) };
+    }
+    getSession(projectId, sessionId) {
+        const row = this.#require('sessions', sessionId);
+        this.#ownedTask(String(row.task_id), projectId);
+        return this.#sessionSummary(doc(row), projectId);
+    }
+    /**
+     * 02A `SessionSummary`. The stored row holds only title, timestamps and revision; `project_id`,
+     * `root_agent_id`, `active_run_count` and `status` are derived. They were absent from the wire
+     * entirely, so the rail showed every Session as "Ready" and its live indicator never lit.
+     */
+    #sessionSummary(session, projectId) {
+        const sessionId = stringField(session.id);
+        const rootAgent = this.#all('SELECT id FROM agents WHERE session_id = ? AND parent_agent_id IS NULL ORDER BY created_at, id LIMIT 1', sessionId)[0];
+        const running = this.#count(`SELECT COUNT(*) AS count FROM runs r JOIN agents a ON a.id = r.agent_id
+       WHERE a.session_id = ? AND r.state = 'RUNNING'`, sessionId);
+        const waiting = this.#count(`SELECT COUNT(*) AS count FROM runs r JOIN agents a ON a.id = r.agent_id
+       WHERE a.session_id = ? AND r.state = 'WAITING'`, sessionId);
+        const pending = this.#count(`SELECT COUNT(*) AS count FROM runs r JOIN agents a ON a.id = r.agent_id
+       WHERE a.session_id = ? AND r.state <> 'TERMINAL'`, sessionId);
+        // The outcome of the most recent Run, not a count of every Run that ever failed. Counting made the
+        // status permanent: one failed Run pinned a Session to `failed` for the rest of its life, however
+        // many successful Runs followed, because a count of past failures never goes down. A status badge
+        // answers "what happened last", so that is what this reads.
+        //
+        // A cancelled last Run reports `ready`: the user stopped it deliberately, which is neither a
+        // failure nor a completion, and the Session is ready for the next message. `interrupted` does
+        // report `failed` -- nothing chose that, the Run was cut off.
+        const latest = this.#all(`SELECT r.outcome FROM runs r JOIN agents a ON a.id = r.agent_id
+       WHERE a.session_id = ? AND r.state = 'TERMINAL'
+       ORDER BY r.created_at DESC, r.id DESC LIMIT 1`, sessionId)[0];
+        const outcome = latest === undefined ? null : String(latest.outcome);
+        return {
+            ...session,
+            project_id: projectId,
+            root_agent_id: rootAgent === undefined ? null : String(rootAgent.id),
+            active_run_count: pending,
+            status: session.archived_at !== null
+                ? 'archived'
+                : running > 0
+                    ? 'running'
+                    : waiting > 0
+                        ? 'waiting'
+                        : outcome === 'failed' || outcome === 'interrupted'
+                            ? 'failed'
+                            : outcome === 'success'
+                                ? 'completed'
+                                : 'ready'
+        };
+    }
+    /**
+     * 02A `SessionDetail`. The Route returned a bare `SessionSummary`, so `root_agent` was absent and
+     * a client reading the active Agent's Workspace dereferenced `undefined`.
+     */
+    sessionDetail(projectId, sessionId) {
+        const session = this.getSession(projectId, sessionId);
+        const rootAgentId = session.root_agent_id;
+        const rootAgent = typeof rootAgentId === 'string' ? this.getAgent(projectId, rootAgentId) : null;
+        return {
+            session,
+            root_agent: rootAgent,
+            runtime: rootAgent === null ? null : this.#agentRuntime(rootAgent),
+            active_run: rootAgent === null ? null : this.#activeRun(stringField(rootAgent.id)),
+            state_revision: String(this.stateRevision())
+        };
+    }
+    /** 02A `AgentDetail`. */
+    agentDetail(projectId, agentId) {
+        const agent = this.getAgent(projectId, agentId);
+        return {
+            agent,
+            session: this.#agentRuntime(agent),
+            active_run: this.#activeRun(agentId)
+        };
+    }
+    /**
+     * 02A `AgentSessionRuntimeSummary`. Only `context_revision` is stored today; the Work Context and
+     * token-estimate fields have no column yet, so they report `null` rather than a fabricated value.
+     */
+    #agentRuntime(agent) {
+        const agentId = stringField(agent.id);
+        const pending = this.#all('SELECT COUNT(*) AS count, MAX(ordinal) AS high FROM pending_messages WHERE agent_id = ?', agentId)[0];
+        return {
+            session_id: agent.session_id ?? null,
+            agent_session_id: agentId,
+            agent_id: agentId,
+            context_revision: agent.context_revision ?? 0,
+            context_high_water: this.#count('SELECT COUNT(*) AS count FROM context_items WHERE agent_id = ?', agentId),
+            pending_seq_high_water: Number(pending?.high ?? 0),
+            pending_revision: Number(pending?.count ?? 0),
+            work_context_revision: null,
+            work_context_digest: null,
+            request_context_frame_digest: null,
+            token_estimate: null
+        };
+    }
+    /** The newest run for an Agent that has not reached `TERMINAL`, as 02A `RunSummary`. */
+    #activeRun(agentId) {
+        const row = this.#all(`SELECT * FROM runs WHERE agent_id = ? AND state <> 'TERMINAL' ORDER BY created_at DESC, id DESC LIMIT 1`, agentId)[0];
+        return row === undefined ? null : this.#runSummary(doc(row));
+    }
+    /**
+     * 02A `RunSummary`. The stored row keeps `state` and `outcome` separate; `status` is the single
+     * documented projection of the two, and clients switch on it.
+     */
+    #runSummary(run) {
+        const state = stringField(run.state);
+        const outcome = typeof run.outcome === 'string' ? run.outcome : null;
+        const terminal = {
+            success: 'COMPLETED', failed: 'FAILED', cancelled: 'CANCELLED', interrupted: 'INTERRUPTED'
+        };
+        return {
+            ...run,
+            run_id: run.id ?? null,
+            session_id: run.agent_id ?? null,
+            agent_session_id: run.agent_id ?? null,
+            retry_of_run_id: run.retry_of_run_id ?? null,
+            initial_step_pending: run.initial_step_pending === 1,
+            tool_continuation_pending: false,
+            status: state === 'TERMINAL' && outcome !== null ? terminal[outcome] ?? 'FAILED' : state,
+            started_at: run.started_at ?? null,
+            ended_at: run.ended_at ?? null,
+            error_code: run.error_code ?? null
+        };
+    }
+    createSession(projectId, taskId, title, ingress) {
+        const replay = ingress === undefined ? null : this.#ingressReplay(ingress);
+        if (replay !== null)
+            return replay;
+        const sessionId = id('session');
+        const timestamp = now();
+        return this.#write(projectId, refs(['session', sessionId]), () => {
+            const task = this.#require('tasks', taskId);
+            owned(task, 'project_id', projectId);
+            if (task.archived_at !== null)
+                fail('TASK_ARCHIVED', 409, 'The Task is archived.');
+            this.#database.prepare(`INSERT INTO sessions(id, task_id, title, archived_at, revision, created_at, updated_at) VALUES (?, ?, ?, NULL, 0, ?, ?)`)
+                .run(sessionId, taskId, title, timestamp, timestamp);
+            const session = this.getSession(projectId, sessionId);
+            if (ingress !== undefined)
+                this.#recordIngress(ingress, session);
+            return session;
+        });
+    }
+    createSessionWithAgent(projectId, input) {
+        const replay = this.#ingressReplay(input.ingress);
+        if (replay !== null)
+            return replay;
+        const sessionId = id('session');
+        const agentId = id('agent');
+        const promptIds = input.initialPrompt === undefined ? null : { messageId: id('message'), contextId: id('context'), turnGroupId: id('turn') };
+        const messageIds = input.initialMessage === undefined ? null : messageIdsForWrite();
+        const changes = [
+            ['session', sessionId],
+            ['agent', agentId],
+            ...(promptIds === null ? [] : [
+                ['message', promptIds.messageId],
+                ['turn_group', promptIds.turnGroupId],
+                ['context_item', promptIds.contextId]
+            ]),
+            ...(messageIds === null ? [] : messageRefs(messageIds))
+        ];
+        return this.#write(projectId, refs(...changes), () => {
+            const task = this.#require('tasks', input.taskId);
+            owned(task, 'project_id', projectId);
+            if (task.archived_at !== null)
+                fail('TASK_ARCHIVED', 409, 'The Task is archived.');
+            const timestamp = now();
+            this.#database.prepare(`INSERT INTO sessions(id, task_id, title, archived_at, revision, created_at, updated_at) VALUES (?, ?, ?, NULL, 0, ?, ?)`)
+                .run(sessionId, input.taskId, input.title, timestamp, timestamp);
+            this.#insertAgent(projectId, agentId, {
+                taskId: input.taskId,
+                sessionId,
+                workspaceId: input.workspaceId,
+                name: input.agentName,
+                model: input.model,
+                modelReasoningEffort: input.modelReasoningEffort,
+                policyPreset: input.policyPreset,
+                capabilities: input.capabilities,
+                loadedCapabilities: input.loadedCapabilities
+            }, timestamp);
+            if (promptIds !== null && input.initialPrompt !== undefined) {
+                this.#insertContextMessage(agentId, 'system', input.initialPrompt, promptIds, timestamp);
+            }
+            const queued = messageIds === null || input.initialMessage === undefined
+                ? null
+                : this.#insertQueuedMessage(projectId, agentId, input.initialMessage, undefined, messageIds, timestamp);
+            const response = {
+                session: this.getSession(projectId, sessionId),
+                agent: this.getAgent(projectId, agentId),
+                assignment: this.listCapabilities(projectId, agentId),
+                run: queued?.run ?? null
+            };
+            this.#recordIngress(input.ingress, response);
+            return response;
+        });
+    }
+    updateSession(projectId, sessionId, expectedRevision, title) {
+        return this.#write(projectId, refs(['session', sessionId]), () => {
+            const current = this.#require('sessions', sessionId);
+            this.#ownedTask(String(current.task_id), projectId);
+            this.#expect(current, expectedRevision);
+            this.#database.prepare('UPDATE sessions SET title = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(title, now(), sessionId);
+            return this.getSession(projectId, sessionId);
+        });
+    }
+    archiveSession(projectId, sessionId, expectedRevision, archived) {
+        return this.#write(projectId, refs(['session', sessionId]), () => {
+            const current = this.#require('sessions', sessionId);
+            this.#ownedTask(String(current.task_id), projectId);
+            this.#expect(current, expectedRevision);
+            if (archived && this.#count(`SELECT COUNT(*) AS count FROM runs r JOIN agents a ON a.id = r.agent_id WHERE a.session_id = ? AND r.state != 'TERMINAL'`, sessionId) > 0) {
+                fail('SESSION_BUSY', 409, 'The Session has active Runs.');
+            }
+            this.#database.prepare('UPDATE sessions SET archived_at = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(archived ? now() : null, now(), sessionId);
+            return this.getSession(projectId, sessionId);
+        });
+    }
+    /**
+     * 02A `SessionSnapshot`, bounded to the Session's live objects per 07 §163. It answered five fields
+     * of the thirteen and named the revision `revision` instead of `state_revision`, so the Trace tab
+     * read `snapshot.steps` and the Runs tab read `snapshot.agent_sessions` off `undefined` -- both threw
+     * during render, and with one boundary around the whole workbench that blanked the window.
+     *
+     * `messages` and `context_items` are still absent. 07 §163 bounds this to non-terminal run objects
+     * and names neither, and a Session's transcript is unbounded and already paged by its own Routes;
+     * sending it on every panel poll would be the opposite of a bounded read. Returning `[]` instead
+     * would be worse than omitting them -- it would assert there are none.
+     */
+    sessionSnapshot(projectId, sessionId) {
+        const session = this.getSession(projectId, sessionId);
+        const agents = this.listAgents(projectId, 'session_id', sessionId);
+        const agentIds = agents.map((entry) => stringField(entry.id));
+        // The Snapshot feeds the Session side panel, which renders the same `RunSummary` and `CallSummary`
+        // the paged Routes return -- so it projects them the same way. Raw rows here meant that panel read
+        // `requested_capability` and `status` off records that never carried either.
+        //
+        // The window is the most recent Runs, not the non-terminal ones. 07 §163 requires this read to be
+        // bounded and reserves *non-terminal only* for the global Snapshot; bounding a Session's own
+        // Snapshot the same way made the Trace and Runs tabs empty for every Session that had finished,
+        // which is almost all of them -- a Session with four Runs reported none. A most-recent-N window is
+        // bounded and is the thing those tabs exist to show.
+        const runs = this.#recentRuns(agentIds).map((run) => this.#runSummary(run));
+        const runIds = runs.map((run) => stringField(run.id));
+        const steps = this.#in('steps', 'run_id', runIds, 'ordinal').map((step) => this.#stepRuntime(step));
+        const stepIds = steps.map((step) => stringField(step.step_id));
+        // Calls of the windowed Steps, plus any Call still waiting: a Call that needs the user must surface
+        // even when its Step has aged out of the window.
+        const calls = this.#callSummaries(dedupeById([
+            ...this.#in('calls', 'step_id', stepIds, 'call_ordinal'),
+            ...agentIds.flatMap((agentId) => this.#all('SELECT * FROM calls WHERE agent_id = ? AND state != \'TERMINAL\' ORDER BY updated_at DESC', agentId).map(doc))
+        ]));
+        return {
+            state_revision: String(this.stateRevision()),
+            session,
+            agents,
+            agent_sessions: agents.map((agent) => this.#agentRuntime(agent)),
+            pending_messages: this.#in('pending_messages', 'agent_id', agentIds, 'ordinal'),
+            runs,
+            steps,
+            model_attempts: this.#in('model_attempts', 'step_id', stepIds, 'sequence'),
+            partitions: this.#in('call_partitions', 'step_id', stepIds, 'ordinal'),
+            calls,
+            attention: attentionItems(calls)
+        };
+    }
+    /**
+     * 02A `StepRuntimeSummary`. `status` is the documented projection of `state`/`outcome`, the same
+     * split `RunSummary.status` makes. `stream_closed` has no column and is derived: a Step is still
+     * streaming only while it is `RUNNING`. `reactive_compaction_attempted`, `assistant_message_id` and
+     * `ended_at` have no storage at all, so they report `false`/`null` rather than a fabricated value,
+     * and `revision` is null because `steps` carries no revision column to report.
+     */
+    #stepRuntime(step) {
+        const state = step.state ?? null;
+        const outcome = typeof step.outcome === 'string' ? step.outcome : null;
+        const terminal = {
+            success: 'COMPLETED', failed: 'FAILED', cancelled: 'CANCELLED', interrupted: 'INTERRUPTED'
+        };
+        return {
+            ...step,
+            step_id: step.id ?? null,
+            run_id: step.run_id ?? null,
+            step_ordinal: step.ordinal ?? 0,
+            state,
+            outcome,
+            status: state === 'TERMINAL'
+                ? terminal[outcome ?? ''] ?? 'FAILED'
+                : state === 'WAITING' ? 'WAITING_CALLS' : 'MODEL_STREAMING',
+            stream_closed: state !== 'RUNNING',
+            reactive_compaction_attempted: false,
+            assistant_message_id: null,
+            ended_at: null,
+            error_code: step.error_code ?? null,
+            revision: null
+        };
+    }
+    /**
+     * The Session's most recent Runs, oldest first so the panel can number Steps in order. Bounded by
+     * `SNAPSHOT_RUN_LIMIT`: a Session can accumulate Runs without limit, and this is read on every panel
+     * poll, so the whole history cannot be the answer. Older Runs remain on the paged Route.
+     */
+    #recentRuns(agentIds) {
+        if (agentIds.length === 0)
+            return [];
+        const placeholders = agentIds.map(() => '?').join(', ');
+        return this.#all(`SELECT * FROM runs WHERE agent_id IN (${placeholders}) ORDER BY created_at DESC, id DESC LIMIT ?`, ...agentIds, SNAPSHOT_RUN_LIMIT).map(doc).reverse();
+    }
+    /** Rows of one table whose `column` is in `keys`, ordered by `order` then `id`. */
+    #in(table, column, keys, order) {
+        if (keys.length === 0)
+            return [];
+        return this.#all(`SELECT * FROM ${table} WHERE ${column} IN (${keys.map(() => '?').join(', ')}) ORDER BY ${order}, id`, ...keys).map(doc);
+    }
+    sessionTimeline(projectId, sessionId, options) {
+        this.getSession(projectId, sessionId);
+        return this.#page(`
+      SELECT 'message' AS entity_type, m.id, m.created_at, m.role AS state, m.content
+      FROM messages m JOIN agents a ON a.id = m.agent_id WHERE a.session_id = ?
+      UNION ALL
+      SELECT 'run' AS entity_type, r.id, r.created_at, r.state, NULL AS content
+      FROM runs r JOIN agents a ON a.id = r.agent_id WHERE a.session_id = ?
+    `, [sessionId, sessionId], options, 'created_at DESC, id DESC');
+    }
+    listAgents(projectId, field, ownerId) {
+        if (field === 'task_id')
+            this.getTask(projectId, ownerId);
+        else
+            this.getSession(projectId, ownerId);
+        return this.#all(`SELECT * FROM agents WHERE ${field} = ? ORDER BY created_at, id`, ownerId).map((row) => this.#agent(row));
+    }
+    getAgent(projectId, agentId) {
+        const row = this.#require('agents', agentId);
+        this.#ownedTask(String(row.task_id), projectId);
+        return this.#agent(row);
+    }
+    createAgent(projectId, input) {
+        const agentId = id('agent');
+        const timestamp = now();
+        return this.#write(projectId, refs(['agent', agentId]), () => {
+            return this.#insertAgent(projectId, agentId, input, timestamp);
+        });
+    }
+    createSubagent(projectId, parentAgentId, input) {
+        const replay = input.ingress === undefined ? null : this.#ingressReplay(input.ingress);
+        if (replay !== null)
+            return replay;
+        if (input.forkContext === 'none' && input.initialPrompt === undefined && input.initialMessage === undefined) {
+            fail('SUBAGENT_INPUT_REQUIRED', 422, 'A Subagent without forked Context requires initial input.');
+        }
+        if (input.forkContext === 'compact' && input.compactSummary === undefined)
+            fail('COMPACTION_FAILED', 502, 'Compact Subagent creation requires a summary.');
+        const parent = this.getAgent(projectId, parentAgentId);
+        const agentId = id('agent');
+        const queuedIds = input.initialMessage === undefined ? null : messageIdsForWrite();
+        const initialRunId = queuedIds === null ? id('run') : null;
+        const changes = [
+            ['agent', agentId],
+            ...(initialRunId === null ? [] : [['run', initialRunId]]),
+            ...(queuedIds === null ? [] : messageRefs(queuedIds))
+        ];
+        return this.#write(projectId, refs(...changes), () => {
+            const timestamp = now();
+            this.#insertAgent(projectId, agentId, {
+                taskId: stringField(parent.task_id),
+                sessionId: stringField(parent.session_id),
+                workspaceId: stringField(parent.workspace_id),
+                parentAgentId,
+                name: input.name,
+                model: input.model,
+                modelReasoningEffort: input.modelReasoningEffort,
+                policyPreset: input.policyPreset,
+                capabilities: input.capabilities,
+                loadedCapabilities: input.loadedCapabilities
+            }, timestamp);
+            if (input.forkContext === 'full') {
+                const boundary = this.#database.prepare(`SELECT MAX(ordinal) AS ordinal FROM context_items WHERE agent_id = ? AND turn_group_id IN (SELECT id FROM context_turn_groups WHERE agent_id = ? AND state = 'COMPLETE')`).get(parentAgentId, parentAgentId);
+                if (boundary.ordinal !== null)
+                    this.#copyContextRange(parentAgentId, agentId, Number(boundary.ordinal), timestamp);
+            }
+            else if (input.forkContext === 'compact' && input.compactSummary !== undefined) {
+                this.#insertStandaloneContextMessage(agentId, 'system', input.compactSummary, 'compaction', timestamp);
+            }
+            if (input.initialPrompt !== undefined)
+                this.#insertStandaloneContextMessage(agentId, 'system', input.initialPrompt, 'message', timestamp);
+            const queued = queuedIds === null || input.initialMessage === undefined
+                ? null
+                : this.#insertQueuedMessage(projectId, agentId, input.initialMessage, parentAgentId, queuedIds, timestamp);
+            let run = queued?.run;
+            if (run === undefined) {
+                this.#database.prepare(`INSERT INTO runs(id, agent_id, goal_message_ids_json, initial_step_pending, state, outcome, error_code, revision, created_at, updated_at) VALUES (?, ?, '[]', 1, 'READY', NULL, NULL, 0, ?, ?)`)
+                    .run(initialRunId, agentId, timestamp, timestamp);
+                run = doc(this.#require('runs', String(initialRunId)));
+            }
+            else {
+                this.#database.prepare('UPDATE runs SET initial_step_pending = 1, revision = revision + 1, updated_at = ? WHERE id = ?')
+                    .run(timestamp, run.id);
+                run = doc(this.#require('runs', stringField(run.id)));
+            }
+            const response = { agent: this.getAgent(projectId, agentId), message: queued?.message ?? null, pending: queued?.pending ?? null, run };
+            if (input.ingress !== undefined)
+                this.#recordIngress(input.ingress, response);
+            return response;
+        });
+    }
+    updateAgent(projectId, agentId, expectedRevision, input) {
+        return this.#write(projectId, refs(['agent', agentId]), () => {
+            const current = this.#require('agents', agentId);
+            this.#ownedTask(String(current.task_id), projectId);
+            this.#expect(current, expectedRevision);
+            if (String(current.state) !== 'IDLE')
+                fail('AGENT_BUSY', 409, 'The Agent must be idle before its configuration changes.');
+            this.#database.prepare('UPDATE agents SET name = ?, model = ?, model_reasoning_effort = ?, policy_preset = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(input.name, input.model, input.modelReasoningEffort, input.policyPreset, now(), agentId);
+            return this.getAgent(projectId, agentId);
+        });
+    }
+    setAgentState(projectId, agentId, state) {
+        return this.#write(projectId, refs(['agent', agentId]), () => {
+            this.getAgent(projectId, agentId);
+            this.#database.prepare('UPDATE agents SET state = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(state, now(), agentId);
+            return this.getAgent(projectId, agentId);
+        });
+    }
+    getMessage(projectId, messageId) {
+        const row = this.#require('messages', messageId);
+        this.#ownedAgent(String(row.agent_id), projectId);
+        return this.#message(doc(row));
+    }
+    /**
+     * 02A `MessageDocument`. The column is `content` but the documented body field is `body_text`,
+     * which is what a client renders, so message bodies arrived under a name nobody reads. `origin`
+     * distinguishes a model turn from a user turn and from one Agent writing to another; it is
+     * derived from the role and `source_agent_id` rather than stored.
+     */
+    #message(message) {
+        const role = stringField(message.role);
+        const fromAgent = typeof message.source_agent_id === 'string';
+        return {
+            ...message,
+            body_text: typeof message.content === 'string' ? message.content : '',
+            origin: fromAgent ? 'agent' : role === 'assistant' ? 'llm' : role === 'system' ? 'system' : role === 'tool' ? 'agent' : 'user',
+            origin_agent_id: typeof message.source_agent_id === 'string' ? message.source_agent_id : null,
+            // No column carries structured model output yet; `null` says so rather than reusing metadata.
+            structured: null
+        };
+    }
+    enqueueMessage(projectId, agentId, content, sourceAgentId, ingress) {
+        const replay = ingress === undefined ? null : this.#ingressReplay(ingress);
+        if (replay !== null)
+            return messageIngressResponse(replay);
+        const ids = messageIdsForWrite(this.#activeRunId(agentId));
+        const timestamp = now();
+        return this.#write(projectId, refs(...messageRefs(ids)), () => {
+            const response = this.#insertQueuedMessage(projectId, agentId, content, sourceAgentId, ids, timestamp);
+            if (ingress !== undefined)
+                this.#recordIngress(ingress, response);
+            return response;
+        });
+    }
+    enqueueSubagentMessage(projectId, parentAgentId, targetAgentId, content, ingress) {
+        const replay = this.#ingressReplay(ingress);
+        if (replay !== null)
+            return replay;
+        const ids = messageIdsForWrite(this.#activeRunId(targetAgentId));
+        return this.#write(projectId, refs(...messageRefs(ids)), () => {
+            const target = this.#require('agents', targetAgentId);
+            this.#ownedAgent(parentAgentId, projectId);
+            if (target.parent_agent_id !== parentAgentId)
+                fail('AGENT_NOT_FOUND', 404, 'The target is not a direct child Agent.');
+            const response = this.#insertQueuedMessage(projectId, targetAgentId, content, parentAgentId, ids, now());
+            this.#recordIngress(ingress, response);
+            return response;
+        });
+    }
+    broadcastSubagentMessage(projectId, parentAgentId, content, ingress) {
+        const replay = this.#ingressReplay(ingress);
+        if (replay !== null)
+            return replay;
+        const parent = this.getAgent(projectId, parentAgentId);
+        const targets = this.listAgents(projectId, 'task_id', stringField(parent.task_id)).filter((entry) => entry.parent_agent_id === parentAgentId);
+        const messages = targets.map((target) => {
+            const targetId = stringField(target.id);
+            return { targetId, ids: messageIdsForWrite(this.#activeRunId(targetId)) };
+        });
+        return this.#write(projectId, refs(...messages.flatMap((entry) => messageRefs(entry.ids))), () => {
+            const timestamp = now();
+            const response = {
+                messages: messages.map((entry) => this.#insertQueuedMessage(projectId, entry.targetId, content, parentAgentId, entry.ids, timestamp).message)
+            };
+            this.#recordIngress(ingress, response);
+            return response;
+        });
+    }
+    async waitForSubagent(projectId, sourceAgentId, targetAgentId, timeoutMs, signal) {
+        const source = this.getAgent(projectId, sourceAgentId);
+        const target = this.getAgent(projectId, targetAgentId);
+        if (source.task_id !== target.task_id || target.parent_agent_id === null)
+            fail('SUBAGENT_TARGET_INVALID', 400, 'The target must be a Subagent in the same Task.');
+        const deadline = Date.now() + Math.min(timeoutMs, 120000);
+        for (;;) {
+            signal.throwIfAborted();
+            const pending = this.#database.prepare(`SELECT * FROM pending_messages WHERE agent_id = ? AND source_agent_id = ? ORDER BY ordinal, id LIMIT 1`)
+                .get(sourceAgentId, targetAgentId);
+            if (pending !== undefined) {
+                return {
+                    status: 'message',
+                    target_agent_id: targetAgentId,
+                    pending_message: doc(pending),
+                    message: this.getMessage(projectId, String(pending.message_id))
+                };
+            }
+            const activeRunIds = this.#all(`SELECT id FROM runs WHERE agent_id = ? AND state IN ('READY', 'RUNNING', 'WAITING') ORDER BY created_at, id`, targetAgentId)
+                .map((row) => String(row.id));
+            if (activeRunIds.length === 0)
+                return { status: 'completed', target_agent_id: targetAgentId, active_run_ids: [] };
+            if (Date.now() >= deadline)
+                fail('CALL_TIMEOUT', 408, 'The Subagent wait timed out.', { target_agent_id: targetAgentId });
+            await new Promise((resolve) => setTimeout(resolve, Math.min(50, Math.max(1, deadline - Date.now()))));
+        }
+    }
+    listPending(projectId, agentId, options) {
+        this.getAgent(projectId, agentId);
+        return this.#page('SELECT * FROM pending_messages WHERE agent_id = ?', [agentId], options, 'ordinal ASC, id ASC');
+    }
+    getPending(projectId, pendingId) {
+        const row = this.#require('pending_messages', pendingId);
+        this.#ownedAgent(String(row.agent_id), projectId);
+        return doc(row);
+    }
+    updatePending(projectId, pendingId, expectedRevision, content) {
+        const current = this.#require('pending_messages', pendingId);
+        const agentId = String(current.agent_id);
+        return this.#write(projectId, refs(['pending_message', pendingId]), () => {
+            this.#ownedAgent(agentId, projectId);
+            this.#expect(current, expectedRevision);
+            this.#database.prepare('UPDATE pending_messages SET content = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(content, now(), pendingId);
+            this.#database.prepare('UPDATE messages SET content = ? WHERE id = ?').run(content, current.message_id);
+            this.#database.prepare(`UPDATE context_items SET content = ?, revision = revision + 1, updated_at = ? WHERE agent_id = ? AND kind = 'message' AND source_id = ?`)
+                .run(content, now(), agentId, current.message_id);
+            this.#touchContext(agentId);
+            return this.getPending(projectId, pendingId);
+        });
+    }
+    deletePending(projectId, pendingId, expectedRevision) {
+        const current = this.#require('pending_messages', pendingId);
+        const agentId = String(current.agent_id);
+        this.#write(projectId, refs(['pending_message', pendingId]), () => {
+            this.#ownedAgent(agentId, projectId);
+            this.#expect(current, expectedRevision);
+            const timestamp = now();
+            this.#database.prepare(`UPDATE context_turn_groups SET state = 'ABORTED', revision = revision + 1, completed_at = ? WHERE id IN (SELECT turn_group_id FROM context_items WHERE agent_id = ? AND kind = 'message' AND source_id = ?) AND state = 'OPEN'`)
+                .run(timestamp, agentId, current.message_id);
+            this.#database.prepare('DELETE FROM pending_messages WHERE id = ?').run(pendingId);
+            if (this.#count('SELECT COUNT(*) AS count FROM pending_messages WHERE agent_id = ?', agentId) === 0) {
+                this.#database.prepare(`UPDATE runs SET state = 'TERMINAL', outcome = 'cancelled', error_code = 'PENDING_DELETED', revision = revision + 1, updated_at = ? WHERE agent_id = ? AND state = 'READY' AND initial_step_pending = 0`)
+                    .run(timestamp, agentId);
+            }
+        });
+    }
+    reorderPending(projectId, agentId, ids) {
+        return this.#write(projectId, ids.map((entry) => ({ type: 'pending_message', id: entry })), () => {
+            this.getAgent(projectId, agentId);
+            const rows = this.#all('SELECT id FROM pending_messages WHERE agent_id = ? ORDER BY ordinal', agentId).map((row) => String(row.id));
+            if (rows.length !== ids.length || rows.some((entry) => !ids.includes(entry)))
+                fail('PENDING_SET_MISMATCH', 409, 'The pending Message set changed.');
+            const temporary = this.#database.prepare('UPDATE pending_messages SET ordinal = ?, revision = revision + 1, updated_at = ? WHERE id = ?');
+            ids.forEach((entry, ordinal) => temporary.run(ordinal + ids.length, now(), entry));
+            ids.forEach((entry, ordinal) => temporary.run(ordinal, now(), entry));
+            return this.#all('SELECT * FROM pending_messages WHERE agent_id = ? ORDER BY ordinal', agentId).map(doc);
+        });
+    }
+    listCapabilities(projectId, agentId) {
+        this.getAgent(projectId, agentId);
+        return this.#all(`
+      SELECT a.capability_id, a.policy, CASE WHEN l.capability_id IS NULL THEN 0 ELSE 1 END AS loaded
+      FROM capability_assignments a
+      LEFT JOIN capability_loads l ON l.agent_id = a.agent_id AND l.capability_id = a.capability_id
+      WHERE a.agent_id = ? ORDER BY a.capability_id
+    `, agentId).map(doc);
+    }
+    getCapabilityAssignment(projectId, agentId, capabilityId) {
+        this.getAgent(projectId, agentId);
+        const row = this.#database.prepare(`
+      SELECT a.capability_id, a.policy, CASE WHEN l.capability_id IS NULL THEN 0 ELSE 1 END AS loaded
+      FROM capability_assignments a
+      LEFT JOIN capability_loads l ON l.agent_id = a.agent_id AND l.capability_id = a.capability_id
+      WHERE a.agent_id = ? AND a.capability_id = ?
+    `).get(agentId, capabilityId);
+        if (row === undefined)
+            fail('CAPABILITY_NOT_ASSIGNED', 403, 'The Capability is not assigned to the Agent.');
+        return doc(row);
+    }
+    replaceCapabilities(projectId, agentId, capabilities, loadedCapabilities) {
+        return this.#write(projectId, refs(['agent', agentId]), () => {
+            const agent = this.#require('agents', agentId);
+            this.#ownedTask(String(agent.task_id), projectId);
+            if (String(agent.state) !== 'IDLE')
+                fail('AGENT_BUSY', 409, 'Capability assignment can only change while the Agent is idle.');
+            const parentCapabilities = agent.parent_agent_id === null
+                ? null
+                : new Set(this.#all('SELECT capability_id FROM capability_assignments WHERE agent_id = ?', agent.parent_agent_id).map((row) => String(row.capability_id)));
+            this.#database.prepare('DELETE FROM capability_assignments WHERE agent_id = ?').run(agentId);
+            const assign = this.#database.prepare('INSERT INTO capability_assignments(agent_id, capability_id, policy, assigned_at) VALUES (?, ?, ?, ?)');
+            const load = this.#database.prepare('INSERT INTO capability_loads(agent_id, capability_id, loaded_at) VALUES (?, ?, ?)');
+            const timestamp = now();
+            for (const [capabilityId, policy] of Object.entries(capabilities)) {
+                if (parentCapabilities !== null && !parentCapabilities.has(capabilityId))
+                    continue;
+                assign.run(agentId, capabilityId, policy, timestamp);
+                if (loadedCapabilities.includes(capabilityId))
+                    load.run(agentId, capabilityId, timestamp);
+            }
+            return this.listCapabilities(projectId, agentId);
+        });
+    }
+    setCapabilityLoaded(projectId, agentId, capabilityId, loaded) {
+        return this.#write(projectId, refs(['agent', agentId]), () => {
+            const agent = this.#require('agents', agentId);
+            this.#ownedTask(String(agent.task_id), projectId);
+            if (String(agent.state) !== 'IDLE')
+                fail('AGENT_BUSY', 409, 'Capabilities can only load while the Agent is idle.');
+            const assignment = this.#database.prepare('SELECT 1 FROM capability_assignments WHERE agent_id = ? AND capability_id = ?').get(agentId, capabilityId);
+            if (assignment === undefined)
+                fail('CAPABILITY_NOT_ASSIGNED', 409, 'The Capability is not assigned to the Agent.');
+            if (loaded)
+                this.#database.prepare('INSERT OR IGNORE INTO capability_loads(agent_id, capability_id, loaded_at) VALUES (?, ?, ?)').run(agentId, capabilityId, now());
+            else
+                this.#database.prepare('DELETE FROM capability_loads WHERE agent_id = ? AND capability_id = ?').run(agentId, capabilityId);
+            return this.listCapabilities(projectId, agentId);
+        });
+    }
+    loadCapabilities(projectId, agentId, capabilities) {
+        return this.#write(projectId, Object.keys(capabilities).map((capabilityId) => ({ type: 'capability_assignment', id: `${agentId}:${capabilityId}` })), () => {
+            this.getAgent(projectId, agentId);
+            const timestamp = now();
+            const load = this.#database.prepare('INSERT OR IGNORE INTO capability_loads(agent_id, capability_id, loaded_at) VALUES (?, ?, ?)');
+            for (const capabilityId of Object.keys(capabilities)) {
+                if (this.#database.prepare('SELECT 1 FROM capability_assignments WHERE agent_id = ? AND capability_id = ?').get(agentId, capabilityId) === undefined) {
+                    fail('CAPABILITY_NOT_ASSIGNED', 403, 'The Capability is not assigned to the Agent.');
+                }
+                load.run(agentId, capabilityId, timestamp);
+            }
+            return this.listCapabilities(projectId, agentId);
+        });
+    }
+    listRuns(projectId, agentId, options) {
+        this.getAgent(projectId, agentId);
+        const page = this.#page('SELECT * FROM runs WHERE agent_id = ?', [agentId], options);
+        return { ...page, items: page.items.map((run) => this.#runSummary(run)) };
+    }
+    /** 02A `RunDetail`. */
+    runDetail(projectId, runId) {
+        const row = this.#require('runs', runId);
+        const agentId = String(row.agent_id);
+        this.#ownedAgent(agentId, projectId);
+        const agent = this.getAgent(projectId, agentId);
+        const activeStep = this.#all(`SELECT id FROM steps WHERE run_id = ? AND state <> 'TERMINAL' ORDER BY created_at DESC, id DESC LIMIT 1`, runId)[0];
+        const run = this.#runSummary(doc(row));
+        return {
+            run,
+            agent_id: agentId,
+            session: this.#agentRuntime(agent),
+            active_step_id: activeStep === undefined ? null : String(activeStep.id),
+            error: typeof run.error_code === 'string'
+                ? { code: run.error_code, message: typeof run.error_message === 'string' ? run.error_message : run.error_code }
+                : null,
+            state_revision: String(this.stateRevision())
+        };
+    }
+    getRun(projectId, runId) {
+        const row = this.#require('runs', runId);
+        this.#ownedAgent(String(row.agent_id), projectId);
+        return this.#runSummary(doc(row));
+    }
+    getRunGoal(projectId, runId) {
+        const run = this.#require('runs', runId);
+        this.#ownedAgent(String(run.agent_id), projectId);
+        const ids = strings(parseJson(String(run.goal_message_ids_json)));
+        if (ids.length > 0) {
+            const messages = ids.map((messageId) => this.getMessage(projectId, messageId));
+            return { message_ids: ids, content: messages.map((message) => stringField(message.content)).join('\n\n') };
+        }
+        const context = this.#database.prepare('SELECT * FROM context_items WHERE agent_id = ? AND visible = 1 ORDER BY ordinal DESC LIMIT 1').get(run.agent_id);
+        return context === undefined ? { content: '' } : doc(context);
+    }
+    retryAgent(projectId, agentId) {
+        const previous = this.#database.prepare(`SELECT * FROM runs WHERE agent_id = ? AND state = 'TERMINAL' ORDER BY created_at DESC, id DESC LIMIT 1`).get(agentId);
+        if (previous === undefined)
+            fail('RUN_NOT_FOUND', 404, 'The Agent has no terminal Run to retry.');
+        this.getAgent(projectId, agentId);
+        if (previous.outcome !== 'failed' || previous.error_code !== 'COMPACTION_FAILED')
+            fail('RUN_NOT_RETRYABLE', 409, 'Only the latest Compaction failure can be retried.');
+        if (this.#activeRunId(agentId) !== undefined)
+            fail('AGENT_BUSY', 409, 'The Agent already has an active Run.');
+        const runId = id('run');
+        const timestamp = now();
+        return this.#write(projectId, refs(['run', runId]), () => {
+            const initialStepPending = this.#count('SELECT COUNT(*) AS count FROM pending_messages WHERE agent_id = ?', agentId) === 0 ? 1 : 0;
+            this.#database.prepare(`INSERT INTO runs(id, agent_id, goal_message_ids_json, initial_step_pending, state, outcome, error_code, revision, created_at, updated_at) VALUES (?, ?, ?, ?, 'READY', NULL, NULL, 0, ?, ?)`)
+                .run(runId, agentId, previous.goal_message_ids_json, initialStepPending, timestamp, timestamp);
+            return this.getRun(projectId, runId);
+        });
+    }
+    claimRun(projectId, agentId) {
+        const ready = this.#database.prepare(`
+      SELECT * FROM runs WHERE agent_id = ? AND state = 'READY'
+      AND (initial_step_pending = 1 OR EXISTS (SELECT 1 FROM pending_messages WHERE pending_messages.agent_id = runs.agent_id))
+      ORDER BY created_at, id LIMIT 1
+    `).get(agentId);
+        if (ready === undefined)
+            return null;
+        const runId = String(ready.id);
+        const stepId = id('step');
+        const pending = this.#all('SELECT * FROM pending_messages WHERE agent_id = ? ORDER BY ordinal, id', agentId);
+        return this.#write(projectId, refs(['run', runId], ['step', stepId], ['agent', agentId]), () => {
+            const timestamp = now();
+            let turnGroupId;
+            if (pending.length === 0) {
+                turnGroupId = id('turn');
+                this.#insertTurnGroup(turnGroupId, agentId, 'turn', 'OPEN', timestamp);
+            }
+            else {
+                const items = pending.map((entry) => this.#one(`SELECT * FROM context_items WHERE agent_id = ? AND kind = 'message' AND source_id = ? ORDER BY ordinal DESC LIMIT 1`, agentId, entry.message_id));
+                turnGroupId = String(items[0]?.turn_group_id);
+                items.forEach((item, ordinal) => {
+                    const sourceGroupId = String(item.turn_group_id);
+                    this.#database.prepare('UPDATE context_items SET turn_group_id = ?, turn_group_ordinal = ? WHERE id = ?').run(turnGroupId, ordinal, item.id);
+                    if (sourceGroupId !== turnGroupId)
+                        this.#database.prepare('DELETE FROM context_turn_groups WHERE id = ?').run(sourceGroupId);
+                });
+            }
+            const goals = strings(parseJson(String(ready.goal_message_ids_json)));
+            const goalMessageIds = [...new Set([...goals, ...pending.map((entry) => String(entry.message_id))])];
+            const update = this.#database.prepare(`UPDATE runs SET state = 'RUNNING', goal_message_ids_json = ?, initial_step_pending = 0, revision = revision + 1, updated_at = ? WHERE id = ? AND state = 'READY'`)
+                .run(json(goalMessageIds), timestamp, runId);
+            if (update.changes !== 1)
+                fail('RUN_STATE_CONFLICT', 409, 'The Run is no longer ready.');
+            const ordinal = this.#nextOrdinal('steps', 'run_id', runId);
+            this.#database.prepare(`INSERT INTO steps(id, run_id, turn_group_id, ordinal, state, outcome, error_code, created_at, updated_at) VALUES (?, ?, ?, ?, 'RUNNING', NULL, NULL, ?, ?)`)
+                .run(stepId, runId, turnGroupId, ordinal, timestamp, timestamp);
+            this.#database.prepare(`UPDATE agents SET state = 'RUNNING', revision = revision + 1, updated_at = ? WHERE id = ?`).run(timestamp, agentId);
+            return { run: this.getRun(projectId, runId), step: doc(this.#require('steps', stepId)), pending: pending.map(doc) };
+        });
+    }
+    consumePending(projectId, pendingId) {
+        const pending = this.#require('pending_messages', pendingId);
+        const agentId = String(pending.agent_id);
+        this.#write(projectId, refs(['pending_message', pendingId]), () => {
+            this.#ownedAgent(agentId, projectId);
+            this.#database.prepare('DELETE FROM pending_messages WHERE id = ?').run(pendingId);
+        });
+    }
+    restorePending(projectId, pending) {
+        const pendingId = stringField(pending.id);
+        const agentId = stringField(pending.agent_id);
+        return this.#write(projectId, refs(['pending_message', pendingId]), () => {
+            this.#ownedAgent(agentId, projectId);
+            const existing = this.#database.prepare('SELECT * FROM pending_messages WHERE id = ?').get(pendingId);
+            if (existing !== undefined)
+                return doc(existing);
+            const rows = this.#all('SELECT id, ordinal FROM pending_messages WHERE agent_id = ? ORDER BY ordinal DESC', agentId);
+            const shift = this.#database.prepare('UPDATE pending_messages SET ordinal = ordinal + 1, revision = revision + 1, updated_at = ? WHERE id = ?');
+            const timestamp = now();
+            for (const row of rows)
+                shift.run(timestamp, row.id);
+            this.#database.prepare(`INSERT INTO pending_messages(id, agent_id, message_id, source_agent_id, content, ordinal, revision, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 0, ?, ?, ?)`)
+                .run(pendingId, agentId, stringField(pending.message_id), pending.source_agent_id ?? null, stringField(pending.content), Number(pending.revision ?? 0) + 1, stringField(pending.created_at), timestamp);
+            return doc(this.#require('pending_messages', pendingId));
+        });
+    }
+    getStep(projectId, stepId) {
+        const row = this.#require('steps', stepId);
+        const run = this.#require('runs', String(row.run_id));
+        this.#ownedAgent(String(run.agent_id), projectId);
+        return doc(row);
+    }
+    listSteps(projectId, runId, options) {
+        this.getRun(projectId, runId);
+        return this.#page('SELECT * FROM steps WHERE run_id = ?', [runId], options, 'ordinal DESC, id DESC');
+    }
+    createAttempt(projectId, input) {
+        const attemptId = id('attempt');
+        const timestamp = now();
+        return this.#write(projectId, refs(['model_attempt', attemptId]), () => {
+            const agent = this.#require('agents', input.agentId);
+            this.#ownedTask(String(agent.task_id), projectId);
+            if (input.stepId !== null)
+                this.getStep(projectId, input.stepId);
+            const sequence = this.#count('SELECT COUNT(*) AS count FROM model_attempts WHERE agent_id = ? AND kind = ?', input.agentId, input.kind);
+            this.#database.prepare(`INSERT INTO model_attempts(id, agent_id, step_id, kind, sequence, model, state, outcome, profile_id, profile_version, profile_digest, config_digest, context_revision, request_digest, preparation_json, usage_json, error_code, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, 'PREPARED', NULL, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?)`)
+                .run(attemptId, input.agentId, input.stepId, input.kind, sequence, input.model, input.profileId, input.profileVersion, input.profileDigest, input.configDigest, input.contextRevision, digest(input.request), json(input.preparation), timestamp, timestamp);
+            const statement = this.#database.prepare('INSERT INTO attempt_capabilities(attempt_id, ordinal, capability_id, schema_json) VALUES (?, ?, ?, ?)');
+            input.capabilities.forEach((entry, ordinal) => statement.run(attemptId, ordinal, entry.id, json(entry.schema)));
+            return this.getAttempt(projectId, attemptId);
+        });
+    }
+    getAttempt(projectId, attemptId) {
+        const row = this.#require('model_attempts', attemptId);
+        this.#ownedAgent(String(row.agent_id), projectId);
+        return { ...doc(row), capabilities: this.#all('SELECT ordinal, capability_id, schema_json FROM attempt_capabilities WHERE attempt_id = ? ORDER BY ordinal', attemptId).map(doc) };
+    }
+    listAttempts(projectId, field, ownerId, options) {
+        if (field === 'agent_id')
+            this.getAgent(projectId, ownerId);
+        else
+            this.getStep(projectId, ownerId);
+        return this.#page(`SELECT * FROM model_attempts WHERE ${field} = ?`, [ownerId], options, 'sequence DESC, id DESC');
+    }
+    transitionAttempt(projectId, attemptId, from, to, outcome = null, usage = null, errorCode = null) {
+        return this.#write(projectId, refs(['model_attempt', attemptId]), () => {
+            const current = this.#require('model_attempts', attemptId);
+            this.#ownedAgent(String(current.agent_id), projectId);
+            const result = this.#database.prepare('UPDATE model_attempts SET state = ?, outcome = ?, usage_json = ?, error_code = ?, updated_at = ? WHERE id = ? AND state = ?')
+                .run(to, outcome, usage === null ? null : json(usage), errorCode, now(), attemptId, from);
+            if (result.changes !== 1)
+                fail('ATTEMPT_STATE_CONFLICT', 409, 'The ModelAttempt state changed.');
+            return this.getAttempt(projectId, attemptId);
+        });
+    }
+    recordToolOrdinal(projectId, attemptId, ordinal, providerToolId, complete) {
+        this.#write(projectId, refs(['model_attempt', attemptId]), () => {
+            this.getAttempt(projectId, attemptId);
+            this.#database.prepare(`INSERT INTO attempt_tool_ordinals(attempt_id, ordinal, provider_tool_id, complete) VALUES (?, ?, ?, ?) ON CONFLICT(attempt_id, ordinal) DO UPDATE SET provider_tool_id = excluded.provider_tool_id, complete = excluded.complete`)
+                .run(attemptId, ordinal, providerToolId, complete ? 1 : 0);
+        });
+    }
+    createPartition(projectId, stepId, mode) {
+        const partitionId = id('partition');
+        return this.#write(projectId, refs(['call_partition', partitionId]), () => {
+            this.getStep(projectId, stepId);
+            const ordinal = this.#nextOrdinal('call_partitions', 'step_id', stepId);
+            this.#database.prepare('INSERT INTO call_partitions(id, step_id, ordinal, mode, created_at) VALUES (?, ?, ?, ?, ?)')
+                .run(partitionId, stepId, ordinal, mode, now());
+            return doc(this.#require('call_partitions', partitionId));
+        });
+    }
+    listPartitions(projectId, stepId, options) {
+        this.getStep(projectId, stepId);
+        return this.#page('SELECT * FROM call_partitions WHERE step_id = ?', [stepId], options, 'ordinal ASC, id ASC');
+    }
+    createCall(projectId, input) {
+        const replay = input.ingress === undefined ? null : this.#ingressReplay(input.ingress);
+        if (replay !== null)
+            return replay;
+        const callId = id('call');
+        const timestamp = now();
+        return this.#write(projectId, refs(['call', callId]), () => {
+            this.getWorkspace(projectId, input.workspaceId);
+            if (input.agentId !== undefined)
+                this.getAgent(projectId, input.agentId);
+            if (input.stepId !== undefined)
+                this.getStep(projectId, input.stepId);
+            if (input.attemptId !== undefined)
+                this.getAttempt(projectId, input.attemptId);
+            this.#database.prepare(`INSERT INTO calls(id, project_id, workspace_id, agent_id, step_id, attempt_id, partition_id, parent_call_id, source, capability_id, provider_call_id, call_ordinal, input_json, effect, policy, state, wait_reason, outcome, outcome_unknown, auto_review_passed, revision, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, 0, ?, 0, ?, ?)`)
+                .run(callId, projectId, input.workspaceId, input.agentId ?? null, input.stepId ?? null, input.attemptId ?? null, input.partitionId ?? null, input.parentCallId ?? null, input.source, input.capabilityId, input.providerCallId ?? null, input.callOrdinal ?? null, json(input.arguments), input.effect, input.policy ?? null, input.state, input.waitReason ?? null, input.autoReviewPassed === undefined ? null : input.autoReviewPassed ? 1 : 0, timestamp, timestamp);
+            const call = this.getCall(projectId, callId);
+            if (input.ingress !== undefined)
+                this.#recordIngress(input.ingress, call);
+            return call;
+        });
+    }
+    /**
+     * The stored Call row plus its Result, as the Runtime reads it: flat, physical column names,
+     * `state` and `outcome` separate. Every scheduling and dispatch path in `src/runtime` switches on
+     * this shape, so it is deliberately not the documented wire shape -- see `callDetail` and
+     * `callSummary` for those.
+     */
+    getCall(projectId, callId) {
+        const call = this.#callRow(projectId, callId);
+        const result = this.#database.prepare('SELECT * FROM results WHERE call_id = ?').get(callId);
+        return { ...call, result: result === undefined ? null : doc(result) };
+    }
+    #callRow(projectId, callId) {
+        const row = this.#require('calls', callId);
+        owned(row, 'project_id', projectId);
+        return doc(row);
+    }
+    /** 02A `CallSummary` for one Call. */
+    callSummary(projectId, callId) {
+        const call = this.#callRow(projectId, callId);
+        return this.#callSummaries([call])[0] ?? call;
+    }
+    /**
+     * 02A `CallDetail`. `concurrency` is absent rather than invented: resource claims live only in the
+     * in-process scheduler (`runtime/scheduler.ts`) and are never persisted, so the Store cannot say
+     * whether a Call was judged concurrency-safe. Reporting `{ safe: true, claims: [] }` would be a
+     * claim no code made.
+     */
+    callDetail(projectId, callId) {
+        const call = this.#callRow(projectId, callId);
+        const result = this.#database.prepare('SELECT id FROM results WHERE call_id = ?').get(callId);
+        const summary = this.#callSummaries([call])[0] ?? {};
+        const input = jsonRecord(call.input);
+        return {
+            id: call.id ?? null,
+            call_id: call.id ?? null,
+            summary,
+            provider_call_id: call.provider_call_id ?? null,
+            // `input_json` holds the arguments directly, except once a user answer has been merged in, when
+            // it becomes `{ arguments, answer }` -- the same test `answerCall` makes before rewriting it.
+            arguments: input !== null && 'arguments' in input ? input.arguments ?? null : call.input ?? null,
+            user_prompt: summary.user_prompt ?? null,
+            result_id: result === undefined ? null : String(result.id),
+            agent_id: call.agent_id ?? null
+        };
+    }
+    /**
+     * 02A `CallSummary`. The stored row uses physical column names and splits the lifecycle across
+     * `state`, `wait_reason` and `outcome`; the documented Summary renames `effect`/`policy` to
+     * `effect_scope`/`policy_value` and adds `legacy_state` as the single projection older clients
+     * switch on. `arguments` is deliberately not here -- it belongs to `CallDetail`, and a page of a
+     * hundred Calls carrying every argument object is payload nothing listing them reads.
+     *
+     * `requested_capability` and `capability_id` are one column: nothing records a
+     * requested-but-unresolved Capability, so both project the stored value instead of one of them
+     * guessing. `yielded_at` has no column at all, so it stays null and `legacy_state` never reports
+     * `YIELDED`.
+     */
+    #callSummary(call, partition, result) {
+        const capability = call.capability_id ?? null;
+        return {
+            id: call.id ?? null,
+            call_id: call.id ?? null,
+            project_id: call.project_id ?? null,
+            source: call.source ?? null,
+            workspace_id: call.workspace_id ?? null,
+            agent_id: call.agent_id ?? null,
+            step_id: call.step_id ?? null,
+            attempt_id: call.attempt_id ?? null,
+            partition_id: call.partition_id ?? null,
+            partition_ordinal: partition?.ordinal ?? null,
+            partition_kind: partition?.mode ?? null,
+            call_ordinal: call.call_ordinal ?? null,
+            requested_capability: capability,
+            capability_id: capability,
+            policy_value: call.policy ?? null,
+            effect_scope: call.effect ?? null,
+            parent_call_id: call.parent_call_id ?? null,
+            state: call.state ?? null,
+            wait_reason: call.wait_reason ?? null,
+            legacy_state: legacyCallState(call),
+            auto_review_passed: call.auto_review_passed ?? null,
+            user_prompt: jsonRecord(jsonRecord(call.input)?.prompt),
+            outcome: call.outcome ?? null,
+            outcome_unknown: call.outcome_unknown === true,
+            yielded_at: null,
+            error_code: result?.error_code ?? null,
+            revision: call.revision ?? null,
+            created_at: call.created_at ?? null,
+            updated_at: call.updated_at ?? null
+        };
+    }
+    /**
+     * Two queries for a whole page rather than two per Call: `partition_ordinal`/`partition_kind` live
+     * on `call_partitions` and `error_code` on `results`, and both are documented `CallSummary` fields.
+     */
+    #callSummaries(calls) {
+        const partitions = this.#byId('call_partitions', 'id', ids(calls, 'partition_id'));
+        const results = this.#byId('results', 'call_id', ids(calls, 'id'));
+        return calls.map((call) => this.#callSummary(call, typeof call.partition_id === 'string' ? partitions.get(call.partition_id) ?? null : null, typeof call.id === 'string' ? results.get(call.id) ?? null : null));
+    }
+    #byId(table, column, keys) {
+        if (keys.length === 0)
+            return new Map();
+        const rows = this.#all(`SELECT * FROM ${table} WHERE ${column} IN (${keys.map(() => '?').join(', ')})`, ...keys);
+        return new Map(rows.map((row) => [String(row[column]), doc(row)]));
+    }
+    listCalls(projectId, options, filters = {}) {
+        this.getProject(projectId);
+        const clauses = ['project_id = ?'];
+        const parameters = [projectId];
+        if (filters.stepId !== undefined) {
+            clauses.push('step_id = ?');
+            parameters.push(filters.stepId);
+        }
+        if (filters.state !== undefined) {
+            clauses.push('state = ?');
+            parameters.push(filters.state);
+        }
+        const page = this.#page(`SELECT * FROM calls WHERE ${clauses.join(' AND ')}`, parameters, options);
+        return { ...page, items: this.#callSummaries(page.items) };
+    }
+    activeCallIds(projectId, agentId) {
+        this.getAgent(projectId, agentId);
+        return this.#all(`SELECT id FROM calls WHERE project_id = ? AND agent_id = ? AND state != 'TERMINAL' ORDER BY created_at`, projectId, agentId)
+            .map((row) => String(row.id));
+    }
+    queuedDirectCallIds(projectId) {
+        this.getProject(projectId);
+        return this.#all(`SELECT id FROM calls WHERE project_id = ? AND source = 'user' AND step_id IS NULL AND state = 'QUEUED' ORDER BY created_at, id`, projectId)
+            .map((row) => String(row.id));
+    }
+    hasActiveRuntimeObjects(projectId) {
+        this.getProject(projectId);
+        return this.#count(`SELECT COUNT(*) AS count FROM runs r JOIN agents a ON a.id = r.agent_id JOIN tasks t ON t.id = a.task_id WHERE t.project_id = ? AND r.state != 'TERMINAL'`, projectId) > 0
+            || this.#count(`SELECT COUNT(*) AS count FROM calls WHERE project_id = ? AND state != 'TERMINAL'`, projectId) > 0;
+    }
+    decideCall(projectId, callId, decision, expectedRevision) {
+        return this.#write(projectId, refs(['call', callId]), () => {
+            const current = this.#require('calls', callId);
+            owned(current, 'project_id', projectId);
+            if (expectedRevision !== undefined)
+                this.#expect(current, expectedRevision);
+            const state = String(current.state);
+            if (decision !== 'cancel') {
+                const prompt = jsonRecord(jsonRecord(parseJson(String(current.input_json)))?.prompt);
+                if (state !== 'WAITING' || current.wait_reason !== 'user_input' || prompt?.kind !== 'policy_approval') {
+                    fail('CALL_STATE_CONFLICT', 409, 'The Call is not waiting for a policy decision.');
+                }
+            }
+            if (decision === 'approve') {
+                this.#database.prepare(`UPDATE calls SET state = 'QUEUED', wait_reason = NULL, revision = revision + 1, updated_at = ? WHERE id = ?`).run(now(), callId);
+                return { call: this.getCall(projectId, callId), result: null };
+            }
+            if (state === 'TERMINAL')
+                fail('CALL_STATE_CONFLICT', 409, 'The Call is already terminal.');
+            const resultId = id('result');
+            const timestamp = now();
+            this.#database.prepare(`UPDATE calls SET state = 'TERMINAL', wait_reason = NULL, outcome = 'cancelled', outcome_unknown = CASE WHEN state = 'RUNNING' THEN 1 ELSE 0 END, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                .run(timestamp, callId);
+            this.#database.prepare(`INSERT INTO results(id, call_id, outcome, content_json, error_code, error_message, created_at) VALUES (?, ?, ?, '{}', ?, ?, ?)`)
+                .run(resultId, callId, 'cancelled', decision === 'reject' ? 'CALL_REJECTED' : 'CALL_CANCELLED', decision === 'reject' ? 'The user rejected the Call.' : 'The user cancelled the Call.', timestamp);
+            return { call: this.getCall(projectId, callId), result: doc(this.#require('results', resultId)) };
+        });
+    }
+    answerCall(projectId, callId, expectedRevision, answer) {
+        return this.#write(projectId, refs(['call', callId]), () => {
+            const current = this.#require('calls', callId);
+            owned(current, 'project_id', projectId);
+            this.#expect(current, expectedRevision);
+            if (current.state !== 'WAITING' || current.wait_reason !== 'user_input')
+                fail('CALL_STATE_CONFLICT', 409, 'The Call is not waiting for user input.');
+            const input = parseJson(String(current.input_json));
+            const prompt = jsonRecord(input)?.prompt;
+            validateAnswer(jsonRecord(prompt), answer);
+            if (jsonRecord(prompt)?.kind === 'policy_approval' && policyAnswer(answer) === 'reject') {
+                const resultId = id('result');
+                const timestamp = now();
+                this.#database.prepare(`UPDATE calls SET state = 'TERMINAL', wait_reason = NULL, outcome = 'cancelled', revision = revision + 1, updated_at = ? WHERE id = ?`).run(timestamp, callId);
+                this.#database.prepare(`INSERT INTO results(id, call_id, outcome, content_json, error_code, error_message, created_at) VALUES (?, ?, 'cancelled', '{}', 'CALL_REJECTED', 'The user rejected the Call.', ?)`)
+                    .run(resultId, callId, timestamp);
+                return { call: this.getCall(projectId, callId), result: doc(this.#require('results', resultId)) };
+            }
+            const nextInput = typeof input === 'object' && input !== null && !Array.isArray(input) && 'arguments' in input
+                ? { ...input, answer }
+                : { arguments: input, answer };
+            this.#database.prepare(`UPDATE calls SET input_json = ?, state = 'QUEUED', wait_reason = NULL, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                .run(json(nextInput), now(), callId);
+            return { call: this.getCall(projectId, callId), result: null };
+        });
+    }
+    reviewCall(projectId, callId, approved) {
+        return this.#write(projectId, refs(['call', callId]), () => {
+            const current = this.#require('calls', callId);
+            owned(current, 'project_id', projectId);
+            if (current.state !== 'WAITING' || current.wait_reason !== 'policy_review')
+                fail('CALL_STATE_CONFLICT', 409, 'The Call is not waiting for policy review.');
+            const input = parseJson(String(current.input_json));
+            this.#database.prepare(`UPDATE calls SET input_json = ?, state = ?, wait_reason = ?, auto_review_passed = ?, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                .run(approved ? json(input) : json({ arguments: input, prompt: policyPrompt(String(current.capability_id)) }), approved ? 'QUEUED' : 'WAITING', approved ? null : 'user_input', approved ? 1 : 0, now(), callId);
+            return this.getCall(projectId, callId);
+        });
+    }
+    startCall(projectId, callId) {
+        return this.#write(projectId, refs(['call', callId]), () => {
+            const result = this.#database.prepare(`UPDATE calls SET state = 'RUNNING', revision = revision + 1, updated_at = ? WHERE id = ? AND state = 'QUEUED'`).run(now(), callId);
+            if (result.changes !== 1)
+                fail('CALL_STATE_CONFLICT', 409, 'The Call is not queued.');
+            return this.getCall(projectId, callId);
+        });
+    }
+    waitCall(projectId, callId, prompt) {
+        return this.#write(projectId, refs(['call', callId]), () => {
+            const current = this.#require('calls', callId);
+            owned(current, 'project_id', projectId);
+            if (current.state !== 'RUNNING')
+                fail('CALL_STATE_CONFLICT', 409, 'Only a running Call can request user input.');
+            this.#database.prepare(`UPDATE calls SET state = 'WAITING', wait_reason = 'user_input', input_json = ?, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                .run(json({ arguments: parseJson(String(current.input_json)), prompt }), now(), callId);
+            return this.getCall(projectId, callId);
+        });
+    }
+    completeCall(projectId, callId, outcome, content, errorCode = null, errorMessage = null, artifacts = [], truncated = false) {
+        const resultId = id('result');
+        const timestamp = now();
+        return this.#write(projectId, refs(['call', callId], ['result', resultId]), () => {
+            const update = this.#database.prepare(`UPDATE calls SET state = 'TERMINAL', outcome = ?, outcome_unknown = 0, revision = revision + 1, updated_at = ? WHERE id = ? AND state = 'RUNNING'`)
+                .run(outcome, timestamp, callId);
+            if (update.changes !== 1)
+                fail('CALL_STATE_CONFLICT', 409, 'The Call is not running.');
+            this.#database.prepare(`INSERT INTO results(id, call_id, outcome, content_json, truncated, error_code, error_message, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(resultId, callId, outcome, json(content), truncated ? 1 : 0, errorCode, errorMessage, timestamp);
+            const link = this.#database.prepare('INSERT INTO result_artifacts(result_id, artifact_id) VALUES (?, ?)');
+            for (const artifactId of artifacts)
+                link.run(resultId, artifactId);
+            return { call: this.getCall(projectId, callId), result: doc(this.#require('results', resultId)) };
+        });
+    }
+    /**
+     * The stored Result plus its full Artifact rows, as `includeResult` reads it when it copies a
+     * Result into a Context. Not the wire shape -- see `resultDocument`.
+     */
+    getResult(projectId, resultId) {
+        const row = this.#require('results', resultId);
+        const call = this.#require('calls', String(row.call_id));
+        owned(call, 'project_id', projectId);
+        const artifacts = this.#all(`SELECT a.* FROM artifacts a JOIN result_artifacts ra ON ra.artifact_id = a.id WHERE ra.result_id = ? ORDER BY a.created_at, a.id`, resultId).map(doc);
+        return { ...doc(row), artifacts };
+    }
+    /**
+     * 02A `ResultDocument`. One `content_json` column becomes `text` or `structured` according to its
+     * JSON type, which is the same split `normalizeOutput` makes when it decides what to store: a
+     * Capability producing prose stores a string, one producing records stores an object or array, and
+     * either is `null` here when the payload was too large to inline and became an Artifact instead.
+     * That is why a client reading a large Result has to fall back to `artifact_ids` and ART-01.
+     *
+     * `error_code` stays off the wire here because the documented shape does not carry it; a failed
+     * Call reports its code on `CallSummary.error_code`.
+     */
+    resultDocument(projectId, resultId) {
+        const result = this.getResult(projectId, resultId);
+        const content = result.content ?? null;
+        const artifacts = Array.isArray(result.artifacts) ? result.artifacts : [];
+        return {
+            id: result.id ?? null,
+            result_id: result.id ?? null,
+            call_id: result.call_id ?? null,
+            outcome: result.outcome ?? null,
+            text: typeof content === 'string' ? content : null,
+            structured: typeof content === 'object' ? content : null,
+            artifact_ids: artifacts
+                .map((artifact) => jsonRecord(artifact)?.id)
+                .filter((value) => typeof value === 'string'),
+            truncated: result.truncated === true,
+            created_at: result.created_at ?? null
+        };
+    }
+    includeResult(projectId, resultId, agentId, expectedContextRevision) {
+        const result = this.getResult(projectId, resultId);
+        const contextId = id('context');
+        const turnGroupId = id('turn');
+        const timestamp = now();
+        return this.#write(projectId, refs(['turn_group', turnGroupId], ['context_item', contextId]), () => {
+            const agent = this.getAgent(projectId, agentId);
+            if (agent.context_revision !== expectedContextRevision)
+                fail('REVISION_CONFLICT', 409, 'The Context changed before this command was applied.');
+            const ordinal = this.#nextOrdinal('context_items', 'agent_id', agentId);
+            this.#insertTurnGroup(turnGroupId, agentId, 'included', 'COMPLETE', timestamp);
+            this.#database.prepare(`INSERT INTO context_items(id, agent_id, turn_group_id, turn_group_ordinal, kind, source_id, role, content, ordinal, visible, locked, revision, created_at, updated_at) VALUES (?, ?, ?, 0, 'result', ?, 'tool', ?, ?, 1, 0, 0, ?, ?)`)
+                .run(contextId, agentId, turnGroupId, resultId, json({ content: result.content ?? null, artifacts: result.artifacts ?? [], truncated: result.truncated === true }), ordinal, timestamp, timestamp);
+            this.#touchContext(agentId);
+            return this.getContextItem(projectId, contextId);
+        });
+    }
+    createArtifact(projectId, input) {
+        const existing = this.#database.prepare('SELECT * FROM artifacts WHERE project_id = ? AND sha256 = ? AND name = ? AND media_type = ?')
+            .get(projectId, input.sha256, input.name, input.mediaType);
+        if (existing !== undefined)
+            return doc(existing);
+        const artifactId = id('artifact');
+        return this.#write(projectId, refs(['artifact', artifactId]), () => {
+            this.getProject(projectId);
+            this.#database.prepare(`INSERT INTO artifacts(id, project_id, name, media_type, relative_path, sha256, size_bytes, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(artifactId, projectId, input.name, input.mediaType, input.relativePath, input.sha256, input.sizeBytes, now());
+            return this.getArtifact(projectId, artifactId);
+        });
+    }
+    getArtifact(projectId, artifactId) {
+        const row = this.#require('artifacts', artifactId);
+        owned(row, 'project_id', projectId);
+        return doc(row);
+    }
+    listArtifacts(projectId, options) {
+        this.getProject(projectId);
+        // Explicit order: the shared pager defaults to `updated_at`, which this table does not have
+        // (see schema.ts), so the default made every request fail with a SQLite error surfaced as 500.
+        return this.#page('SELECT * FROM artifacts WHERE project_id = ?', [projectId], options, 'created_at DESC, id DESC');
+    }
+    /**
+     * 02A `ContextPageQuery.direction`. `backward` walks from the newest item towards the oldest,
+     * which is what a transcript needs: the first page is the latest turn, and paging loads history.
+     * `forward` walks in ordinal order for an audit view. The parameter was ignored and every caller
+     * got ordinal order, so the chat rendered its newest turn first and, past one page, would have
+     * paged away from the conversation instead of into its history.
+     */
+    listContext(projectId, agentId, options, direction = 'forward') {
+        this.getAgent(projectId, agentId);
+        const order = direction === 'backward' ? 'ordinal DESC, id DESC' : 'ordinal ASC, id ASC';
+        return this.#page('SELECT * FROM context_items WHERE agent_id = ?', [agentId], options, order);
+    }
+    contextSource(projectId, agentId) {
+        return {
+            agent: this.getAgent(projectId, agentId),
+            items: this.#all('SELECT * FROM context_items WHERE agent_id = ? AND visible = 1 ORDER BY ordinal, id', agentId).map(doc),
+            overrides: this.#all('SELECT * FROM context_overrides WHERE agent_id = ? ORDER BY created_at, id', agentId).map(doc),
+            capabilities: this.listCapabilities(projectId, agentId).filter((entry) => entry.loaded === true)
+        };
+    }
+    getPlan(projectId, agentId) {
+        this.getAgent(projectId, agentId);
+        const row = this.#database.prepare('SELECT * FROM agent_plans WHERE agent_id = ?').get(agentId);
+        return row === undefined ? null : doc(row);
+    }
+    updatePlan(projectId, agentId, items) {
+        return this.#write(projectId, refs(['agent_plan', agentId]), () => {
+            this.getAgent(projectId, agentId);
+            this.#database.prepare(`INSERT INTO agent_plans(agent_id, items_json, revision, updated_at) VALUES (?, ?, 0, ?) ON CONFLICT(agent_id) DO UPDATE SET items_json = excluded.items_json, revision = agent_plans.revision + 1, updated_at = excluded.updated_at`)
+                .run(agentId, json(items), now());
+            return doc(this.#one('SELECT * FROM agent_plans WHERE agent_id = ?', agentId));
+        });
+    }
+    getContextItem(projectId, contextItemId) {
+        const row = this.#require('context_items', contextItemId);
+        this.#ownedAgent(String(row.agent_id), projectId);
+        return doc(row);
+    }
+    updateContextItem(projectId, contextItemId, expectedRevision, content) {
+        const current = this.#require('context_items', contextItemId);
+        const agentId = String(current.agent_id);
+        return this.#write(projectId, refs(['context_item', contextItemId], ['agent', agentId]), () => {
+            this.#ownedAgent(agentId, projectId);
+            this.#expect(current, expectedRevision);
+            if (Number(current.locked) === 1)
+                fail('CONTEXT_LOCKED', 409, 'The ContextItem is before the latest Compaction boundary.');
+            const timestamp = now();
+            this.#database.prepare('UPDATE context_items SET content = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(content, timestamp, contextItemId);
+            this.#database.prepare('UPDATE agents SET context_revision = context_revision + 1, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(timestamp, agentId);
+            return this.getContextItem(projectId, contextItemId);
+        });
+    }
+    setContextVisibility(projectId, agentId, turnGroupIds, visible, expectedContextRevision) {
+        return this.#write(projectId, turnGroupIds.map((entry) => ({ type: 'turn_group', id: entry })), () => {
+            const agent = this.getAgent(projectId, agentId);
+            if (agent.context_revision !== expectedContextRevision)
+                fail('REVISION_CONFLICT', 409, 'The Context changed before this command was applied.');
+            const statement = this.#database.prepare(`UPDATE context_items SET visible = ?, revision = revision + 1, updated_at = ? WHERE turn_group_id = ? AND agent_id = ? AND locked = 0`);
+            for (const groupId of turnGroupIds) {
+                const group = this.#require('context_turn_groups', groupId);
+                if (group.agent_id !== agentId || group.state !== 'COMPLETE')
+                    fail('CONTEXT_GROUP_INVALID', 409, 'A complete TurnGroup is required.');
+                const expected = this.#count('SELECT COUNT(*) AS count FROM context_items WHERE turn_group_id = ?', groupId);
+                if (statement.run(visible ? 1 : 0, now(), groupId, agentId).changes !== expected)
+                    fail('CONTEXT_ITEM_CONFLICT', 409, 'A locked TurnGroup cannot change visibility.');
+            }
+            this.#touchContext(agentId);
+            return this.#all(`SELECT * FROM context_items WHERE turn_group_id IN (${turnGroupIds.map(() => '?').join(',')}) ORDER BY ordinal`, ...turnGroupIds).map(doc);
+        });
+    }
+    reorderContext(projectId, agentId, turnGroupIds, expectedContextRevision) {
+        return this.#write(projectId, turnGroupIds.map((entry) => ({ type: 'turn_group', id: entry })), () => {
+            const agent = this.getAgent(projectId, agentId);
+            if (agent.context_revision !== expectedContextRevision)
+                fail('REVISION_CONFLICT', 409, 'The Context changed before this command was applied.');
+            const current = this.#all(`SELECT g.id FROM context_turn_groups g WHERE g.agent_id = ? AND g.state = 'COMPLETE' AND NOT EXISTS (SELECT 1 FROM context_items i WHERE i.turn_group_id = g.id AND i.locked = 1) ORDER BY g.ordinal`, agentId).map((row) => String(row.id));
+            if (current.length !== turnGroupIds.length || current.some((entry) => !turnGroupIds.includes(entry)) || new Set(turnGroupIds).size !== turnGroupIds.length)
+                fail('CONTEXT_SET_MISMATCH', 409, 'The complete unlocked TurnGroup order is required.');
+            const lockedCount = this.#count('SELECT COUNT(*) AS count FROM context_items WHERE agent_id = ? AND locked = 1', agentId);
+            const lockedGroups = this.#count(`SELECT COUNT(*) AS count FROM context_turn_groups g WHERE g.agent_id = ? AND EXISTS (SELECT 1 FROM context_items i WHERE i.turn_group_id = g.id AND i.locked = 1)`, agentId);
+            const move = this.#database.prepare('UPDATE context_items SET ordinal = ordinal + 1000000000 WHERE turn_group_id = ?');
+            for (const groupId of turnGroupIds)
+                move.run(groupId);
+            const updateItem = this.#database.prepare('UPDATE context_items SET ordinal = ?, revision = revision + 1, updated_at = ? WHERE id = ?');
+            const updateGroup = this.#database.prepare('UPDATE context_turn_groups SET ordinal = ?, revision = revision + 1 WHERE id = ?');
+            let ordinal = lockedCount;
+            for (const [groupOffset, groupId] of turnGroupIds.entries()) {
+                updateGroup.run(lockedGroups + groupOffset, groupId);
+                for (const row of this.#all('SELECT id FROM context_items WHERE turn_group_id = ? ORDER BY turn_group_ordinal', groupId)) {
+                    updateItem.run(ordinal, now(), row.id);
+                    ordinal += 1;
+                }
+            }
+            this.#touchContext(agentId);
+            return this.#all('SELECT * FROM context_items WHERE agent_id = ? ORDER BY ordinal', agentId).map(doc);
+        });
+    }
+    listOverrides(projectId, agentId, options) {
+        this.getAgent(projectId, agentId);
+        return this.#page('SELECT * FROM context_overrides WHERE agent_id = ?', [agentId], options);
+    }
+    getOverride(projectId, overrideId) {
+        const row = this.#require('context_overrides', overrideId);
+        this.#ownedAgent(String(row.agent_id), projectId);
+        return doc(row);
+    }
+    createOverride(projectId, agentId, targetKind, targetId, instructions) {
+        const overrideId = id('override');
+        const timestamp = now();
+        return this.#write(projectId, refs(['context_override', overrideId], ['agent', agentId]), () => {
+            this.getAgent(projectId, agentId);
+            this.#database.prepare(`INSERT INTO context_overrides(id, agent_id, target_kind, target_id, instructions, revision, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 0, ?, ?)`)
+                .run(overrideId, agentId, targetKind, targetId, instructions, timestamp, timestamp);
+            this.#touchContext(agentId);
+            return this.getOverride(projectId, overrideId);
+        });
+    }
+    updateOverride(projectId, overrideId, expectedRevision, instructions) {
+        const current = this.#require('context_overrides', overrideId);
+        const agentId = String(current.agent_id);
+        return this.#write(projectId, refs(['context_override', overrideId], ['agent', agentId]), () => {
+            this.#ownedAgent(agentId, projectId);
+            this.#expect(current, expectedRevision);
+            this.#database.prepare('UPDATE context_overrides SET instructions = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(instructions, now(), overrideId);
+            this.#touchContext(agentId);
+            return this.getOverride(projectId, overrideId);
+        });
+    }
+    deleteOverride(projectId, overrideId, expectedRevision) {
+        const current = this.#require('context_overrides', overrideId);
+        const agentId = String(current.agent_id);
+        this.#write(projectId, refs(['context_override', overrideId], ['agent', agentId]), () => {
+            this.#ownedAgent(agentId, projectId);
+            this.#expect(current, expectedRevision);
+            this.#database.prepare('DELETE FROM context_overrides WHERE id = ?').run(overrideId);
+            this.#touchContext(agentId);
+        });
+    }
+    listTurnGroups(projectId, agentId, options) {
+        this.getAgent(projectId, agentId);
+        return this.#page('SELECT * FROM context_turn_groups WHERE agent_id = ?', [agentId], options, 'ordinal ASC, id ASC');
+    }
+    listProjectionDecisions(projectId, agentId, options) {
+        this.getAgent(projectId, agentId);
+        return this.#page('SELECT * FROM projection_decisions WHERE agent_id = ?', [agentId], options, 'created_at DESC, id DESC');
+    }
+    resetProjection(projectId, agentId, expectedContextRevision, stages) {
+        return this.#write(projectId, refs(['agent', agentId]), () => {
+            const agent = this.getAgent(projectId, agentId);
+            if (agent.context_revision !== expectedContextRevision)
+                fail('REVISION_CONFLICT', 409, 'The Context changed before this command was applied.');
+            if (stages === undefined)
+                this.#database.prepare('DELETE FROM projection_decisions WHERE agent_id = ?').run(agentId);
+            else
+                this.#database.prepare(`DELETE FROM projection_decisions WHERE agent_id = ? AND stage IN (${stages.map(() => '?').join(',')})`).run(agentId, ...stages);
+            return { agent_id: agentId, context_revision: agent.context_revision };
+        });
+    }
+    appendProjectionDecision(projectId, agentId, attemptId, stage, sourceTokens, projectedTokens, details) {
+        const decisionId = id('projection');
+        return this.#write(projectId, refs(['projection_decision', decisionId]), () => {
+            this.getAgent(projectId, agentId);
+            this.#database.prepare(`INSERT INTO projection_decisions(id, agent_id, attempt_id, stage, source_tokens, projected_tokens, details_json, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(decisionId, agentId, attemptId, stage, sourceTokens, projectedTokens, json(details), now());
+            return doc(this.#require('projection_decisions', decisionId));
+        });
+    }
+    compactContext(projectId, agentId, summary, preserveFromOrdinal) {
+        const contextId = id('context');
+        const turnGroupId = id('turn');
+        const timestamp = now();
+        return this.#write(projectId, refs(['turn_group', turnGroupId], ['context_item', contextId], ['agent', agentId]), () => {
+            this.getAgent(projectId, agentId);
+            this.#database.prepare('UPDATE context_items SET locked = 1, revision = revision + 1, updated_at = ? WHERE agent_id = ? AND ordinal < ?')
+                .run(timestamp, agentId, preserveFromOrdinal);
+            const ordinal = this.#nextOrdinal('context_items', 'agent_id', agentId);
+            this.#insertTurnGroup(turnGroupId, agentId, 'compaction', 'COMPLETE', timestamp);
+            this.#database.prepare(`INSERT INTO context_items(id, agent_id, turn_group_id, turn_group_ordinal, kind, source_id, role, content, ordinal, visible, locked, revision, created_at, updated_at) VALUES (?, ?, ?, 0, 'compaction', ?, 'system', ?, ?, 1, 0, 0, ?, ?)`)
+                .run(contextId, agentId, turnGroupId, contextId, summary, ordinal, timestamp, timestamp);
+            this.#touchContext(agentId);
+            return this.getContextItem(projectId, contextId);
+        });
+    }
+    forkContext(projectId, sourceAgentId, targetAgentId, throughOrdinal) {
+        return this.#write(projectId, refs(['agent', targetAgentId]), () => {
+            this.getAgent(projectId, sourceAgentId);
+            this.getAgent(projectId, targetAgentId);
+            return this.#copyContextRange(sourceAgentId, targetAgentId, throughOrdinal, now());
+        });
+    }
+    createContextFork(projectId, sourceAgentId, input) {
+        const targetAgentId = id('agent');
+        return this.#write(projectId, refs(['agent', targetAgentId]), () => {
+            const source = this.getAgent(projectId, sourceAgentId);
+            if (source.context_revision !== input.expectedContextRevision)
+                fail('FORK_SOURCE_CHANGED', 409, 'The source Context changed before Fork.');
+            const boundary = this.#require('context_turn_groups', input.throughTurnGroupId);
+            if (boundary.agent_id !== sourceAgentId || boundary.state !== 'COMPLETE')
+                fail('CONTEXT_GROUP_INVALID', 409, 'Context Fork requires a complete source TurnGroup.');
+            if (this.#count('SELECT COUNT(*) AS count FROM context_items WHERE turn_group_id = ? AND locked = 1', input.throughTurnGroupId) !== 0)
+                fail('CONTEXT_LOCKED', 409, 'The Context Fork boundary is locked.');
+            const throughOrdinal = Number(this.#one('SELECT MAX(ordinal) AS ordinal FROM context_items WHERE turn_group_id = ?', input.throughTurnGroupId).ordinal);
+            const taskId = stringField(source.task_id);
+            const timestamp = now();
+            const parentAgentId = source.parent_agent_id === null ? undefined : stringField(source.parent_agent_id);
+            let sessionId = stringField(source.session_id);
+            if (parentAgentId === undefined) {
+                sessionId = id('session');
+                this.#database.prepare(`INSERT INTO sessions(id, task_id, title, archived_at, revision, created_at, updated_at) VALUES (?, ?, ?, NULL, 0, ?, ?)`)
+                    .run(sessionId, taskId, input.name, timestamp, timestamp);
+            }
+            const capabilities = Object.fromEntries(this.#all('SELECT capability_id, policy FROM capability_assignments WHERE agent_id = ?', sourceAgentId).map((row) => [String(row.capability_id), String(row.policy)]));
+            const loadedCapabilities = this.#all('SELECT capability_id FROM capability_loads WHERE agent_id = ?', sourceAgentId).map((row) => String(row.capability_id));
+            this.#insertAgent(projectId, targetAgentId, {
+                taskId,
+                sessionId,
+                workspaceId: stringField(source.workspace_id),
+                ...(parentAgentId === undefined ? {} : { parentAgentId }),
+                name: input.name,
+                model: input.model,
+                modelReasoningEffort: input.modelReasoningEffort,
+                policyPreset: stringField(source.policy_preset),
+                capabilities,
+                loadedCapabilities
+            }, timestamp);
+            this.#copyContextRange(sourceAgentId, targetAgentId, throughOrdinal, timestamp);
+            return this.getAgent(projectId, targetAgentId);
+        });
+    }
+    appendAssistantMessage(projectId, agentId, stepId, content) {
+        const messageId = id('message');
+        const contextId = id('context');
+        const timestamp = now();
+        return this.#write(projectId, refs(['message', messageId], ['context_item', contextId]), () => {
+            this.getAgent(projectId, agentId);
+            const turnGroupId = stringField(this.getStep(projectId, stepId).turn_group_id);
+            this.#database.prepare(`INSERT INTO messages(id, agent_id, source_agent_id, role, content, metadata_json, created_at) VALUES (?, ?, NULL, 'assistant', ?, NULL, ?)`)
+                .run(messageId, agentId, content, timestamp);
+            const ordinal = this.#nextOrdinal('context_items', 'agent_id', agentId);
+            const groupOrdinal = this.#nextOrdinal('context_items', 'turn_group_id', turnGroupId);
+            this.#database.prepare(`INSERT INTO context_items(id, agent_id, turn_group_id, turn_group_ordinal, kind, source_id, role, content, ordinal, visible, locked, revision, created_at, updated_at) VALUES (?, ?, ?, ?, 'message', ?, 'assistant', ?, ?, 1, 0, 0, ?, ?)`)
+                .run(contextId, agentId, turnGroupId, groupOrdinal, messageId, content, ordinal, timestamp, timestamp);
+            this.#touchContext(agentId);
+            return this.getMessage(projectId, messageId);
+        });
+    }
+    appendToolCalls(projectId, agentId, stepId, calls) {
+        const contextId = id('context');
+        const timestamp = now();
+        return this.#write(projectId, refs(['context_item', contextId]), () => {
+            this.getAgent(projectId, agentId);
+            const turnGroupId = stringField(this.getStep(projectId, stepId).turn_group_id);
+            const ordinal = this.#nextOrdinal('context_items', 'agent_id', agentId);
+            const groupOrdinal = this.#nextOrdinal('context_items', 'turn_group_id', turnGroupId);
+            this.#database.prepare(`INSERT INTO context_items(id, agent_id, turn_group_id, turn_group_ordinal, kind, source_id, role, content, ordinal, visible, locked, revision, created_at, updated_at) VALUES (?, ?, ?, ?, 'tool_calls', ?, 'assistant', ?, ?, 1, 0, 0, ?, ?)`)
+                .run(contextId, agentId, turnGroupId, groupOrdinal, contextId, json(calls), ordinal, timestamp, timestamp);
+            this.#touchContext(agentId);
+            return this.getContextItem(projectId, contextId);
+        });
+    }
+    /**
+     * `errorMessage` is what the failure actually said. `error_code` alone made a Provider rejection, a TLS
+     * fault and a malformed Tool block all read as one `RUNTIME_FAILED` with nothing to act on.
+     */
+    finishStep(projectId, stepId, outcome, errorCode = null, errorMessage = null) {
+        const step = this.#require('steps', stepId);
+        const runId = String(step.run_id);
+        const run = this.#require('runs', runId);
+        const agentId = String(run.agent_id);
+        return this.#write(projectId, refs(['step', stepId], ['run', runId], ['agent', agentId]), () => {
+            const timestamp = now();
+            this.#database.prepare(`UPDATE steps SET state = 'TERMINAL', outcome = ?, error_code = ?, error_message = ?, updated_at = ? WHERE id = ? AND state != 'TERMINAL'`)
+                .run(outcome, errorCode, errorMessage, timestamp, stepId);
+            const hasPending = this.#count('SELECT COUNT(*) AS count FROM pending_messages WHERE agent_id = ?', agentId) > 0;
+            const continueRun = outcome === 'success' && hasPending;
+            this.#database.prepare(`UPDATE runs SET state = ?, outcome = ?, error_code = ?, error_message = ?, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                .run(continueRun ? 'READY' : 'TERMINAL', continueRun ? null : outcome, continueRun ? null : errorCode, continueRun ? null : errorMessage, timestamp, runId);
+            if (!continueRun && hasPending && errorCode !== 'COMPACTION_FAILED') {
+                this.#database.prepare(`INSERT INTO runs(id, agent_id, goal_message_ids_json, state, outcome, error_code, revision, created_at, updated_at) VALUES (?, ?, '[]', 'READY', NULL, NULL, 0, ?, ?)`)
+                    .run(id('run'), agentId, timestamp, timestamp);
+            }
+            this.#database.prepare(`UPDATE agents SET state = 'IDLE', revision = revision + 1, updated_at = ? WHERE id = ?`)
+                .run(timestamp, agentId);
+            this.#database.prepare(`UPDATE context_turn_groups SET state = ?, revision = revision + 1, completed_at = ? WHERE id = ? AND state = 'OPEN'`)
+                .run(outcome === 'success' ? 'COMPLETE' : 'ABORTED', timestamp, step.turn_group_id);
+            return { step: this.getStep(projectId, stepId), run: this.getRun(projectId, runId), agent: this.getAgent(projectId, agentId) };
+        });
+    }
+    continueRun(projectId, stepId) {
+        const step = this.#require('steps', stepId);
+        const runId = String(step.run_id);
+        const run = this.#require('runs', runId);
+        const nextStepId = id('step');
+        return this.#write(projectId, refs(['step', stepId], ['step', nextStepId], ['run', runId]), () => {
+            const timestamp = now();
+            const update = this.#database.prepare(`UPDATE steps SET state = 'TERMINAL', outcome = 'success', updated_at = ? WHERE id = ? AND state != 'TERMINAL'`)
+                .run(timestamp, stepId);
+            if (update.changes !== 1)
+                fail('STEP_STATE_CONFLICT', 409, 'The Step is already terminal.');
+            const ordinal = this.#nextOrdinal('steps', 'run_id', runId);
+            this.#database.prepare(`INSERT INTO steps(id, run_id, turn_group_id, ordinal, state, outcome, error_code, created_at, updated_at) VALUES (?, ?, ?, ?, 'RUNNING', NULL, NULL, ?, ?)`)
+                .run(nextStepId, runId, step.turn_group_id, ordinal, timestamp, timestamp);
+            this.#database.prepare(`UPDATE runs SET state = 'RUNNING', revision = revision + 1, updated_at = ? WHERE id = ?`).run(timestamp, runId);
+            this.#ownedAgent(String(run.agent_id), projectId);
+            return doc(this.#require('steps', nextStepId));
+        });
+    }
+    yieldResults(projectId, agentId, callIds) {
+        const timestamp = now();
+        return this.#write(projectId, callIds.map((entry) => ({ type: 'result', id: entry })), () => {
+            this.getAgent(projectId, agentId);
+            const rows = callIds.map((callId) => {
+                const call = this.#require('calls', callId);
+                if (call.state !== 'TERMINAL')
+                    fail('CALL_STATE_CONFLICT', 409, 'All Calls must be terminal before Result Yield.');
+                const result = this.#database.prepare('SELECT * FROM results WHERE call_id = ?').get(callId);
+                if (result === undefined)
+                    fail('RESULT_NOT_FOUND', 503, 'A terminal Call has no Result.');
+                return { call, result };
+            }).sort((left, right) => Number(left.call.call_ordinal ?? 0) - Number(right.call.call_ordinal ?? 0));
+            const yielded = [];
+            for (const { call, result } of rows) {
+                if (typeof call.provider_call_id !== 'string')
+                    fail('DATABASE_CORRUPT', 503, 'An LLM Call has no Provider Call ID.');
+                if (typeof call.step_id !== 'string')
+                    fail('DATABASE_CORRUPT', 503, 'An LLM Call has no Step.');
+                const turnGroupId = String(this.#require('steps', call.step_id).turn_group_id);
+                const contextId = id('context');
+                const ordinal = this.#nextOrdinal('context_items', 'agent_id', agentId);
+                const groupOrdinal = this.#nextOrdinal('context_items', 'turn_group_id', turnGroupId);
+                const artifacts = this.#all('SELECT artifact_id FROM result_artifacts WHERE result_id = ? ORDER BY artifact_id', result.id).map((row) => String(row.artifact_id));
+                const content = json({ content: parseJson(String(result.content_json)), artifacts, truncated: Number(result.truncated) === 1 });
+                this.#database.prepare(`INSERT INTO context_items(id, agent_id, turn_group_id, turn_group_ordinal, kind, source_id, role, content, tool_call_id, tool_name, ordinal, visible, locked, revision, created_at, updated_at) VALUES (?, ?, ?, ?, 'result', ?, 'tool', ?, ?, ?, ?, 1, 0, 0, ?, ?)`)
+                    .run(contextId, agentId, turnGroupId, groupOrdinal, String(result.id), content, call.provider_call_id, String(call.capability_id), ordinal, timestamp, timestamp);
+                yielded.push({ ...doc(result), tool_call_id: call.provider_call_id, tool_name: String(call.capability_id) });
+            }
+            this.#touchContext(agentId);
+            return yielded;
+        });
+    }
+    cancelAgent(projectId, agentId) {
+        return this.#write(projectId, refs(['agent', agentId]), () => {
+            this.getAgent(projectId, agentId);
+            const timestamp = now();
+            this.#database.prepare(`UPDATE model_attempts SET state = 'TERMINAL', outcome = 'cancelled', error_code = 'USER_CANCELLED', updated_at = ? WHERE agent_id = ? AND state != 'TERMINAL'`).run(timestamp, agentId);
+            this.#database.prepare(`UPDATE calls SET state = 'TERMINAL', outcome = 'cancelled', outcome_unknown = CASE WHEN state = 'RUNNING' THEN 1 ELSE 0 END, revision = revision + 1, updated_at = ? WHERE agent_id = ? AND state != 'TERMINAL'`).run(timestamp, agentId);
+            this.#database.prepare(`UPDATE steps SET state = 'TERMINAL', outcome = 'cancelled', error_code = 'USER_CANCELLED', updated_at = ? WHERE run_id IN (SELECT id FROM runs WHERE agent_id = ?) AND state != 'TERMINAL'`).run(timestamp, agentId);
+            this.#database.prepare(`UPDATE runs SET state = 'TERMINAL', outcome = 'cancelled', error_code = 'USER_CANCELLED', revision = revision + 1, updated_at = ? WHERE agent_id = ? AND state != 'TERMINAL'`).run(timestamp, agentId);
+            this.#database.prepare(`UPDATE agents SET state = 'IDLE', revision = revision + 1, updated_at = ? WHERE id = ?`).run(timestamp, agentId);
+            this.#database.prepare(`UPDATE context_turn_groups SET state = 'ABORTED', revision = revision + 1, completed_at = ? WHERE agent_id = ? AND state = 'OPEN'`).run(timestamp, agentId);
+            return this.#all('SELECT * FROM runs WHERE agent_id = ? ORDER BY created_at DESC', agentId).map(doc);
+        });
+    }
+    runTimeline(projectId, runId, options) {
+        this.getRun(projectId, runId);
+        return this.#page(`
+      SELECT 'step' AS entity_type, id, created_at, state, outcome, error_code FROM steps WHERE run_id = ?
+      UNION ALL
+      SELECT 'call' AS entity_type, c.id, c.created_at, c.state, c.outcome, NULL AS error_code
+      FROM calls c JOIN steps s ON s.id = c.step_id WHERE s.run_id = ?
+    `, [runId, runId], options, 'created_at ASC, id ASC');
+    }
+    stepOutput(projectId, stepId) {
+        this.getStep(projectId, stepId);
+        const calls = this.#all('SELECT * FROM calls WHERE step_id = ? ORDER BY call_ordinal, id', stepId).map(doc);
+        const results = this.#all('SELECT r.* FROM results r JOIN calls c ON c.id = r.call_id WHERE c.step_id = ? ORDER BY c.call_ordinal, c.id', stepId).map(doc);
+        return { calls, results };
+    }
+    storageStats() {
+        const pageCount = Number(this.#one('PRAGMA page_count').page_count);
+        const pageSize = Number(this.#one('PRAGMA page_size').page_size);
+        const tables = ['projects', 'workspaces', 'tasks', 'sessions', 'agents', 'messages', 'runs', 'steps', 'model_attempts', 'calls', 'results', 'artifacts', 'context_items'];
+        return {
+            bytes: pageCount * pageSize,
+            tables: Object.fromEntries(tables.map((table) => [table, this.#count(`SELECT COUNT(*) AS count FROM ${table}`)]))
+        };
+    }
+    exportState() {
+        const tables = [
+            'instance', 'projects', 'workspaces', 'workspace_paths', 'tasks', 'sessions', 'agents', 'messages',
+            'pending_messages', 'runs', 'steps', 'model_attempts', 'attempt_capabilities', 'attempt_tool_ordinals',
+            'call_partitions', 'calls', 'results', 'artifacts', 'result_artifacts', 'context_turn_groups',
+            'context_items', 'context_overrides', 'projection_decisions', 'capability_assignments', 'capability_loads',
+            'agent_plans', 'ingress_requests', 'side_effect_ledgers'
+        ];
+        return Object.fromEntries(tables.map((table) => [table, this.#all(`SELECT * FROM ${table}`).map(rawJson)]));
+    }
+    purgeArchived(projectId, before) {
+        return this.#write(projectId, refs(['maintenance', projectId]), () => {
+            const tasks = this.#all('SELECT id FROM tasks WHERE project_id = ? AND archived_at IS NOT NULL AND archived_at < ?', projectId, before).map((row) => String(row.id));
+            return { purged_tasks: tasks.length, ...this.#purgeTaskRows(tasks) };
+        });
+    }
+    snapshot(projectId, maxEntities) {
+        const project = this.getProject(projectId);
+        const workspaces = this.listWorkspaces(projectId);
+        const tasks = this.#all('SELECT * FROM tasks WHERE project_id = ? AND archived_at IS NULL ORDER BY updated_at DESC', projectId).map(doc);
+        const sessions = this.#all(`SELECT s.* FROM sessions s JOIN tasks t ON t.id = s.task_id WHERE t.project_id = ? AND s.archived_at IS NULL ORDER BY s.updated_at DESC`, projectId).map(doc);
+        const agents = this.#all(`SELECT a.* FROM agents a JOIN tasks t ON t.id = a.task_id WHERE t.project_id = ? AND a.state != 'STOPPED' ORDER BY a.updated_at DESC`, projectId).map((row) => this.#agent(row));
+        const runs = this.#all(`SELECT r.* FROM runs r JOIN agents a ON a.id = r.agent_id JOIN tasks t ON t.id = a.task_id WHERE t.project_id = ? AND r.state != 'TERMINAL' ORDER BY r.updated_at DESC`, projectId).map(doc);
+        const calls = this.#all(`SELECT * FROM calls WHERE project_id = ? AND state != 'TERMINAL' ORDER BY updated_at DESC`, projectId).map(doc);
+        const count = workspaces.length + tasks.length + sessions.length + agents.length + runs.length + calls.length;
+        if (count > maxEntities)
+            fail('SNAPSHOT_TOO_LARGE', 503, 'The runtime Snapshot exceeds its configured bound.', { count, maximum: maxEntities });
+        return { revision: this.stateRevision(), project, workspaces, tasks, sessions, agents, runs, calls };
+    }
+    #ingressReplay(input) {
+        const row = this.#database.prepare('SELECT operation, request_digest, response_json FROM ingress_requests WHERE client_id = ? AND key = ?')
+            .get(input.clientId, input.key);
+        if (row === undefined)
+            return null;
+        if (row.operation !== input.operation || row.request_digest !== input.digest) {
+            fail('IDEMPOTENCY_CONFLICT', 409, 'The Idempotency-Key was already used for a different request.');
+        }
+        const value = parseJson(String(row.response_json));
+        if (!isJsonObject(value))
+            fail('DATABASE_CORRUPT', 503, 'An ingress response is invalid.');
+        return value;
+    }
+    #recordIngress(input, response) {
+        this.#database.prepare('INSERT INTO ingress_requests(client_id, key, operation, request_digest, response_json, created_at) VALUES (?, ?, ?, ?, ?, ?)')
+            .run(input.clientId, input.key, input.operation, input.digest, json(response), now());
+    }
+    #write(projectId, changes, command) {
+        const transaction = this.#database.transaction(() => {
+            const value = command();
+            this.#database.prepare('UPDATE instance SET state_revision = state_revision + 1 WHERE id = 1').run();
+            return { value, stateRevision: this.stateRevision() };
+        });
+        const result = transaction();
+        this.#eventLog?.append(result.stateRevision, this.exportState());
+        // Resolved after the transaction commits: the owner and revision are read from the state the
+        // subscriber is about to see, and an entity that is gone is reported as deleted.
+        const change = {
+            projectId,
+            stateRevision: result.stateRevision,
+            changes: changes.map((entry) => this.#describeChange(entry))
+        };
+        this.#events.publish(change);
+        return result.value;
+    }
+    /**
+     * 07 `ChangedEntityRef`. The event carried only `{ type, id }`, so `read_route` was undefined and
+     * a subscriber had nothing to re-read -- live invalidation could not work at all -- while the
+     * absent `owner_id` threw inside the subscriber's handler and stopped the stream outright.
+     *
+     * `change` distinguishes `deleted` from `updated` by whether the row survived the transaction.
+     * `created` is not distinguished: nothing records it, and a subscriber re-reads either way.
+     */
+    #describeChange(entry) {
+        const owner = OWNERSHIP[entry.type];
+        const row = TABLE_BY_ENTITY[entry.type] === undefined
+            ? undefined
+            : this.#all(`SELECT * FROM ${TABLE_BY_ENTITY[entry.type] ?? ''} WHERE id = ?`, entry.id)[0];
+        const ownerId = owner === undefined || row === undefined ? null : row[owner.column];
+        return {
+            type: entry.type,
+            id: entry.id,
+            entity_type: entry.type,
+            entity_id: entry.id,
+            owner_id: typeof ownerId === 'string' ? ownerId : null,
+            read_route: readRouteFor(entry.type, entry.id),
+            revision: typeof row?.revision === 'number' ? row.revision : null,
+            change: row === undefined && TABLE_BY_ENTITY[entry.type] !== undefined ? 'deleted' : 'updated',
+            ...this.#changeScope(entry.type, row)
+        };
+    }
+    /**
+     * The 07 §4.2 invalidation scope: `project_id`, `task_id`, aggregate `session_id` and `agent_id`,
+     * derived from Canonical State. Only `project_id` was published, so a subscriber could invalidate
+     * the row that changed and nothing that is computed from it -- a Run reaching `TERMINAL` refreshed
+     * the Run Routes while `SessionSummary.status` and `active_run_count`, both derived from Runs, kept
+     * whatever they last said.
+     *
+     * These fields are invalidation scope, not ownership: they say what to re-read. A Direct Call has no
+     * Agent, Task or Project, and 07 requires omitting the fields there rather than inventing one, which
+     * is why every branch here can come back empty.
+     */
+    #changeScope(type, row) {
+        if (row === undefined)
+            return {};
+        const agentId = this.#scopeAgentId(type, row);
+        const agent = agentId === null
+            ? undefined
+            : this.#all('SELECT task_id, session_id FROM agents WHERE id = ?', agentId)[0];
+        const sessionId = type === 'session' ? optionalScopeId(row.id) : optionalScopeId(agent?.session_id);
+        const taskId = type === 'task'
+            ? optionalScopeId(row.id)
+            : type === 'session' ? optionalScopeId(row.task_id) : optionalScopeId(agent?.task_id);
+        const projectId = type === 'project'
+            ? optionalScopeId(row.id)
+            : projectIdOf(row) ?? (taskId === undefined ? undefined : optionalScopeId(this.#all('SELECT project_id FROM tasks WHERE id = ?', taskId)[0]?.project_id));
+        return {
+            ...(agentId === null ? {} : { agent_id: agentId }),
+            ...(sessionId === undefined ? {} : { session_id: sessionId }),
+            ...(taskId === undefined ? {} : { task_id: taskId }),
+            ...(projectId === undefined ? {} : { project_id: projectId })
+        };
+    }
+    /**
+     * The Agent a changed row belongs to. Most rows carry `agent_id` outright; a Step, Partition or
+     * Result needs one hop first, and the walk is at most three rows deep.
+     */
+    #scopeAgentId(type, row) {
+        if (type === 'agent')
+            return typeof row.id === 'string' ? row.id : null;
+        if (typeof row.agent_id === 'string')
+            return row.agent_id;
+        const parent = SCOPE_PARENT[type];
+        if (parent === undefined)
+            return null;
+        const parentId = row[parent.column];
+        if (typeof parentId !== 'string')
+            return null;
+        const parentRow = this.#all(`SELECT * FROM ${parent.table} WHERE id = ?`, parentId)[0];
+        return parentRow === undefined ? null : this.#scopeAgentId(parent.type, parentRow);
+    }
+    #insertAgent(projectId, agentId, input, timestamp) {
+        const task = this.#require('tasks', input.taskId);
+        owned(task, 'project_id', projectId);
+        const session = this.#require('sessions', input.sessionId);
+        if (String(session.task_id) !== input.taskId)
+            fail('SESSION_NOT_FOUND', 404, 'The Session does not belong to the Task.');
+        this.getWorkspace(projectId, input.workspaceId);
+        let parentCapabilities = null;
+        if (input.parentAgentId !== undefined) {
+            const parent = this.#require('agents', input.parentAgentId);
+            if (String(parent.task_id) !== input.taskId || String(parent.session_id) !== input.sessionId) {
+                fail('AGENT_NOT_FOUND', 404, 'The parent Agent does not belong to the Session.');
+            }
+            parentCapabilities = new Set(this.#all('SELECT capability_id FROM capability_assignments WHERE agent_id = ?', input.parentAgentId).map((row) => String(row.capability_id)));
+        }
+        this.#database.prepare(`INSERT INTO agents(id, task_id, session_id, workspace_id, parent_agent_id, name, state, model, model_reasoning_effort, policy_preset, context_revision, revision, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, 'IDLE', ?, ?, ?, 0, 0, ?, ?)`)
+            .run(agentId, input.taskId, input.sessionId, input.workspaceId, input.parentAgentId ?? null, input.name, input.model, input.modelReasoningEffort, input.policyPreset, timestamp, timestamp);
+        const assign = this.#database.prepare('INSERT INTO capability_assignments(agent_id, capability_id, policy, assigned_at) VALUES (?, ?, ?, ?)');
+        const load = this.#database.prepare('INSERT INTO capability_loads(agent_id, capability_id, loaded_at) VALUES (?, ?, ?)');
+        for (const [capabilityId, policy] of Object.entries(input.capabilities)) {
+            if (parentCapabilities !== null && !parentCapabilities.has(capabilityId))
+                continue;
+            assign.run(agentId, capabilityId, policy, timestamp);
+            if (input.loadedCapabilities.includes(capabilityId))
+                load.run(agentId, capabilityId, timestamp);
+        }
+        return this.getAgent(projectId, agentId);
+    }
+    #copyContextRange(sourceAgentId, targetAgentId, throughOrdinal, timestamp) {
+        const boundary = this.#database.prepare(`SELECT MAX(ordinal) AS ordinal FROM context_items WHERE agent_id = ? AND kind = 'compaction' AND ordinal <= ?`).get(sourceAgentId, throughOrdinal);
+        const fromOrdinal = boundary.ordinal === null ? 0 : Number(boundary.ordinal);
+        const source = this.#all('SELECT * FROM context_items WHERE agent_id = ? AND ordinal >= ? AND ordinal <= ? AND visible = 1 ORDER BY ordinal', sourceAgentId, fromOrdinal, throughOrdinal);
+        if (source.length === 0 || Number(source.at(-1)?.ordinal) !== throughOrdinal)
+            fail('CONTEXT_GROUP_INVALID', 409, 'The Context fork boundary does not exist.');
+        const lastGroupId = String(source.at(-1)?.turn_group_id);
+        if (this.#count('SELECT COUNT(*) AS count FROM context_items WHERE turn_group_id = ? AND ordinal > ?', lastGroupId, throughOrdinal) !== 0)
+            fail('CONTEXT_GROUP_INVALID', 409, 'Context Fork must end at a complete TurnGroup boundary.');
+        const groupIds = new Map();
+        for (const sourceGroupId of new Set(source.map((row) => String(row.turn_group_id)))) {
+            const group = this.#require('context_turn_groups', sourceGroupId);
+            if (group.state !== 'COMPLETE')
+                fail('CONTEXT_GROUP_INVALID', 409, 'Only complete TurnGroups can be forked.');
+            const targetGroupId = id('turn');
+            groupIds.set(sourceGroupId, targetGroupId);
+            this.#insertTurnGroup(targetGroupId, targetAgentId, String(group.kind), 'COMPLETE', timestamp);
+        }
+        const insert = this.#database.prepare(`INSERT INTO context_items(id, agent_id, turn_group_id, turn_group_ordinal, kind, source_id, role, content, tool_call_id, tool_name, ordinal, visible, locked, revision, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?)`);
+        let ordinal = this.#nextOrdinal('context_items', 'agent_id', targetAgentId);
+        for (const row of source) {
+            const contextId = id('context');
+            let sourceId = String(row.source_id);
+            if (row.kind === 'message') {
+                const messageId = id('message');
+                this.#database.prepare(`INSERT INTO messages(id, agent_id, source_agent_id, role, content, metadata_json, created_at) VALUES (?, ?, ?, ?, ?, NULL, ?)`)
+                    .run(messageId, targetAgentId, sourceAgentId, row.role, row.content, timestamp);
+                sourceId = messageId;
+            }
+            else if (row.kind !== 'result')
+                sourceId = contextId;
+            const targetGroupId = groupIds.get(String(row.turn_group_id));
+            if (targetGroupId === undefined)
+                fail('DATABASE_CORRUPT', 503, 'A Context TurnGroup mapping is missing.');
+            insert.run(contextId, targetAgentId, targetGroupId, row.turn_group_ordinal, row.kind, sourceId, row.role, row.content, row.tool_call_id, row.tool_name, ordinal, row.visible, timestamp, timestamp);
+            ordinal += 1;
+        }
+        this.#touchContext(targetAgentId);
+        return this.#all('SELECT * FROM context_items WHERE agent_id = ? ORDER BY ordinal', targetAgentId).map(doc);
+    }
+    #insertStandaloneContextMessage(agentId, role, content, kind, timestamp) {
+        const messageId = id('message');
+        const turnGroupId = id('turn');
+        const contextId = id('context');
+        this.#database.prepare(`INSERT INTO messages(id, agent_id, source_agent_id, role, content, metadata_json, created_at) VALUES (?, ?, NULL, ?, ?, NULL, ?)`)
+            .run(messageId, agentId, role, content, timestamp);
+        this.#insertTurnGroup(turnGroupId, agentId, kind === 'compaction' ? 'compaction' : 'turn', 'COMPLETE', timestamp);
+        this.#database.prepare(`INSERT INTO context_items(id, agent_id, turn_group_id, turn_group_ordinal, kind, source_id, role, content, ordinal, visible, locked, revision, created_at, updated_at) VALUES (?, ?, ?, 0, ?, ?, ?, ?, ?, 1, 0, 0, ?, ?)`)
+            .run(contextId, agentId, turnGroupId, kind, messageId, role, content, this.#nextOrdinal('context_items', 'agent_id', agentId), timestamp, timestamp);
+        this.#touchContext(agentId);
+    }
+    // Returns what the caller still has to clean up outside the transaction: Artifact files on disk,
+    // and the Calls whose file history the Executor is still holding. Neither can happen in here --
+    // Store transactions do no file or network I/O.
+    #purgeTaskRows(taskIds) {
+        for (const taskId of taskIds) {
+            const references = this.#count(`SELECT COUNT(*) AS count FROM context_items ci JOIN agents target ON target.id = ci.agent_id WHERE ci.kind = 'result' AND target.task_id != ? AND ci.source_id IN (SELECT r.id FROM results r JOIN calls c ON c.id = r.call_id WHERE c.agent_id IN (SELECT id FROM agents WHERE task_id = ?))`, taskId, taskId);
+            if (references > 0)
+                fail('TASK_REFERENCED', 409, 'The archived Task has cross-Task Result references.');
+        }
+        const placeholders = taskIds.map(() => '?').join(',') || "''";
+        const purgedCalls = this.#all(`SELECT id, workspace_id FROM calls WHERE agent_id IN (SELECT id FROM agents WHERE task_id IN (${placeholders}))`, ...taskIds)
+            .map((row) => ({ call_id: String(row.id), workspace_id: String(row.workspace_id) }));
+        const candidateArtifacts = this.#all(`
+      SELECT DISTINCT a.id, a.relative_path FROM artifacts a WHERE a.id IN (
+        SELECT ra.artifact_id FROM result_artifacts ra JOIN results r ON r.id = ra.result_id JOIN calls c ON c.id = r.call_id JOIN agents owner ON owner.id = c.agent_id WHERE owner.task_id IN (${placeholders})
+      )
+    `, ...taskIds);
+        this.#database.prepare(`DELETE FROM calls WHERE agent_id IN (SELECT id FROM agents WHERE task_id IN (${placeholders}))`).run(...taskIds);
+        const removeTask = this.#database.prepare('DELETE FROM tasks WHERE id = ?');
+        for (const taskId of taskIds)
+            removeTask.run(taskId);
+        const orphanedPaths = new Set();
+        for (const artifact of candidateArtifacts) {
+            const artifactId = String(artifact.id);
+            const linked = this.#count('SELECT COUNT(*) AS count FROM result_artifacts WHERE artifact_id = ?', artifactId);
+            const overridden = this.#count(`SELECT COUNT(*) AS count FROM context_overrides WHERE target_kind = 'artifact' AND target_id = ?`, artifactId);
+            if (linked !== 0 || overridden !== 0)
+                continue;
+            const relativePath = String(artifact.relative_path);
+            this.#database.prepare('DELETE FROM artifacts WHERE id = ?').run(artifactId);
+            if (this.#count('SELECT COUNT(*) AS count FROM artifacts WHERE relative_path = ?', relativePath) === 0)
+                orphanedPaths.add(relativePath);
+        }
+        return { orphaned_artifact_paths: [...orphanedPaths], purged_calls: purgedCalls };
+    }
+    #insertContextMessage(agentId, role, content, ids, timestamp, groupKind = 'included') {
+        this.#database.prepare(`INSERT INTO messages(id, agent_id, source_agent_id, role, content, metadata_json, created_at) VALUES (?, ?, NULL, ?, ?, NULL, ?)`)
+            .run(ids.messageId, agentId, role, content, timestamp);
+        this.#insertTurnGroup(ids.turnGroupId, agentId, groupKind, 'COMPLETE', timestamp);
+        const ordinal = this.#nextOrdinal('context_items', 'agent_id', agentId);
+        this.#database.prepare(`INSERT INTO context_items(id, agent_id, turn_group_id, turn_group_ordinal, kind, source_id, role, content, ordinal, visible, locked, revision, created_at, updated_at) VALUES (?, ?, ?, 0, 'message', ?, ?, ?, ?, 1, 0, 0, ?, ?)`)
+            .run(ids.contextId, agentId, ids.turnGroupId, ids.messageId, role, content, ordinal, timestamp, timestamp);
+        this.#touchContext(agentId);
+    }
+    #insertQueuedMessage(projectId, agentId, content, sourceAgentId, ids, timestamp) {
+        const agent = this.#require('agents', agentId);
+        this.#ownedTask(String(agent.task_id), projectId);
+        if (sourceAgentId !== undefined) {
+            const source = this.#require('agents', sourceAgentId);
+            this.#ownedTask(String(source.task_id), projectId);
+            if (source.task_id !== agent.task_id)
+                fail('AGENT_NOT_FOUND', 404, 'Cross-Agent Messages must remain inside one Task.');
+        }
+        const pendingOrdinal = this.#nextOrdinal('pending_messages', 'agent_id', agentId);
+        const contextOrdinal = this.#nextOrdinal('context_items', 'agent_id', agentId);
+        this.#database.prepare(`INSERT INTO messages(id, agent_id, source_agent_id, role, content, metadata_json, created_at) VALUES (?, ?, ?, 'user', ?, NULL, ?)`)
+            .run(ids.messageId, agentId, sourceAgentId ?? null, content, timestamp);
+        this.#database.prepare(`INSERT INTO pending_messages(id, agent_id, message_id, source_agent_id, content, ordinal, revision, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)`)
+            .run(ids.pendingId, agentId, ids.messageId, sourceAgentId ?? null, content, pendingOrdinal, timestamp, timestamp);
+        this.#insertTurnGroup(ids.turnGroupId, agentId, 'turn', 'OPEN', timestamp);
+        this.#database.prepare(`INSERT INTO context_items(id, agent_id, turn_group_id, turn_group_ordinal, kind, source_id, role, content, ordinal, visible, locked, revision, created_at, updated_at) VALUES (?, ?, ?, 0, 'message', ?, 'user', ?, ?, 1, 0, 0, ?, ?)`)
+            .run(ids.contextId, agentId, ids.turnGroupId, ids.messageId, content, contextOrdinal, timestamp, timestamp);
+        const active = this.#database.prepare(`SELECT * FROM runs WHERE id = ? AND agent_id = ? AND state != 'TERMINAL'`).get(ids.runId, agentId);
+        if (active === undefined) {
+            this.#database.prepare(`INSERT INTO runs(id, agent_id, goal_message_ids_json, state, outcome, error_code, revision, created_at, updated_at) VALUES (?, ?, '[]', 'READY', NULL, NULL, 0, ?, ?)`)
+                .run(ids.runId, agentId, timestamp, timestamp);
+        }
+        this.#touchContext(agentId);
+        return {
+            message: this.getMessage(projectId, ids.messageId),
+            pending: doc(this.#require('pending_messages', ids.pendingId)),
+            run: doc(this.#require('runs', ids.runId))
+        };
+    }
+    #activeRunId(agentId) {
+        const row = this.#database.prepare(`SELECT id FROM runs WHERE agent_id = ? AND state != 'TERMINAL'`).get(agentId);
+        return row === undefined ? undefined : String(row.id);
+    }
+    #workspace(row) {
+        const paths = this.#all('SELECT path FROM workspace_paths WHERE workspace_id = ? ORDER BY ordinal', String(row.id)).map((entry) => String(entry.path));
+        return { ...doc(row), paths };
+    }
+    /**
+     * 02A `AgentSummary`. `is_subagent` and `subagent_list` are derived rather than stored, per the
+     * architecture. `project_id`, `aggregate_session_id` and `model_reference` were absent from the
+     * wire: the column is named `model`, and the other two live one join away, so a client reading
+     * the documented names saw nothing.
+     */
+    #agent(row) {
+        const agentId = String(row.id);
+        const children = this.#all('SELECT id FROM agents WHERE parent_agent_id = ? ORDER BY created_at, id', agentId).map((entry) => String(entry.id));
+        const owner = this.#all('SELECT project_id FROM tasks WHERE id = ?', String(row.task_id))[0];
+        return {
+            ...doc(row),
+            project_id: owner === undefined ? null : String(owner.project_id),
+            aggregate_session_id: typeof row.session_id === 'string' ? row.session_id : null,
+            model_reference: typeof row.model === 'string' ? row.model : null,
+            is_subagent: row.parent_agent_id !== null,
+            subagent_list: children
+        };
+    }
+    #replaceWorkspacePaths(workspaceId, paths) {
+        this.#database.prepare('DELETE FROM workspace_paths WHERE workspace_id = ?').run(workspaceId);
+        const insert = this.#database.prepare('INSERT INTO workspace_paths(workspace_id, ordinal, path) VALUES (?, ?, ?)');
+        paths.forEach((path, ordinal) => insert.run(workspaceId, ordinal, path));
+    }
+    #insertTurnGroup(idValue, agentId, kind, state, timestamp) {
+        const ordinal = this.#nextOrdinal('context_turn_groups', 'agent_id', agentId);
+        this.#database.prepare(`INSERT INTO context_turn_groups(id, agent_id, ordinal, kind, state, revision, created_at, completed_at) VALUES (?, ?, ?, ?, ?, 0, ?, ?)`)
+            .run(idValue, agentId, ordinal, kind, state, timestamp, state === 'OPEN' ? null : timestamp);
+    }
+    #touchContext(agentId) {
+        this.#database.prepare('UPDATE agents SET context_revision = context_revision + 1, revision = revision + 1, updated_at = ? WHERE id = ?')
+            .run(now(), agentId);
+    }
+    #activeProject(projectId) {
+        if (this.#require('projects', projectId).archived_at !== null)
+            fail('PROJECT_ARCHIVED', 409, 'The Project is archived.');
+    }
+    #ownedTask(taskId, projectId) {
+        owned(this.#require('tasks', taskId), 'project_id', projectId);
+    }
+    #ownedAgent(agentId, projectId) {
+        this.#ownedTask(String(this.#require('agents', agentId).task_id), projectId);
+    }
+    #expect(row, revision) {
+        if (Number(row.revision) !== revision)
+            fail('REVISION_CONFLICT', 409, 'The resource changed before this command was applied.');
+    }
+    #require(table, entityId) {
+        const row = this.#database.prepare(`SELECT * FROM ${table} WHERE id = ?`).get(entityId);
+        if (row === undefined)
+            fail(`${table.replaceAll('_', '').replace(/s$/, '').toUpperCase()}_NOT_FOUND`, 404, 'The requested resource does not exist.');
+        return row;
+    }
+    #one(sql, ...parameters) {
+        const row = this.#database.prepare(sql).get(...parameters);
+        if (row === undefined)
+            fail('DATABASE_CORRUPT', 503, 'An expected database row is missing.');
+        return row;
+    }
+    /**
+     * The Workspaces a Task touches, keyed by Task. A Task has no Workspace of its own -- the
+     * binding is `agents.workspace_id` -- and a Task may hold several Root Agents, so the answer is
+     * a set rather than one value. Resolved in a single statement for the whole page: doing it per
+     * Task is the N+1 that the sidebar previously paid for a Workspace grouping key.
+     */
+    #taskWorkspaceIds(taskIds) {
+        const result = new Map();
+        if (taskIds.length === 0)
+            return result;
+        const rows = this.#all(`SELECT DISTINCT task_id, workspace_id FROM agents WHERE task_id IN (${taskIds.map(() => '?').join(', ')}) ORDER BY workspace_id`, ...taskIds);
+        for (const row of rows) {
+            const key = String(row.task_id);
+            const existing = result.get(key);
+            if (existing === undefined)
+                result.set(key, [String(row.workspace_id)]);
+            else
+                existing.push(String(row.workspace_id));
+        }
+        return result;
+    }
+    #all(sql, ...parameters) {
+        return this.#database.prepare(sql).all(...parameters);
+    }
+    #count(sql, ...parameters) {
+        return Number(this.#one(sql, ...parameters).count);
+    }
+    #nextOrdinal(table, field, ownerId) {
+        return Number(this.#one(`SELECT COALESCE(MAX(ordinal), -1) + 1 AS ordinal FROM ${table} WHERE ${field} = ?`, ownerId).ordinal);
+    }
+    #page(sql, parameters, options, order = 'updated_at DESC, id DESC') {
+        const revision = this.stateRevision();
+        const scope = digest({ sql, parameters: parameters, order });
+        const offset = decodeCursor(options.cursor, revision, scope);
+        const rows = this.#all(`${sql} ORDER BY ${order} LIMIT ? OFFSET ?`, ...parameters, options.limit + 1, offset);
+        const items = rows.slice(0, options.limit).map(doc);
+        return { items, nextCursor: rows.length > options.limit ? encodeCursor(offset + options.limit, revision, scope) : null, collectionRevision: revision };
+    }
+}
+/**
+ * The `CallSummary.legacy_state` projection of the canonical `state`/`wait_reason` pair, per 02A §287.
+ * `YIELDED` is unreachable: nothing stores a yielded flag or timestamp, so a terminal Call reports
+ * `COMPLETED` regardless of outcome, exactly as the physical column allows.
+ */
+function legacyCallState(call) {
+    const state = call.state;
+    if (state === 'WAITING')
+        return call.wait_reason === 'user_input' ? 'WAITING_USER' : 'WAITING_REVIEW';
+    if (state === 'RUNNING')
+        return 'EXECUTING';
+    if (state === 'TERMINAL')
+        return 'COMPLETED';
+    return 'QUEUED';
+}
+/** The distinct non-null string values of one field across a page of documents. */
+function ids(documents, field) {
+    return [...new Set(documents.map((entry) => entry[field]).filter((value) => typeof value === 'string'))];
+}
+function doc(row) {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+        if (key.endsWith('_json')) {
+            if (value !== null && typeof value !== 'string')
+                fail('DATABASE_CORRUPT', 503, 'A stored JSON field is invalid.');
+            result[key.slice(0, -5)] = parseJson(value);
+        }
+        else if (booleans.has(key))
+            result[key] = Number(value) === 1;
+        else if (value === null || typeof value === 'string' || typeof value === 'number')
+            result[key] = value;
+        else
+            fail('DATABASE_CORRUPT', 503, 'A stored row contains an unsupported value.');
+    }
+    return result;
+}
+const booleans = new Set(['is_default', 'visible', 'locked', 'complete', 'loaded', 'truncated', 'outcome_unknown', 'auto_review_passed', 'initial_step_pending', 'existed_before']);
+/** The table each published entity type lives in, used to resolve its owner and revision. */
+const TABLE_BY_ENTITY = {
+    project: 'projects', workspace: 'workspaces', task: 'tasks', session: 'sessions', agent: 'agents',
+    pending_message: 'pending_messages', run: 'runs', step: 'steps', model_attempt: 'model_attempts',
+    call: 'calls', message: 'messages', context_item: 'context_items',
+    context_override: 'context_overrides', result: 'results', artifact: 'artifacts'
+};
+/** The column naming each entity's owner, which a subscriber uses to refresh the owning view. */
+const OWNERSHIP = {
+    workspace: { column: 'project_id' }, task: { column: 'project_id' }, session: { column: 'task_id' },
+    agent: { column: 'session_id' }, pending_message: { column: 'agent_id' }, run: { column: 'agent_id' },
+    step: { column: 'run_id' }, model_attempt: { column: 'step_id' }, call: { column: 'step_id' },
+    message: { column: 'agent_id' }, context_item: { column: 'agent_id' },
+    context_override: { column: 'agent_id' }, result: { column: 'call_id' }, artifact: { column: 'project_id' }
+};
+/** The Route a subscriber re-reads for a changed entity. */
+function readRouteFor(type, entityId) {
+    const routes = {
+        project: `/api/v1/projects/${entityId}`,
+        task: `/api/v1/tasks/${entityId}`,
+        session: `/api/v1/sessions/${entityId}`,
+        agent: `/api/v1/agents/${entityId}`,
+        pending_message: `/api/v1/pending-messages/${entityId}`,
+        run: `/api/v1/runs/${entityId}`,
+        step: `/api/v1/steps/${entityId}`,
+        model_attempt: `/api/v1/model-attempts/${entityId}`,
+        call: `/api/v1/calls/${entityId}`,
+        message: `/api/v1/messages/${entityId}`,
+        context_item: `/api/v1/context/${entityId}`,
+        context_override: `/api/v1/context-overrides/${entityId}`,
+        result: `/api/v1/results/${entityId}`,
+        artifact: `/api/v1/artifacts/${entityId}/metadata`
+    };
+    return routes[type] ?? `/api/v1/${type}/${entityId}`;
+}
+function projectIdOf(row) {
+    return typeof row?.project_id === 'string' ? row.project_id : undefined;
+}
+function optionalScopeId(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * How many Runs a Session Snapshot carries. Read on every panel poll, so it is a window rather than the
+ * Session's whole history; the paged Run Route is where the rest lives.
+ */
+const SNAPSHOT_RUN_LIMIT = 50;
+function dedupeById(documents) {
+    const byId = new Map();
+    for (const entry of documents) {
+        if (typeof entry.id === 'string' && !byId.has(entry.id))
+            byId.set(entry.id, entry);
+    }
+    return [...byId.values()];
+}
+/**
+ * 02A `AttentionItem` for the Session Snapshot: the Calls that cannot progress without the user.
+ * Derived rather than stored -- `attention.required` is an event, and a client that reconnects after
+ * one was emitted still has to be able to see what is waiting.
+ */
+function attentionItems(calls) {
+    return calls
+        .filter((call) => call.state === 'WAITING')
+        .map((call) => ({
+        code: call.wait_reason === 'user_input' ? 'CALL_WAITING_USER' : 'CALL_WAITING_REVIEW',
+        entity_type: 'call',
+        entity_id: call.call_id ?? null,
+        agent_id: call.agent_id ?? null
+    }));
+}
+/**
+ * The one row to hop through to reach an Agent, for the entities that do not carry `agent_id`
+ * themselves. Everything else either has the column or has no Agent at all.
+ */
+const SCOPE_PARENT = {
+    step: { type: 'run', table: 'runs', column: 'run_id' },
+    partition: { type: 'step', table: 'steps', column: 'step_id' },
+    result: { type: 'call', table: 'calls', column: 'call_id' }
+};
+/**
+ * Turns a duplicate Workspace name into the rejection it is. `WORKSPACE_NAME_INVALID` is the closest
+ * documented code -- 07 lists no duplicate-name code -- so the message carries the detail.
+ */
+function uniqueName(name, write) {
+    try {
+        write();
+    }
+    catch (error) {
+        const code = typeof error === 'object' && error !== null && 'code' in error ? error.code : undefined;
+        if (code === 'SQLITE_CONSTRAINT_UNIQUE') {
+            fail('WORKSPACE_NAME_INVALID', 422, `A Workspace named ${name} already exists in this Project.`);
+        }
+        throw error;
+    }
+}
+function refs(...entries) {
+    return entries.map(([type, entryId]) => ({ type, id: entryId }));
+}
+function messageIdsForWrite(runId = id('run')) {
+    return {
+        messageId: id('message'),
+        pendingId: id('pending'),
+        runId,
+        contextId: id('context'),
+        turnGroupId: id('turn')
+    };
+}
+function messageRefs(ids) {
+    return [
+        ['message', ids.messageId],
+        ['pending_message', ids.pendingId],
+        ['run', ids.runId],
+        ['turn_group', ids.turnGroupId],
+        ['context_item', ids.contextId]
+    ];
+}
+function owned(row, field, expected) {
+    if (String(row[field]) !== expected)
+        fail('PROJECT_NOT_FOUND', 404, 'The requested resource does not belong to the Project.');
+}
+function encodeCursor(offset, revision, scope) {
+    return Buffer.from(JSON.stringify({ offset, revision, scope })).toString('base64url');
+}
+function decodeCursor(cursor, revision, scope) {
+    if (cursor === undefined)
+        return 0;
+    let value;
+    try {
+        value = JSON.parse(Buffer.from(cursor, 'base64url').toString());
+    }
+    catch {
+        fail('CURSOR_INVALID', 400, 'The cursor is invalid.');
+    }
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        fail('CURSOR_INVALID', 400, 'The cursor is invalid.');
+    const parsed = value;
+    if (!Number.isSafeInteger(parsed.offset) || typeof parsed.offset !== 'number' || parsed.offset < 0 || typeof parsed.revision !== 'number' || typeof parsed.scope !== 'string')
+        fail('CURSOR_INVALID', 400, 'The cursor is invalid.');
+    if (parsed.scope !== scope)
+        fail('CURSOR_INVALID', 400, 'The cursor belongs to another collection.');
+    if (parsed.revision !== revision)
+        fail('PAGE_REVISION_CONFLICT', 409, 'The paged collection changed.');
+    return parsed.offset;
+}
+function validateAnswer(prompt, answer) {
+    if (answer === null)
+        fail('USER_INPUT_INVALID', 422, 'A user answer is required.');
+    if (prompt?.kind === 'policy_approval') {
+        if (policyAnswer(answer) === null)
+            fail('USER_INPUT_INVALID', 422, 'The policy answer must approve or reject the Call.');
+        return;
+    }
+    if (prompt?.kind === 'mcp_input_required') {
+        if (jsonRecord(answer) === null)
+            fail('USER_INPUT_INVALID', 422, 'MCP input responses must be an object.');
+        return;
+    }
+    if (prompt?.kind !== 'question')
+        return;
+    const answers = Array.isArray(answer) ? answer : [answer];
+    if (answers.length === 0 || (Array.isArray(answer) && prompt.multi_select !== true))
+        fail('USER_INPUT_INVALID', 422, 'The question accepts a non-empty answer of the configured shape.');
+    const options = [];
+    if (Array.isArray(prompt.options)) {
+        for (const entry of prompt.options) {
+            const value = jsonRecord(entry)?.value;
+            if (typeof value === 'string')
+                options.push(value);
+        }
+    }
+    if (prompt.allow_freeform === false && answers.some((entry) => typeof entry !== 'string' || !options.includes(entry))) {
+        fail('USER_INPUT_INVALID', 422, 'The answer is not one of the configured options.');
+    }
+}
+function policyAnswer(value) {
+    const selected = typeof value === 'string' ? value : jsonRecord(value)?.decision;
+    return selected === 'approve' || selected === 'reject' ? selected : null;
+}
+function jsonRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    return value;
+}
+function stringField(value) {
+    if (typeof value !== 'string')
+        fail('DATABASE_CORRUPT', 503, 'A stored string field is invalid.');
+    return value;
+}
+function strings(value) {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string'))
+        fail('DATABASE_CORRUPT', 503, 'A stored string list is invalid.');
+    return value;
+}
+function messageIngressResponse(value) {
+    return {
+        message: documentField(value.message),
+        pending: documentField(value.pending),
+        run: documentField(value.run)
+    };
+}
+function documentField(value) {
+    if (!isJsonObject(value))
+        fail('DATABASE_CORRUPT', 503, 'An ingress response field is invalid.');
+    return value;
+}
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function rawJson(row) {
+    return Object.fromEntries(Object.entries(row).map(([key, value]) => {
+        if (value === null || typeof value === 'string' || typeof value === 'number')
+            return [key, value];
+        fail('DATABASE_CORRUPT', 503, 'A database row cannot be exported.');
+    }));
+}