@lensagent/core 0.1.0 → 0.1.2

package/dist/store/store.js

@@ -1,18 +1,57 @@
+import { assertContextBoundaries, assertContextTransition, boundaryMessages, contextToolCalls } from '../core/context-boundaries.js';
 import { digest, id, json, now, parseJson } from '../core/codec.js';
-import { fail } from '../core/domain.js';
+import { fail, LensError } from '../core/domain.js';
+import { estimateTokens } from '../runtime/tokenizer.js';
 import { policyPrompt } from '../runtime/policy.js';
+import { activeContextItems } from '../core/context.js';
 export class Store {
+    observability;
     #database;
     #events;
     #eventLog;
-    constructor(database, events, eventLog) {
+    #batchChanges;
+    /** Persist a model tool batch before reviews or execution can yield control. */
+    commitToolBatch(projectId, command) {
+        const changes = [];
+        return this.#write(projectId, changes, () => {
+            this.#batchChanges = changes;
+            try {
+                return command();
+            }
+            finally {
+                this.#batchChanges = undefined;
+            }
+        });
+    }
+    constructor(database, events, eventLog, observability) {
+        this.observability = observability;
         this.#database = database;
         this.#events = events;
         this.#eventLog = eventLog;
+        this.#database.transaction(() => {
+            const migrated = new Set(this.#all("SELECT DISTINCT agent_id FROM context_items WHERE kind = 'compaction' AND role != 'assistant'").map((row) => String(row.agent_id)));
+            if (migrated.size > 0) {
+                const timestamp = now();
+                this.#database.prepare(`UPDATE messages SET role = 'assistant' WHERE id IN (SELECT source_id FROM context_items WHERE kind = 'compaction')`).run();
+                this.#database.prepare(`UPDATE context_items SET role = 'assistant', revision = revision + 1, updated_at = ? WHERE kind = 'compaction' AND role != 'assistant'`).run(timestamp);
+                this.#database.prepare('UPDATE instance SET state_revision = state_revision + 1 WHERE id = 1').run();
+            }
+            for (const row of this.#all('SELECT id FROM agents')) {
+                const agentId = String(row.id);
+                if (migrated.has(agentId))
+                    this.#touchContext(agentId);
+                else
+                    this.#syncWorkingContext(agentId);
+            }
+        })();
     }
     async close() {
-        await this.#eventLog?.close();
-        this.#database.close();
+        try {
+            await this.#eventLog?.close();
+        }
+        finally {
+            this.#database.close();
+        }
     }
     instance() {
         return doc(this.#one('SELECT * FROM instance WHERE id = 1'));
@@ -33,23 +72,16 @@ export class Store {
         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 interruptedAgentIds = new Set(this.#all(`SELECT DISTINCT agent_id FROM runs WHERE state != 'TERMINAL'`).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);
+            interrupted.push(...this.#materializeInterruptedCalls(timestamp));
+            for (const row of this.#all("SELECT * FROM calls WHERE state != 'TERMINAL'")) {
+                interrupted.push(...this.#interruptCall(row, row.state === 'RUNNING' ? 'PROCESS_INTERRUPTED' : 'RECOVERY_CANCELLED', 'Execution stopped when the process exited; the Call will not be resumed.', timestamp));
             }
+            interrupted.push(...this.#recoverResultContext(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);
@@ -81,7 +113,7 @@ export class Store {
                     .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')");
+            const runs = this.#all("SELECT id FROM runs WHERE state != 'TERMINAL'");
             for (const row of runs) {
                 const runId = String(row.id);
                 const compactionFailed = compactionRunIds.has(runId);
@@ -97,6 +129,7 @@ export class Store {
                 this.#database.prepare('UPDATE instance SET state_revision = state_revision + 1 WHERE id = 1').run();
         });
         transaction();
+        this.#observe(interrupted);
         return interrupted;
     }
     /**
@@ -115,7 +148,7 @@ export class Store {
     getProject(projectId) {
         return doc(this.#require('projects', projectId));
     }
-    createProject(name, paths) {
+    createProject(name, paths, executorId = 'remote') {
         const projectId = id('project');
         const workspaceId = id('workspace');
         const timestamp = now();
@@ -125,6 +158,7 @@ export class Store {
             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);
+            this.#database.prepare('UPDATE workspaces SET executor_ref = ? WHERE id = ?').run(executorId, workspaceId);
             return this.getProject(projectId);
         });
     }
@@ -183,7 +217,7 @@ export class Store {
         owned(row, 'project_id', projectId);
         return this.#workspace(row);
     }
-    createWorkspace(projectId, name, paths, makeDefault) {
+    createWorkspace(projectId, name, paths, makeDefault, executorId = 'remote') {
         const workspaceId = id('workspace');
         const timestamp = now();
         return this.#write(projectId, refs(['workspace', workspaceId]), () => {
@@ -198,6 +232,7 @@ export class Store {
                     .run(workspaceId, projectId, name, makeDefault ? 1 : 0, timestamp, timestamp);
             });
             this.#replaceWorkspacePaths(workspaceId, paths);
+            this.#database.prepare('UPDATE workspaces SET executor_ref = ? WHERE id = ?').run(executorId, workspaceId);
             return this.getWorkspace(projectId, workspaceId);
         });
     }
@@ -324,14 +359,14 @@ export class Store {
             return this.getTask(projectId, taskId);
         });
     }
-    deleteTask(projectId, taskId, expectedRevision) {
+    deleteTask(projectId, taskId, expectedRevision, executorStateId) {
         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]);
+            return this.#purgeTaskRows(projectId, [taskId], executorStateId);
         });
     }
     listSessions(projectId, taskId, options, archived = false) {
@@ -352,10 +387,10 @@ export class Store {
     #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 phases = this.#all("SELECT r.* FROM runs r JOIN agents a ON a.id = r.agent_id WHERE a.session_id = ? AND r.state != 'TERMINAL'", sessionId)
+            .map(run => this.#runPhase(doc(run)));
+        const waiting = phases.filter(phase => phase === 'WAITING_USER').length;
+        const running = phases.filter(phase => phase !== 'WAITING_USER' && phase !== 'QUEUED').length;
         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
@@ -414,11 +449,11 @@ export class Store {
         };
     }
     /**
-     * 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.
+     * 02A `AgentSessionRuntimeSummary`. Source and Working Context revisions are independent.
      */
     #agentRuntime(agent) {
         const agentId = stringField(agent.id);
+        const working = this.#database.prepare('SELECT revision, digest FROM working_contexts WHERE agent_id = ?').get(agentId);
         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,
@@ -428,8 +463,8 @@ export class Store {
             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,
+            work_context_revision: working === undefined ? null : Number(working.revision),
+            work_context_digest: working === undefined ? null : String(working.digest),
             request_context_frame_digest: null,
             token_estimate: null
         };
@@ -455,9 +490,10 @@ export class Store {
             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,
+            initial_step_pending: run.initial_step_pending === true,
             tool_continuation_pending: false,
-            status: state === 'TERMINAL' && outcome !== null ? terminal[outcome] ?? 'FAILED' : state,
+            phase: this.#runPhase(run),
+            status: state === 'TERMINAL' && outcome !== null ? terminal[outcome] ?? 'FAILED' : this.#runPhase(run) === 'WAITING_USER' ? 'WAITING' : state,
             started_at: run.started_at ?? null,
             ended_at: run.ended_at ?? null,
             error_code: run.error_code ?? null
@@ -613,6 +649,30 @@ export class Store {
      * `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.
      */
+    #runPhase(run) {
+        if (run.state === 'TERMINAL')
+            return 'TERMINAL';
+        if (run.state === 'READY')
+            return 'QUEUED';
+        const step = this.#database.prepare("SELECT * FROM steps WHERE run_id = ? AND state != 'TERMINAL' ORDER BY ordinal DESC LIMIT 1").get(run.id);
+        return step === undefined ? 'PREPARING' : this.#stepPhase(doc(step));
+    }
+    #stepPhase(step) {
+        if (step.state === 'TERMINAL')
+            return 'TERMINAL';
+        if (this.#count("SELECT COUNT(*) AS count FROM model_attempts WHERE step_id = ? AND state IN ('PREPARED', 'RUNNING')", step.id) > 0)
+            return 'MODEL_STREAMING';
+        const calls = this.#all("SELECT state, wait_reason FROM calls WHERE step_id = ? AND state != 'TERMINAL'", step.id);
+        if (calls.some(call => call.state === 'RUNNING'))
+            return 'TOOLS_RUNNING';
+        if (calls.some(call => call.state === 'WAITING' && call.wait_reason === 'policy_review'))
+            return 'POLICY_REVIEW';
+        if (calls.some(call => call.state === 'WAITING'))
+            return 'WAITING_USER';
+        if (calls.some(call => call.state === 'QUEUED'))
+            return 'TOOLS_QUEUED';
+        return 'PREPARING';
+    }
     #stepRuntime(step) {
         const state = step.state ?? null;
         const outcome = typeof step.outcome === 'string' ? step.outcome : null;
@@ -628,8 +688,9 @@ export class Store {
             outcome,
             status: state === 'TERMINAL'
                 ? terminal[outcome ?? ''] ?? 'FAILED'
-                : state === 'WAITING' ? 'WAITING_CALLS' : 'MODEL_STREAMING',
-            stream_closed: state !== 'RUNNING',
+                : this.#stepPhase(step),
+            phase: this.#stepPhase(step),
+            stream_closed: this.#stepPhase(step) !== 'MODEL_STREAMING',
             reactive_compaction_attempted: false,
             assistant_message_id: null,
             ended_at: null,
@@ -702,6 +763,8 @@ export class Store {
             ...(queuedIds === null ? [] : messageRefs(queuedIds))
         ];
         return this.#write(projectId, refs(...changes), () => {
+            if (input.expectedParentContextRevision !== undefined && this.getAgent(projectId, parentAgentId).context_revision !== input.expectedParentContextRevision)
+                fail('REVISION_CONFLICT', 409, 'Parent Context changed while preparing the Subagent.');
             const timestamp = now();
             this.#insertAgent(projectId, agentId, {
                 taskId: stringField(parent.task_id),
@@ -716,12 +779,20 @@ export class Store {
                 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);
+                const working = this.#workingItems(parentAgentId);
+                if (working.length > 0)
+                    this.#copyContextRange(parentAgentId, agentId, Math.max(...working.map((item) => Number(item.ordinal))), timestamp, undefined, true);
             }
             else if (input.forkContext === 'compact' && input.compactSummary !== undefined) {
-                this.#insertStandaloneContextMessage(agentId, 'system', input.compactSummary, 'compaction', timestamp);
+                this.#insertStandaloneContextMessage(agentId, 'assistant', input.compactSummary, 'compaction', timestamp);
+                const checkpoint = this.#one("SELECT id FROM context_items WHERE agent_id = ? AND kind = 'compaction'", agentId);
+                this.#database.prepare('INSERT INTO context_compactions(context_item_id, source_revision, covered_item_ids_json, focus) VALUES (?, ?, ?, ?)')
+                    .run(checkpoint.id, Number(parent.context_revision), json(input.compactCoveredItemIds ?? []), input.compactFocus ?? null);
+                const retained = input.compactRetainedItemIds ?? [];
+                if (retained.length > 0) {
+                    const through = Math.max(...retained.map((itemId) => Number(this.#require('context_items', itemId).ordinal)));
+                    this.#copyContextRange(parentAgentId, agentId, through, timestamp, retained);
+                }
             }
             if (input.initialPrompt !== undefined)
                 this.#insertStandaloneContextMessage(agentId, 'system', input.initialPrompt, 'message', timestamp);
@@ -807,10 +878,7 @@ export class Store {
             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;
@@ -835,32 +903,53 @@ export class Store {
             return response;
         });
     }
-    async waitForSubagent(projectId, sourceAgentId, targetAgentId, timeoutMs, signal) {
+    async waitForSubagent(projectId, sourceAgentId, targetAgentId, timeoutMs, signal, afterMessageId) {
         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) {
+        if (source.session_id !== target.session_id || sourceAgentId === targetAgentId)
+            fail('SUBAGENT_TARGET_INVALID', 400, 'The target must be another Agent in the same Session.');
+        let after = 0;
+        if (afterMessageId !== undefined) {
+            const cursor = this.#database.prepare('SELECT rowid FROM messages WHERE id = ? AND agent_id = ? AND source_agent_id = ?').get(afterMessageId, sourceAgentId, targetAgentId);
+            if (cursor === undefined)
+                fail('INVALID_INPUT', 400, 'The message cursor must identify a message from the target to this Agent.');
+            after = Number(cursor.rowid);
+        }
+        return this.#events.waitFor(projectId, () => {
+            const message = this.#database.prepare(`SELECT * FROM messages WHERE agent_id = ? AND source_agent_id = ? AND rowid > ?
+        AND COALESCE(json_extract(metadata_json, '$.context_copy'), 0) = 0 ORDER BY rowid LIMIT 1`)
+                .get(sourceAgentId, targetAgentId, after);
+            if (message !== undefined) {
+                const pending = this.#database.prepare('SELECT * FROM pending_messages WHERE message_id = ?').get(message.id);
                 return {
                     status: 'message',
                     target_agent_id: targetAgentId,
-                    pending_message: doc(pending),
-                    message: this.getMessage(projectId, String(pending.message_id))
+                    pending_message: pending === undefined ? null : doc(pending),
+                    message: this.getMessage(projectId, String(message.id)),
+                    after_message_id: String(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()))));
-        }
+            if (activeRunIds.length === 0) {
+                const run = this.#database.prepare('SELECT * FROM runs WHERE agent_id = ? ORDER BY rowid DESC LIMIT 1').get(targetAgentId);
+                const answer = run === undefined ? undefined : this.#database.prepare(`SELECT m.id FROM messages m JOIN context_items ci ON ci.source_id = m.id AND ci.kind = 'message'
+          WHERE ci.agent_id = ? AND m.role = 'assistant' AND m.source_agent_id IS NULL
+          AND ci.turn_group_id IN (SELECT turn_group_id FROM steps WHERE run_id = ?)
+          ORDER BY ci.ordinal DESC LIMIT 1`).get(targetAgentId, run.id);
+                return {
+                    status: run === undefined ? 'idle' : run.outcome === 'success' ? 'completed' : String(run.outcome),
+                    target_agent_id: targetAgentId,
+                    active_run_ids: [],
+                    run: run === undefined ? null : this.getRun(projectId, String(run.id)),
+                    message: answer === undefined ? null : this.getMessage(projectId, String(answer.id))
+                };
+            }
+            return undefined;
+        }, signal, {
+            ms: Math.min(timeoutMs, 120000),
+            error: new LensError('CALL_TIMEOUT', 408, 'The Subagent wait timed out.', { target_agent_id: targetAgentId })
+        });
     }
     listPending(projectId, agentId, options) {
         this.getAgent(projectId, agentId);
@@ -880,9 +969,10 @@ export class Store {
             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 = ?`)
+            const updated = 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);
+            if (updated.changes > 0)
+                this.#touchContext(agentId);
             return this.getPending(projectId, pendingId);
         });
     }
@@ -896,6 +986,10 @@ export class Store {
             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);
+            const updated = this.#database.prepare(`UPDATE context_items SET visible = 0, revision = revision + 1, updated_at = ? WHERE agent_id = ? AND kind = 'message' AND source_id = ?`)
+                .run(timestamp, agentId, current.message_id);
+            if (updated.changes > 0)
+                this.#touchContext(agentId);
             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);
@@ -909,7 +1003,8 @@ export class Store {
             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));
+            const offset = this.#nextOrdinal('pending_messages', 'agent_id', agentId);
+            ids.forEach((entry, ordinal) => temporary.run(ordinal + offset, 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);
         });
@@ -1057,23 +1152,12 @@ export class Store {
         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 changes = [...refs(['run', runId], ['step', stepId], ['agent', agentId])];
+        return this.#write(projectId, changes, () => {
             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 turnGroupId = id('turn');
+            this.#insertTurnGroup(turnGroupId, agentId, 'turn', 'OPEN', timestamp);
+            changes.push({ type: 'turn_group', id: turnGroupId }, ...this.#appendPendingContext(agentId, turnGroupId, pending, timestamp));
             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'`)
@@ -1134,6 +1218,7 @@ export class Store {
             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);
+            this.#database.prepare('UPDATE model_attempts SET request_json = ? WHERE id = ?').run(json(input.request), attemptId);
             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);
@@ -1149,9 +1234,28 @@ export class Store {
             this.getAgent(projectId, ownerId);
         else
             this.getStep(projectId, ownerId);
-        return this.#page(`SELECT * FROM model_attempts WHERE ${field} = ?`, [ownerId], options, 'sequence DESC, id DESC');
+        return this.#page(`SELECT * FROM model_attempts WHERE ${field} = ?`, [ownerId], options, 'rowid DESC');
+    }
+    latestModelAttempt(projectId, agentId, kind, model) {
+        this.getAgent(projectId, agentId);
+        const row = this.#database.prepare(`SELECT * FROM model_attempts WHERE agent_id = ? AND state != 'PREPARED' ${kind === undefined ? '' : 'AND kind = ?'} ${model === undefined ? '' : 'AND model = ?'} ORDER BY rowid DESC LIMIT 1`)
+            .get(agentId, ...(kind === undefined ? [] : [kind]), ...(model === undefined ? [] : [model]));
+        return row === undefined ? null : doc(row);
     }
-    transitionAttempt(projectId, attemptId, from, to, outcome = null, usage = null, errorCode = null) {
+    cacheUsage(projectId, agentId) {
+        this.getAgent(projectId, agentId);
+        const row = this.#one(`SELECT COUNT(*) AS attempts,
+      SUM(CASE WHEN json_type(usage_json, '$.cache_read_tokens') = 'integer' THEN 1 ELSE 0 END) AS reported_attempts,
+      SUM(CASE WHEN json_type(usage_json, '$.cache_read_tokens') = 'integer' THEN json_extract(usage_json, '$.input_tokens') ELSE 0 END) AS reported_input_tokens,
+      SUM(json_extract(usage_json, '$.cache_read_tokens')) AS cache_read_tokens,
+      SUM(json_extract(usage_json, '$.cache_write_tokens')) AS cache_write_tokens,
+      SUM(json_extract(usage_json, '$.uncached_input_tokens')) AS uncached_input_tokens
+      FROM model_attempts WHERE agent_id = ?`, agentId);
+        const denominator = Number(row.reported_input_tokens ?? 0);
+        return { ...doc(row), unknown_attempts: Number(row.attempts) - Number(row.reported_attempts ?? 0),
+            reported_hit_ratio: denominator > 0 ? Number(row.cache_read_tokens) / denominator : null };
+    }
+    transitionAttempt(projectId, attemptId, from, to, outcome = null, usage = null, errorCode = null, observation = null) {
         return this.#write(projectId, refs(['model_attempt', attemptId]), () => {
             const current = this.#require('model_attempts', attemptId);
             this.#ownedAgent(String(current.agent_id), projectId);
@@ -1159,6 +1263,8 @@ export class Store {
                 .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.');
+            if (observation !== null)
+                this.#database.prepare('UPDATE model_attempts SET observation_json = ? WHERE id = ?').run(json(observation), attemptId);
             return this.getAttempt(projectId, attemptId);
         });
     }
@@ -1197,8 +1303,8 @@ export class Store {
                 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);
+            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, continuation_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), json(input.prompt === undefined ? {} : { prompt: input.prompt }), 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);
@@ -1236,15 +1342,12 @@ export class Store {
         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,
+            arguments: call.input ?? null,
             user_prompt: summary.user_prompt ?? null,
             result_id: result === undefined ? null : String(result.id),
             agent_id: call.agent_id ?? null
@@ -1286,7 +1389,8 @@ export class Store {
             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),
+            auto_review: call.auto_review ?? null,
+            user_prompt: jsonRecord(jsonRecord(call.continuation)?.prompt),
             outcome: call.outcome ?? null,
             outcome_unknown: call.outcome_unknown === true,
             yielded_at: null,
@@ -1349,13 +1453,13 @@ export class Store {
                 this.#expect(current, expectedRevision);
             const state = String(current.state);
             if (decision !== 'cancel') {
-                const prompt = jsonRecord(jsonRecord(parseJson(String(current.input_json)))?.prompt);
+                const prompt = jsonRecord(jsonRecord(doc(current).continuation)?.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);
+                this.#database.prepare(`UPDATE calls SET state = 'QUEUED', wait_reason = NULL, continuation_json = '{}', revision = revision + 1, updated_at = ? WHERE id = ?`).run(now(), callId);
                 return { call: this.getCall(projectId, callId), result: null };
             }
             if (state === 'TERMINAL')
@@ -1376,8 +1480,8 @@ export class Store {
             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;
+            const continuation = jsonRecord(doc(current).continuation);
+            const prompt = continuation?.prompt;
             validateAnswer(jsonRecord(prompt), answer);
             if (jsonRecord(prompt)?.kind === 'policy_approval' && policyAnswer(answer) === 'reject') {
                 const resultId = id('result');
@@ -1387,46 +1491,209 @@ export class Store {
                     .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);
+            const nextContinuation = jsonRecord(prompt)?.kind === 'policy_approval' ? {} : { ...continuation, answer };
+            this.#database.prepare(`UPDATE calls SET continuation_json = ?, state = 'QUEUED', wait_reason = NULL, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                .run(json(nextContinuation), now(), callId);
             return { call: this.getCall(projectId, callId), result: null };
         });
     }
-    reviewCall(projectId, callId, approved) {
+    reviewCall(projectId, callId, review) {
         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);
+            const approved = review.status === 'reviewed' && review.outcome === 'allow';
+            this.#database.prepare(`UPDATE calls SET continuation_json = ?, state = ?, wait_reason = ?, auto_review_passed = ?, auto_review_json = ?, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                .run(approved ? json({}) : json({ prompt: policyPrompt(String(current.capability_id), review.rationale) }), approved ? 'QUEUED' : 'WAITING', approved ? null : 'user_input', review.status === 'failed' ? null : approved ? 1 : 0, json(review), now(), callId);
+            return this.getCall(projectId, callId);
+        });
+    }
+    autoReviewContext(projectId, agentId) {
+        const agent = this.getAgent(projectId, agentId);
+        const authorization = [];
+        let ancestor = agent;
+        while (ancestor !== null) {
+            // Read original messages, including compacted ones. Copied/delegated text and deleted
+            // pending messages must not turn into user permission merely because their role is user.
+            authorization.push(...this.#all(`SELECT m.id, m.agent_id, m.content, m.created_at, m.rowid AS sequence,
+        COALESCE(json_extract(m.metadata_json, '$.ingress_origin'), 'unknown') AS ingress_origin
+        FROM messages m WHERE m.agent_id = ? AND m.role = 'user' AND m.source_agent_id IS NULL
+        AND (m.metadata_json IS NULL OR json_extract(m.metadata_json, '$.ingress_origin') = 'user')
+        AND (EXISTS (SELECT 1 FROM pending_messages p WHERE p.message_id = m.id)
+          OR EXISTS (SELECT 1 FROM context_items ci JOIN context_turn_groups g ON g.id = ci.turn_group_id
+            WHERE ci.source_id = m.id AND ci.kind = 'message' AND g.state != 'ABORTED'))
+        ORDER BY m.rowid`, stringField(ancestor.id)).map(doc));
+            ancestor = typeof ancestor.parent_agent_id === 'string' ? this.getAgent(projectId, ancestor.parent_agent_id) : null;
+        }
+        authorization.sort((a, b) => Number(a.sequence) - Number(b.sequence));
+        const evidence = this.#all(`SELECT ci.role, ci.kind, ci.tool_name,
+      substr(ci.content, 1, 1000) AS excerpt, CASE WHEN length(ci.content) > 1000 THEN 1 ELSE 0 END AS truncated
+      FROM context_items ci JOIN context_turn_groups g ON g.id = ci.turn_group_id
+      WHERE ci.agent_id = ? AND ci.visible = 1 AND g.state != 'ABORTED'
+      ORDER BY ci.ordinal DESC LIMIT 12`, agentId).map(doc).reverse();
+        return { authorization, workspacePaths: this.projectWorkspacePaths(projectId, stringField(agent.workspace_id)), evidence };
+    }
+    consumePendingForStep(projectId, stepId) {
+        const step = this.getStep(projectId, stepId);
+        const run = this.getRun(projectId, stringField(step.run_id));
+        const agentId = stringField(run.agent_id);
+        const pending = this.#all('SELECT * FROM pending_messages WHERE agent_id = ? ORDER BY ordinal, id', agentId);
+        if (pending.length === 0)
+            return [];
+        const changes = [...refs(['agent', agentId], ['run', stringField(run.id)], ...pending.map(entry => ['pending_message', String(entry.id)]))];
+        return this.#write(projectId, changes, () => {
+            if (step.state === 'TERMINAL' || run.state === 'TERMINAL')
+                fail('RUN_STATE_CONFLICT', 409, 'The Run no longer accepts pending input.');
+            this.#assertContext(agentId, false);
+            const timestamp = now();
+            changes.push(...this.#appendPendingContext(agentId, stringField(step.turn_group_id), pending, timestamp));
+            const goals = [...new Set([...strings(run.goal_message_ids ?? []), ...pending.map(entry => String(entry.message_id))])];
+            this.#database.prepare('UPDATE runs SET goal_message_ids_json = ?, revision = revision + 1, updated_at = ? WHERE id = ?')
+                .run(json(goals), timestamp, run.id);
+            const remove = this.#database.prepare('DELETE FROM pending_messages WHERE id = ?');
+            for (const entry of pending)
+                remove.run(entry.id);
+            return pending.map(doc);
+        });
+    }
+    #appendPendingContext(agentId, turnGroupId, pending, timestamp) {
+        const changes = [];
+        for (const entry of pending) {
+            const item = this.#database.prepare(`SELECT * FROM context_items WHERE agent_id = ? AND kind = 'message' AND source_id = ?`).get(agentId, entry.message_id);
+            // claimRun has already placed its initial batch in this group and queue order.
+            if (item?.turn_group_id === turnGroupId)
+                continue;
+            const contextId = item === undefined ? id('context') : String(item.id);
+            const ordinal = this.#nextOrdinal('context_items', 'agent_id', agentId);
+            const groupOrdinal = this.#nextOrdinal('context_items', 'turn_group_id', turnGroupId);
+            if (item === undefined) {
+                const message = this.#require('messages', String(entry.message_id));
+                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, metadata_json) VALUES (?, ?, ?, ?, 'message', ?, 'user', ?, ?, 1, 0, 0, ?, ?, ?)`)
+                    .run(contextId, agentId, turnGroupId, groupOrdinal, entry.message_id, entry.content, ordinal, timestamp, timestamp, message.metadata_json);
+            }
+            else {
+                this.#database.prepare('UPDATE context_items SET turn_group_id = ?, turn_group_ordinal = ?, ordinal = ?, visible = 1, revision = revision + 1, updated_at = ? WHERE id = ?')
+                    .run(turnGroupId, groupOrdinal, ordinal, timestamp, item.id);
+                if (this.#count('SELECT COUNT(*) AS count FROM context_items WHERE turn_group_id = ?', item.turn_group_id) === 0) {
+                    this.#database.prepare('DELETE FROM context_turn_groups WHERE id = ? AND NOT EXISTS (SELECT 1 FROM steps WHERE turn_group_id = ?)').run(item.turn_group_id, item.turn_group_id);
+                    changes.push({ type: 'turn_group', id: String(item.turn_group_id) });
+                }
+            }
+            changes.push({ type: 'context_item', id: contextId });
+        }
+        if (changes.length > 0)
+            this.#touchContext(agentId);
+        return changes;
+    }
+    interruptCall(projectId, callId, errorCode, message) {
+        const changes = [];
+        return this.#write(projectId, changes, () => {
+            const call = this.#require('calls', callId);
+            owned(call, 'project_id', projectId);
+            changes.push(...this.#interruptCall(call, errorCode, message, now()));
             return this.getCall(projectId, callId);
         });
     }
-    startCall(projectId, callId) {
+    interruptProjectCalls(projectId) {
+        const changes = [];
+        this.#write(projectId, changes, () => {
+            for (const call of this.#all("SELECT * FROM calls WHERE project_id = ? AND state != 'TERMINAL'", projectId)) {
+                changes.push(...this.#interruptCall(call, 'PROCESS_INTERRUPTED', 'The runtime stopped; this Call will not be resumed.', now()));
+            }
+        });
+    }
+    #interruptCall(call, errorCode, message, timestamp) {
+        if (call.state === 'TERMINAL')
+            return [];
+        const running = call.state === 'RUNNING';
+        const outcome = errorCode === 'CALL_CANCELLED' || !running ? 'cancelled' : 'interrupted';
+        const detail = running ? `${message} External side effects may already have occurred.` : message;
+        this.#database.prepare("UPDATE calls SET state = 'TERMINAL', wait_reason = NULL, outcome = ?, outcome_unknown = ?, revision = revision + 1, updated_at = ? WHERE id = ?")
+            .run(outcome, running ? 1 : 0, timestamp, call.id);
+        const resultId = id('result');
+        this.#database.prepare('INSERT OR IGNORE INTO results(id, call_id, outcome, content_json, error_code, error_message, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+            .run(resultId, call.id, outcome, json({ error_code: errorCode, error_message: detail, outcome_unknown: running }), errorCode, detail, timestamp);
+        return [{ type: 'call', id: String(call.id) }, { type: 'result', id: resultId }];
+    }
+    callAdmission(projectId, callId) {
+        return this.#callAdmission(projectId, this.#callRow(projectId, callId));
+    }
+    #callAdmission(projectId, call) {
+        if (call.state !== 'QUEUED')
+            return 'inactive';
+        if (typeof call.parent_call_id === 'string') {
+            const parent = this.#callRow(projectId, call.parent_call_id);
+            if (parent.state !== 'RUNNING')
+                fail('CALL_PARENT_INACTIVE', 409, 'The parent Call is no longer running.');
+            if (call.source !== 'program' || parent.capability_id !== 'programmatic_tool_run' ||
+                typeof call.agent_id !== 'string' || typeof call.step_id !== 'string' || typeof call.attempt_id !== 'string' ||
+                parent.agent_id !== call.agent_id || parent.step_id !== call.step_id || parent.attempt_id !== call.attempt_id) {
+                fail('CALL_PARENT_INVALID', 409, 'The nested Call does not belong to its program parent.');
+            }
+            const frozen = this.#database.prepare('SELECT 1 FROM attempt_capabilities WHERE attempt_id = ? AND capability_id = ?')
+                .get(call.attempt_id, call.capability_id);
+            if (frozen === undefined)
+                fail('CAPABILITY_NOT_LOADED', 403, 'The nested Capability is outside the frozen model attempt.');
+            const selected = jsonRecord(parent.input)?.capabilityIds;
+            if (Array.isArray(selected) && !selected.includes(call.capability_id ?? null)) {
+                fail('CAPABILITY_NOT_LOADED', 403, 'The nested Capability is outside the parent program selection.');
+            }
+            // Program dependencies are inside the parent; its unfinished top-level batch cannot gate a child.
+            return 'ready';
+        }
+        if (typeof call.partition_id !== 'string')
+            return 'ready';
+        const partition = this.#require('call_partitions', call.partition_id);
+        if (partition.step_id !== call.step_id)
+            fail('CALL_PARTITION_INVALID', 409, 'The Call does not belong to its partition Step.');
+        const predecessor = this.#database.prepare(`SELECT 1 FROM calls c JOIN call_partitions p ON p.id = c.partition_id
+      WHERE p.step_id = ? AND p.ordinal < ? AND c.parent_call_id IS NULL
+      AND c.attempt_id IS ? AND c.state != 'TERMINAL' LIMIT 1`)
+            .get(partition.step_id, partition.ordinal, call.attempt_id ?? null);
+        return predecessor === undefined ? 'ready' : 'blocked';
+    }
+    startCall(projectId, callId, validate) {
         return this.#write(projectId, refs(['call', callId]), () => {
+            const call = this.#callRow(projectId, callId);
+            const admission = this.#callAdmission(projectId, call);
+            if (admission === 'blocked')
+                fail('CALL_BLOCKED', 409, 'An earlier top-level partition has not finished.');
+            if (admission === 'inactive')
+                fail('CALL_STATE_CONFLICT', 409, 'The Call is not queued.');
+            validate?.(call);
             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);
         });
     }
+    failQueuedCall(projectId, callId, errorCode, errorMessage, content = {}) {
+        const resultId = id('result');
+        const timestamp = now();
+        return this.#write(projectId, refs(['call', callId], ['result', resultId]), () => {
+            this.#callRow(projectId, callId);
+            const update = this.#database.prepare(`UPDATE calls SET state = 'TERMINAL', outcome = 'failed', wait_reason = NULL,
+        outcome_unknown = 0, revision = revision + 1, updated_at = ? WHERE id = ? AND state = 'QUEUED'`).run(timestamp, callId);
+            if (update.changes !== 1)
+                fail('CALL_STATE_CONFLICT', 409, 'Only a queued Call can fail without executing.');
+            this.#database.prepare(`INSERT INTO results(id, call_id, outcome, content_json, error_code, error_message, created_at)
+        VALUES (?, ?, 'failed', ?, ?, ?, ?)`).run(resultId, callId, json(content), errorCode, errorMessage, timestamp);
+            return { call: this.getCall(projectId, callId), result: doc(this.#require('results', resultId)) };
+        });
+    }
     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);
+            this.#database.prepare(`UPDATE calls SET state = 'WAITING', wait_reason = 'user_input', continuation_json = ?, revision = revision + 1, updated_at = ? WHERE id = ?`)
+                .run(json({ prompt }), now(), callId);
             return this.getCall(projectId, callId);
         });
     }
-    completeCall(projectId, callId, outcome, content, errorCode = null, errorMessage = null, artifacts = [], truncated = false) {
+    completeCall(projectId, callId, outcome, content, errorCode = null, errorMessage = null, artifacts = [], truncated = false, capture = 'unknown', stored = 'unknown') {
         const resultId = id('result');
         const timestamp = now();
         return this.#write(projectId, refs(['call', callId], ['result', resultId]), () => {
@@ -1436,6 +1703,7 @@ export class Store {
                 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);
+            this.#database.prepare('UPDATE results SET capture = ?, stored = ? WHERE id = ?').run(capture, stored, resultId);
             const link = this.#database.prepare('INSERT INTO result_artifacts(result_id, artifact_id) VALUES (?, ?)');
             for (const artifactId of artifacts)
                 link.run(resultId, artifactId);
@@ -1455,10 +1723,9 @@ export class Store {
     }
     /**
      * 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.
+     * JSON type. Short results retain their original type; long non-PTC results carry a text preview
+     * and full-body Artifact. Earlier results may have null content with only an Artifact reference.
+     * Clients reading the full large Result use `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`.
@@ -1478,11 +1745,13 @@ export class Store {
                 .map((artifact) => jsonRecord(artifact)?.id)
                 .filter((value) => typeof value === 'string'),
             truncated: result.truncated === true,
+            payload: { capture: result.capture ?? 'unknown', stored: result.stored ?? 'unknown', view: result.truncated === true ? 'preview' : 'full' },
             created_at: result.created_at ?? null
         };
     }
     includeResult(projectId, resultId, agentId, expectedContextRevision) {
         const result = this.getResult(projectId, resultId);
+        const call = this.#require('calls', stringField(result.call_id));
         const contextId = id('context');
         const turnGroupId = id('turn');
         const timestamp = now();
@@ -1493,7 +1762,7 @@ export class Store {
             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);
+                .run(contextId, agentId, turnGroupId, resultId, this.#resultContextContent(call, result), ordinal, timestamp, timestamp);
             this.#touchContext(agentId);
             return this.getContextItem(projectId, contextId);
         });
@@ -1516,6 +1785,75 @@ export class Store {
         owned(row, 'project_id', projectId);
         return doc(row);
     }
+    getAgentArtifact(projectId, agentId, artifactId) {
+        this.getAgent(projectId, agentId);
+        const artifact = this.getArtifact(projectId, artifactId);
+        const linked = this.#database.prepare(`SELECT 1 FROM context_items ci
+      JOIN result_artifacts ra ON ra.result_id = ci.source_id
+      WHERE ci.agent_id = ? AND ci.kind = 'result' AND ci.visible = 1 AND ra.artifact_id = ? LIMIT 1`).get(agentId, artifactId);
+        if (linked === undefined)
+            fail('ARTIFACT_NOT_ACCESSIBLE', 404, 'Artifact is not referenced by this Agent visible history.');
+        const captures = this.#all(`SELECT DISTINCT r.capture FROM results r JOIN result_artifacts ra ON ra.result_id = r.id
+      JOIN context_items ci ON ci.source_id = r.id AND ci.kind = 'result'
+      WHERE ci.agent_id = ? AND ci.visible = 1 AND ra.artifact_id = ?`, agentId, artifactId).map((row) => row.capture);
+        return { ...artifact, capture: captures.includes('partial') ? 'partial' : captures.includes('unknown') ? 'unknown' : 'complete' };
+    }
+    readHistoryItem(projectId, agentId, contextId) {
+        this.getAgent(projectId, agentId);
+        const row = this.#database.prepare(`SELECT ci.*, CASE WHEN co.instructions IS NULL THEN ci.content
+      ELSE co.instructions || char(10) || char(10) || ci.content END AS content
+      , a.session_id, a.task_id, a.name AS agent_name, a.parent_agent_id
+      FROM context_items ci JOIN agents a ON a.id = ci.agent_id JOIN tasks t ON t.id = a.task_id
+      LEFT JOIN context_overrides co ON co.agent_id = ci.agent_id
+      AND co.target_kind = ci.kind AND co.target_id = ci.source_id
+      WHERE ci.id = ? AND t.project_id = ? AND ci.visible = 1`).get(contextId, projectId);
+        if (row === undefined)
+            fail('HISTORY_NOT_ACCESSIBLE', 404, 'History item is not visible in this Project.');
+        return doc(row);
+    }
+    searchHistory(projectId, agentId, query, after, limit, scope = {}) {
+        this.getAgent(projectId, agentId);
+        if (scope.agent_id !== undefined)
+            this.getAgent(projectId, scope.agent_id);
+        if (scope.session_id !== undefined)
+            this.getSession(projectId, scope.session_id);
+        if (scope.task_id !== undefined)
+            this.getTask(projectId, scope.task_id);
+        const filters = ['t.project_id = ?', 'ci.visible = 1', 'ci.ordinal > ?'];
+        const parameters = [projectId, after];
+        for (const field of ['agent_id', 'session_id', 'task_id']) {
+            const value = scope[field];
+            if (value === undefined)
+                continue;
+            filters.push(`${field === 'agent_id' ? 'ci' : 'a'}.${field} = ?`);
+            parameters.push(value);
+        }
+        if (scope.after_context_item_id !== undefined) {
+            const cursor = this.readHistoryItem(projectId, agentId, scope.after_context_item_id);
+            for (const field of ['agent_id', 'session_id', 'task_id']) {
+                if (scope[field] !== undefined && scope[field] !== cursor[field])
+                    fail('INVALID_INPUT', 400, 'History continuation must use the same scope.');
+            }
+            const owner = this.getAgent(projectId, stringField(cursor.agent_id));
+            filters.push('(a.created_at, a.id, ci.ordinal) > (?, ?, ?)');
+            parameters.push(stringField(owner.created_at), stringField(cursor.agent_id), Number(cursor.ordinal));
+        }
+        const rows = this.#all(`WITH history AS (
+      SELECT ci.id, ci.source_id, ci.agent_id, a.session_id, a.task_id, a.name AS agent_name, a.parent_agent_id,
+      a.created_at AS agent_created_at, ci.ordinal, ci.role, ci.kind, ci.locked, ci.revision,
+      CASE WHEN co.instructions IS NULL THEN ci.content ELSE co.instructions || char(10) || char(10) || ci.content END AS body
+      FROM context_items ci JOIN agents a ON a.id = ci.agent_id JOIN tasks t ON t.id = a.task_id
+      LEFT JOIN context_overrides co ON co.agent_id = ci.agent_id
+      AND co.target_kind = ci.kind AND co.target_id = ci.source_id
+      WHERE ${filters.join(' AND ')})
+      SELECT id AS context_item_id, source_id, agent_id, session_id, task_id, agent_name, parent_agent_id, ordinal, role, kind, locked, revision,
+      substr(body, max(1, instr(body, ?) - 50), 160) AS snippet
+      FROM history WHERE ? = '' OR instr(body, ?) > 0 ORDER BY agent_created_at, agent_id, ordinal LIMIT ?`, ...parameters, query, query, query, limit + 1);
+        const matches = rows.slice(0, limit).map(doc);
+        return { matches, has_more: rows.length > limit,
+            next_after_context_item_id: rows.length > limit ? matches.at(-1)?.context_item_id ?? null : null,
+            next_after_ordinal: rows.length > limit && scope.agent_id !== undefined ? matches.at(-1)?.ordinal ?? null : null };
+    }
     listArtifacts(projectId, options) {
         this.getProject(projectId);
         // Explicit order: the shared pager defaults to `updated_at`, which this table does not have
@@ -1534,27 +1872,100 @@ export class Store {
         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) {
+    contextSource(projectId, agentId, completedOnly = false) {
+        const items = this.#all(`SELECT * FROM context_items WHERE agent_id = ? AND visible = 1 ${completedOnly ? "AND turn_group_id IN (SELECT id FROM context_turn_groups WHERE state = 'COMPLETE')" : ''} ORDER BY ordinal, id`, agentId).map(doc);
+        const ids = new Set(items.map((item) => item.id));
         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),
+            items,
+            todo: this.getTodo(projectId, agentId),
+            unsettledItemIds: this.#unsettledContextItems(agentId),
+            workingItems: this.#workingItems(agentId).filter((item) => ids.has(item.id)),
             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) {
+    workingContext(projectId, agentId) {
+        this.getAgent(projectId, agentId);
+        const state = this.#database.prepare('SELECT * FROM working_contexts WHERE agent_id = ?').get(agentId);
+        return { ...(state === undefined ? {} : doc(state)), items: this.#workingItems(agentId) };
+    }
+    saveWorkingContext(projectId, agentId, sourceRevision, edits, messages, prefixes, requestFrame) {
+        const state = this.workingContext(projectId, agentId);
+        const messageJson = json(messages);
+        if (edits.length === 0 && json(state.messages ?? null) === messageJson && json(state.request_frame ?? null) === json(requestFrame))
+            return;
+        this.#write(projectId, refs(['agent', agentId]), () => {
+            if (this.getAgent(projectId, agentId).context_revision !== sourceRevision)
+                fail('REVISION_CONFLICT', 409, 'Context changed before Working Context publication.');
+            const update = this.#database.prepare('UPDATE working_context_items SET content = ?, snipped = 1 WHERE agent_id = ? AND context_item_id = ?');
+            for (const edit of edits) {
+                if (update.run(edit.content, agentId, edit.id).changes !== 1)
+                    fail('CONTEXT_ITEM_CONFLICT', 409, 'A Working Context source is no longer active.');
+            }
+            this.#database.prepare('UPDATE working_contexts SET revision = revision + 1, digest = ?, messages_json = ?, prefixes_json = ?, request_frame_json = ?, updated_at = ? WHERE agent_id = ?')
+                .run(digest({ items: this.#workingItems(agentId), prefixes }), messageJson, json(prefixes), json(requestFrame), now(), agentId);
+        });
+    }
+    compactionSources(projectId, contextItemId) {
+        this.getContextItem(projectId, contextItemId);
+        const row = this.#database.prepare('SELECT * FROM context_compactions WHERE context_item_id = ?').get(contextItemId);
+        if (row === undefined)
+            return { context_item_id: contextItemId, covered_item_ids: [], coverage_known: false };
+        const record = doc(row);
+        return { ...record, coverage_known: true, items: strings(record.covered_item_ids ?? []).map((itemId) => this.getContextItem(projectId, itemId)) };
+    }
+    getTodo(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) {
+    updateTodo(projectId, agentId, items) {
+        const current = this.getTodo(projectId, agentId);
+        if (current !== null && digest(current.items ?? []) === digest(items))
+            return current;
         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());
+            this.#touchContext(agentId);
             return doc(this.#one('SELECT * FROM agent_plans WHERE agent_id = ?', agentId));
         });
     }
+    syncTodoReminder(projectId, agentId) {
+        const source = this.contextSource(projectId, agentId);
+        if (!source.capabilities.some((entry) => entry.capability_id === 'todo'))
+            return;
+        const state = this.#database.prepare('SELECT * FROM todo_reminder_state WHERE agent_id = ?').get(agentId);
+        const cursor = Number(state?.last_context_rowid ?? 0);
+        // Count each newly projected payload once. Compact/Snip/retries must not reset or
+        // increase the cadence; locked original history remains available across restart.
+        const added = this.#all(`SELECT ci.*, ci.rowid AS context_rowid, COALESCE(w.content, ci.content) AS content
+      FROM context_items ci LEFT JOIN working_context_items w ON w.context_item_id = ci.id
+      WHERE ci.agent_id = ? AND ci.rowid > ? ORDER BY ci.rowid`, agentId, cursor);
+        let pending = Number(state?.pending_tokens ?? 0);
+        for (const item of added.map(doc)) {
+            const metadata = item.metadata;
+            if (item.visible !== true || item.locked === true || item.kind === 'compaction' || item.role === 'system' || metadata?.purpose === 'todo_reminder')
+                continue;
+            pending += estimateTokens(json(boundaryMessages([item]).map((message) => ({ role: message.role, content: message.content, ...(message.toolCalls === undefined ? {} : { toolCalls: message.toolCalls }) })))).expected;
+        }
+        const messages = boundaryMessages(activeContextItems(source.items));
+        const boundaries = assertContextBoundaries(messages, { allowOpenTail: true, unsettledItemIds: source.unsettledItemIds });
+        const due = pending >= 30000 && boundaries.legalCuts.at(-1) === messages.length;
+        if (added.length === 0 && !due)
+            return;
+        this.#write(projectId, refs(['agent', agentId]), () => {
+            if (due) {
+                this.#insertStandaloneContextMessage(agentId, 'user', 'Todo reminder: read your current checklist with todo({}). Keep the original user goal and applicable instructions in view. Maintain and update the checklist with todo({items: [...]}) as progress or instructions change; create one if needed. This reminder does not change the user goal or prove completion.', 'message', now(), { purpose: 'todo_reminder' });
+                pending %= 30000;
+            }
+            const latest = this.#one('SELECT COALESCE(MAX(rowid), 0) AS cursor FROM context_items WHERE agent_id = ?', agentId);
+            this.#database.prepare(`INSERT INTO todo_reminder_state(agent_id, last_context_rowid, pending_tokens) VALUES (?, ?, ?)
+        ON CONFLICT(agent_id) DO UPDATE SET last_context_rowid = excluded.last_context_rowid, pending_tokens = excluded.pending_tokens`)
+                .run(agentId, Number(latest.cursor), pending);
+        });
+    }
     getContextItem(projectId, contextItemId) {
         const row = this.#require('context_items', contextItemId);
         this.#ownedAgent(String(row.agent_id), projectId);
@@ -1568,19 +1979,30 @@ export class Store {
             this.#expect(current, expectedRevision);
             if (Number(current.locked) === 1)
                 fail('CONTEXT_LOCKED', 409, 'The ContextItem is before the latest Compaction boundary.');
+            if (current.kind === 'tool_calls') {
+                const identity = (text) => json(contextToolCalls(text).map(({ id, name }) => ({ id, name })));
+                if (identity(String(current.content)) !== identity(content))
+                    fail('CONTEXT_BOUNDARY_INVALID', 409, 'Editing a tool batch cannot change its call identities or members.');
+            }
+            const before = this.#assertContext(agentId);
             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);
+            assertContextTransition(before, this.#assertContext(agentId), this.#unsettledContextItems(agentId));
+            this.#touchContext(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);
+            const before = this.#assertContext(agentId);
             if (agent.context_revision !== expectedContextRevision)
                 fail('REVISION_CONFLICT', 409, 'The Context changed before this command was applied.');
+            const selected = new Set(turnGroupIds);
+            const selection = this.#all('SELECT * FROM context_items WHERE agent_id = ? ORDER BY ordinal, id', agentId).map(doc)
+                .filter((item) => selected.has(stringField(item.turn_group_id)));
+            assertContextBoundaries(boundaryMessages(selection), { unsettledItemIds: this.#unsettledContextItems(agentId) });
             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);
@@ -1590,6 +2012,7 @@ export class Store {
                 if (statement.run(visible ? 1 : 0, now(), groupId, agentId).changes !== expected)
                     fail('CONTEXT_ITEM_CONFLICT', 409, 'A locked TurnGroup cannot change visibility.');
             }
+            assertContextTransition(before, this.#assertContext(agentId), this.#unsettledContextItems(agentId));
             this.#touchContext(agentId);
             return this.#all(`SELECT * FROM context_items WHERE turn_group_id IN (${turnGroupIds.map(() => '?').join(',')}) ORDER BY ordinal`, ...turnGroupIds).map(doc);
         });
@@ -1597,26 +2020,38 @@ export class Store {
     reorderContext(projectId, agentId, turnGroupIds, expectedContextRevision) {
         return this.#write(projectId, turnGroupIds.map((entry) => ({ type: 'turn_group', id: entry })), () => {
             const agent = this.getAgent(projectId, agentId);
+            const before = this.#assertContext(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 = ?');
+            // A Compact boundary may split a TurnGroup. Reuse only movable slots, leaving archived
+            // rows and the retained part of a partially locked group in place.
+            const movable = new Set(current);
+            const slots = this.#all('SELECT ordinal, turn_group_id FROM context_items WHERE agent_id = ? ORDER BY ordinal', agentId)
+                .filter((row) => movable.has(String(row.turn_group_id))).map((row) => Number(row.ordinal));
+            const groupSlots = this.#all('SELECT id, ordinal FROM context_turn_groups WHERE agent_id = ? ORDER BY ordinal', agentId)
+                .filter((row) => movable.has(String(row.id))).map((row) => Number(row.ordinal));
+            const offset = this.#nextOrdinal('context_items', 'agent_id', agentId);
+            const move = this.#database.prepare('UPDATE context_items SET ordinal = ordinal + ? WHERE turn_group_id = ?');
+            for (const groupId of turnGroupIds)
+                move.run(offset, groupId);
+            const moveGroup = this.#database.prepare('UPDATE context_turn_groups SET ordinal = ordinal + ? WHERE id = ?');
+            const groupOffset = this.#nextOrdinal('context_turn_groups', 'agent_id', agentId);
             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 = ?');
+                moveGroup.run(groupOffset, groupId);
+            const updateItem = this.#database.prepare('UPDATE context_items SET ordinal = ?, 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);
+            let slot = 0;
+            for (const [index, groupId] of turnGroupIds.entries()) {
+                updateGroup.run(groupSlots[index], 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;
+                    updateItem.run(slots[slot], now(), row.id);
+                    slot += 1;
                 }
             }
+            assertContextTransition(before, this.#assertContext(agentId), this.#unsettledContextItems(agentId));
             this.#touchContext(agentId);
             return this.#all('SELECT * FROM context_items WHERE agent_id = ? ORDER BY ordinal', agentId).map(doc);
         });
@@ -1676,11 +2111,14 @@ export class Store {
             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 };
+            if (stages?.some((stage) => stage !== 'snip'))
+                fail('VALIDATION_ERROR', 400, 'Only the snip projection can be reset.');
+            if (stages === undefined || stages.includes('snip')) {
+                this.#database.prepare("DELETE FROM projection_decisions WHERE agent_id = ? AND stage = 'snip'").run(agentId);
+                this.#database.prepare(`UPDATE working_context_items SET content = (SELECT content FROM context_items WHERE id = context_item_id), snipped = 0 WHERE agent_id = ? AND snipped = 1`).run(agentId);
+                this.#touchContext(agentId);
+            }
+            return { agent_id: agentId, context_revision: Number(this.getAgent(projectId, agentId).context_revision) };
         });
     }
     appendProjectionDecision(projectId, agentId, attemptId, stage, sourceTokens, projectedTokens, details) {
@@ -1692,18 +2130,41 @@ export class Store {
             return doc(this.#require('projection_decisions', decisionId));
         });
     }
-    compactContext(projectId, agentId, summary, preserveFromOrdinal) {
+    compactContext(projectId, agentId, summary, coveredItemIds, expectedContextRevision, focus, expectedAgentRevision) {
         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);
+            const agent = this.getAgent(projectId, agentId);
+            if (agent.context_revision !== expectedContextRevision)
+                fail('REVISION_CONFLICT', 409, 'Context changed while Compaction was running.');
+            if (expectedAgentRevision !== undefined && agent.revision !== expectedAgentRevision)
+                fail('REVISION_CONFLICT', 409, 'Agent state changed while Compaction was running.');
+            if (summary.trim().length === 0 || coveredItemIds.length === 0)
+                fail('COMPACTION_INVALID', 422, 'Compaction requires a nonempty summary and source range.');
+            const active = activeContextItems(this.#all('SELECT * FROM context_items WHERE agent_id = ? ORDER BY ordinal', agentId).map(doc))
+                .filter((item) => !(item.kind === 'message' && item.role === 'system'));
+            const covered = active.slice(0, coveredItemIds.length);
+            if (covered.length !== coveredItemIds.length || covered.some((item, index) => item.id !== coveredItemIds[index]))
+                fail('CONTEXT_SET_MISMATCH', 409, 'Compaction must cover an active history prefix.');
+            const boundaries = assertContextBoundaries(boundaryMessages(active), { allowOpenTail: true, unsettledItemIds: this.#unsettledContextItems(agentId) });
+            if (!boundaries.legalCuts.includes(coveredItemIds.length))
+                fail('CONTEXT_BOUNDARY_INVALID', 409, 'Compaction cannot split or cover an unfinished protocol group.', { legal_cuts: boundaries.legalCuts });
+            const firstRetained = active[coveredItemIds.length];
+            const ordinal = firstRetained === undefined ? Math.max(...covered.map((item) => Number(item.ordinal))) + 1 : Number(firstRetained.ordinal);
+            const lock = this.#database.prepare('UPDATE context_items SET locked = 1, revision = revision + 1, updated_at = ? WHERE id = ?');
+            for (const itemId of coveredItemIds)
+                lock.run(timestamp, itemId);
+            // Insert at the cutoff, before the retained tail. Descending moves respect the unique ordinal.
+            const shift = this.#database.prepare('UPDATE context_items SET ordinal = ordinal + 1 WHERE id = ?');
+            for (const row of this.#all('SELECT id FROM context_items WHERE agent_id = ? AND ordinal >= ? ORDER BY ordinal DESC', agentId, ordinal))
+                shift.run(row.id);
             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, ?, ?)`)
+            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', ?, 'assistant', ?, ?, 1, 0, 0, ?, ?)`)
                 .run(contextId, agentId, turnGroupId, contextId, summary, ordinal, timestamp, timestamp);
+            this.#database.prepare('INSERT INTO context_compactions(context_item_id, source_revision, covered_item_ids_json, focus) VALUES (?, ?, ?, ?)')
+                .run(contextId, expectedContextRevision, json(coveredItemIds), focus ?? null);
+            this.#database.prepare('DELETE FROM working_context_items WHERE agent_id = ?').run(agentId);
             this.#touchContext(agentId);
             return this.getContextItem(projectId, contextId);
         });
@@ -1724,7 +2185,7 @@ export class Store {
             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)
+            if (this.#count('SELECT COUNT(*) AS count FROM context_items WHERE turn_group_id = ? AND locked = 0', 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);
@@ -1754,6 +2215,26 @@ export class Store {
             return this.getAgent(projectId, targetAgentId);
         });
     }
+    /** Persist one completed Provider response atomically with its tool batch. */
+    appendModelResponse(projectId, agentId, stepId, text, calls, response) {
+        const messageId = id('message');
+        const contextId = id('context');
+        const timestamp = now();
+        const metadata = json({ source_step_id: stepId, model_response: response });
+        return this.#write(projectId, refs(['message', messageId], ['context_item', contextId]), () => {
+            this.getAgent(projectId, agentId);
+            const turnGroupId = stringField(this.getStep(projectId, stepId).turn_group_id);
+            // Display text remains separate from protocol blocks; one Context item keeps the
+            // reasoning, text and tool calls indivisible at Compact/Fork boundaries.
+            this.#database.prepare(`INSERT INTO messages(id, agent_id, source_agent_id, role, content, metadata_json, created_at) VALUES (?, ?, NULL, 'assistant', ?, ?, ?)`)
+                .run(messageId, agentId, text, metadata, timestamp);
+            const hasCalls = calls.length > 0;
+            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, metadata_json) VALUES (?, ?, ?, ?, ?, ?, 'assistant', ?, ?, 1, 0, 0, ?, ?, ?)`)
+                .run(contextId, agentId, turnGroupId, this.#nextOrdinal('context_items', 'turn_group_id', turnGroupId), hasCalls ? 'tool_calls' : 'message', hasCalls ? contextId : messageId, hasCalls ? json(calls) : text, this.#nextOrdinal('context_items', 'agent_id', agentId), timestamp, timestamp, metadata);
+            this.#touchContext(agentId);
+            return this.getContextItem(projectId, contextId);
+        });
+    }
     appendAssistantMessage(projectId, agentId, stepId, content) {
         const messageId = id('message');
         const contextId = id('context');
@@ -1781,6 +2262,7 @@ export class Store {
             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.#database.prepare('UPDATE context_items SET metadata_json = ? WHERE id = ?').run(json({ source_step_id: stepId }), contextId);
             this.#touchContext(agentId);
             return this.getContextItem(projectId, contextId);
         });
@@ -1794,17 +2276,31 @@ export class Store {
         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 changes = [...refs(['step', stepId], ['run', runId], ['agent', agentId])];
+        return this.#write(projectId, changes, () => {
             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;
+            for (const call of this.#all("SELECT c.* FROM calls c JOIN steps s ON s.id = c.step_id WHERE s.run_id = ? AND c.state != 'TERMINAL'", runId)) {
+                changes.push(...this.#interruptCall(call, errorCode ?? 'RUN_ENDED', errorMessage ?? 'The Run ended before this Call completed.', timestamp));
+            }
+            changes.push(...this.#recoverResultContext(timestamp, agentId));
             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);
+            if (outcome === 'failed' && run.state !== 'TERMINAL' && hasPending) {
+                const consumed = new Set(strings(parseJson(String(run.goal_message_ids_json))));
+                const freshInput = this.#all('SELECT message_id FROM pending_messages WHERE agent_id = ?', agentId)
+                    .some(message => !consumed.has(String(message.message_id)));
+                // Restored input from a failed compaction is not a new execution request.
+                // Only input not consumed by this Run can schedule a fresh Run; old Calls stay terminal.
+                if (freshInput) {
+                    const nextRunId = id('run');
+                    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(nextRunId, agentId, timestamp, timestamp);
+                    changes.push({ type: 'run', id: nextRunId });
+                }
             }
             this.#database.prepare(`UPDATE agents SET state = 'IDLE', revision = revision + 1, updated_at = ? WHERE id = ?`)
                 .run(timestamp, agentId);
@@ -1834,15 +2330,18 @@ export class Store {
     }
     yieldResults(projectId, agentId, callIds) {
         const timestamp = now();
-        return this.#write(projectId, callIds.map((entry) => ({ type: 'result', id: entry })), () => {
+        const changes = [];
+        return this.#write(projectId, changes, () => {
             this.getAgent(projectId, agentId);
             const rows = callIds.map((callId) => {
                 const call = this.#require('calls', callId);
+                owned(call, 'agent_id', agentId);
                 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.');
+                changes.push({ type: 'result', id: String(result.id) });
                 return { call, result };
             }).sort((left, right) => Number(left.call.call_ordinal ?? 0) - Number(right.call.call_ordinal ?? 0));
             const yielded = [];
@@ -1851,26 +2350,153 @@ export class Store {
                     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.');
+                if (this.#count("SELECT COUNT(*) AS count FROM context_items WHERE agent_id = ? AND kind = 'result' AND source_id = ? AND tool_call_id IS NOT NULL", agentId, result.id) > 0)
+                    continue;
                 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);
+                this.#insertResultContext(agentId, turnGroupId, call, result, timestamp, this.#nextOrdinal('context_items', 'agent_id', agentId), this.#nextOrdinal('context_items', 'turn_group_id', turnGroupId));
                 yielded.push({ ...doc(result), tool_call_id: call.provider_call_id, tool_name: String(call.capability_id) });
             }
             this.#touchContext(agentId);
             return yielded;
         });
     }
+    #insertResultContext(agentId, turnGroupId, call, result, timestamp, ordinal, groupOrdinal) {
+        const contextId = id('context');
+        const content = this.#resultContextContent(call, doc(result));
+        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);
+        return contextId;
+    }
+    // Old partial batches may have persisted tool IDs but no Call. Create only an
+    // interrupted fact anchored to the recorded Step; never schedule these tools.
+    #materializeInterruptedCalls(timestamp) {
+        const changes = [];
+        for (const batch of this.#all("SELECT * FROM context_items WHERE kind = 'tool_calls' AND visible = 1 AND locked = 0")) {
+            const metadata = jsonRecord(parseJson(typeof batch.metadata_json === 'string' ? batch.metadata_json : null));
+            if (typeof metadata?.source_step_id !== 'string')
+                continue;
+            const step = this.#database.prepare('SELECT s.*, a.workspace_id, t.project_id FROM steps s JOIN runs r ON r.id = s.run_id JOIN agents a ON a.id = r.agent_id JOIN tasks t ON t.id = a.task_id WHERE s.id = ? AND r.agent_id = ? AND s.turn_group_id = ?').get(metadata.source_step_id, batch.agent_id, batch.turn_group_id);
+            if (step === undefined)
+                continue;
+            for (const [ordinal, tool] of contextToolCalls(String(batch.content)).entries()) {
+                if (this.#count('SELECT COUNT(*) AS count FROM calls WHERE step_id = ? AND provider_call_id = ? AND parent_call_id IS NULL', step.id, tool.id) > 0)
+                    continue;
+                const callId = id('call');
+                this.#database.prepare(`INSERT INTO calls(id, project_id, workspace_id, agent_id, step_id, source, capability_id, provider_call_id, call_ordinal, input_json, effect, state, outcome_unknown, revision, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, 'llm', ?, ?, ?, '{}', 'full', 'QUEUED', 0, 0, ?, ?)`)
+                    .run(callId, step.project_id, step.workspace_id, batch.agent_id, step.id, tool.name, tool.id, ordinal, timestamp, timestamp);
+                changes.push(...this.#interruptCall(this.#require('calls', callId), 'PROCESS_INTERRUPTED', 'Execution was interrupted before a Call was recorded; no automatic retry will occur.', timestamp));
+            }
+        }
+        return changes;
+    }
+    #recoverResultContext(timestamp, onlyAgentId) {
+        const changes = [];
+        const touched = new Set();
+        const batches = this.#all(`SELECT i.id FROM context_items i WHERE i.kind = 'tool_calls' AND i.visible = 1 AND i.locked = 0
+      AND EXISTS (SELECT 1 FROM calls c JOIN steps s ON s.id = c.step_id JOIN results r ON r.call_id = c.id
+        WHERE c.agent_id = i.agent_id AND s.turn_group_id = i.turn_group_id AND c.source = 'llm' AND c.state = 'TERMINAL'
+        AND NOT EXISTS (SELECT 1 FROM context_items response WHERE response.agent_id = i.agent_id AND response.kind = 'result'
+          AND response.source_id = r.id AND response.tool_call_id IS NOT NULL)) ORDER BY i.agent_id, i.ordinal`);
+        for (const { id: batchId } of batches) {
+            // Earlier insertions can move this batch; always use current ordinals.
+            const batch = this.#require('context_items', String(batchId));
+            const agentId = String(batch.agent_id);
+            if (onlyAgentId !== undefined && agentId !== onlyAgentId)
+                continue;
+            const groupId = String(batch.turn_group_id);
+            const tools = contextToolCalls(String(batch.content));
+            const toolIds = new Set(tools.map((tool) => tool.id));
+            const following = this.#all('SELECT * FROM context_items WHERE agent_id = ? AND ordinal > ? ORDER BY ordinal', agentId, batch.ordinal);
+            const existing = [];
+            for (const item of following) {
+                if (item.kind !== 'result' || item.turn_group_id !== groupId || !toolIds.has(String(item.tool_call_id)))
+                    break;
+                existing.push(item);
+            }
+            const present = new Set(existing.map((item) => String(item.tool_call_id)));
+            if (tools.every((tool) => present.has(tool.id)))
+                continue;
+            const metadata = jsonRecord(parseJson(typeof batch.metadata_json === 'string' ? batch.metadata_json : null));
+            let stepId = typeof metadata?.source_step_id === 'string' ? metadata.source_step_id : undefined;
+            if (stepId === undefined && existing.length > 0) {
+                const steps = new Set(existing.flatMap((item) => this.#all('SELECT c.step_id FROM results r JOIN calls c ON c.id = r.call_id WHERE r.id = ? AND c.agent_id = ?', item.source_id, agentId).map((row) => String(row.step_id))));
+                if (steps.size === 1)
+                    stepId = [...steps][0];
+            }
+            const last = existing.at(-1) ?? batch;
+            let ordinal = Number(last.ordinal) + 1;
+            let groupOrdinal = Number(last.turn_group_ordinal) + 1;
+            for (const tool of tools) {
+                if (present.has(tool.id))
+                    continue;
+                // Legacy batches without an explicit Step or an existing Result anchor must
+                // have an unambiguous batch identity within this TurnGroup.
+                if (stepId === undefined) {
+                    const owners = this.#all("SELECT content FROM context_items WHERE agent_id = ? AND turn_group_id = ? AND kind = 'tool_calls'", agentId, groupId)
+                        .filter((row) => contextToolCalls(String(row.content)).some((entry) => entry.id === tool.id));
+                    if (owners.length !== 1)
+                        continue;
+                }
+                const candidates = this.#all(`SELECT c.* FROM calls c JOIN steps s ON s.id = c.step_id
+          WHERE c.agent_id = ? AND s.turn_group_id = ? AND c.source = 'llm' AND c.parent_call_id IS NULL
+          AND c.provider_call_id = ? AND c.capability_id = ? ${stepId === undefined ? '' : 'AND c.step_id = ?'}`, agentId, groupId, tool.id, tool.name, ...(stepId === undefined ? [] : [stepId]));
+                if (candidates.length !== 1)
+                    continue;
+                const call = candidates[0];
+                if (call.state !== 'TERMINAL')
+                    continue;
+                const result = this.#database.prepare('SELECT * FROM results WHERE call_id = ?').get(call.id);
+                if (result === undefined)
+                    continue;
+                // A copied/hidden/already projected response must never be resurrected or duplicated.
+                if (this.#count("SELECT COUNT(*) AS count FROM context_items WHERE agent_id = ? AND kind = 'result' AND source_id = ? AND tool_call_id IS NOT NULL", agentId, result.id) > 0)
+                    continue;
+                const shift = this.#database.prepare('UPDATE context_items SET ordinal = ordinal + 1 WHERE id = ?');
+                for (const item of this.#all('SELECT id FROM context_items WHERE agent_id = ? AND ordinal >= ? ORDER BY ordinal DESC', agentId, ordinal))
+                    shift.run(item.id);
+                const shiftGroup = this.#database.prepare('UPDATE context_items SET turn_group_ordinal = turn_group_ordinal + 1 WHERE id = ?');
+                for (const item of this.#all('SELECT id FROM context_items WHERE turn_group_id = ? AND turn_group_ordinal >= ? ORDER BY turn_group_ordinal DESC', groupId, groupOrdinal))
+                    shiftGroup.run(item.id);
+                const contextId = this.#insertResultContext(agentId, groupId, call, result, timestamp, ordinal++, groupOrdinal++);
+                changes.push({ type: 'context_item', id: contextId });
+                touched.add(agentId);
+            }
+        }
+        for (const agentId of touched) {
+            this.#touchContext(agentId);
+            changes.push({ type: 'agent', id: agentId });
+        }
+        return changes;
+    }
+    #resultContextContent(call, result) {
+        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 view = { content: result.content ?? null, artifacts, truncated: result.truncated === true };
+        // PTC roots retain their existing protocol result; nested program results are not auto-yielded.
+        if (call.source === 'program' || call.capability_id === 'programmatic_tool_run')
+            return json(view);
+        const envelope = {
+            result_id: stringField(result.id),
+            call_id: String(call.id),
+            outcome: stringField(result.outcome),
+            outcome_unknown: Number(call.outcome_unknown) === 1,
+            error_code: result.error_code === null ? null : stringField(result.error_code),
+            error_message: result.error_message === null ? null : stringField(result.error_message),
+            ...view,
+            payload: { capture: result.capture === 'complete' || result.capture === 'partial' ? result.capture : 'unknown', stored: result.stored === 'full' ? 'full' : 'unknown', view: result.truncated === true ? 'preview' : 'full' }
+        };
+        return json(envelope);
+    }
     cancelAgent(projectId, agentId) {
-        return this.#write(projectId, refs(['agent', agentId]), () => {
+        const changes = [...refs(['agent', agentId]), ...this.#all("SELECT id FROM runs WHERE agent_id = ? AND state != 'TERMINAL'", agentId).map(row => ({ type: 'run', id: String(row.id) }))];
+        return this.#write(projectId, changes, () => {
             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);
+            for (const call of this.#all("SELECT * FROM calls WHERE agent_id = ? AND state != 'TERMINAL'", agentId)) {
+                changes.push(...this.#interruptCall(call, 'CALL_CANCELLED', 'The Agent was stopped; this Call will not be resumed.', timestamp));
+            }
+            changes.push(...this.#recoverResultContext(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);
@@ -1907,17 +2533,29 @@ export class Store {
             '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'
+            'context_items', 'context_overrides', 'working_contexts', 'working_context_items', 'context_compactions', 'projection_decisions', 'capability_assignments', 'capability_loads',
+            'agent_plans', 'todo_reminder_state', 'ingress_requests', 'side_effect_ledgers', 'purge_cleanups'
         ];
-        return Object.fromEntries(tables.map((table) => [table, this.#all(`SELECT * FROM ${table}`).map(rawJson)]));
+        return Object.fromEntries(tables.map((table) => [table, this.#all(`SELECT ${table === 'context_items' ? 'rowid, *' : '*'} FROM ${table} ORDER BY rowid`).map(rawJson)]));
     }
-    purgeArchived(projectId, before) {
+    purgeArchived(projectId, before, executorStateId) {
         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) };
+            return { purged_tasks: tasks.length, ...this.#purgeTaskRows(projectId, tasks, executorStateId) };
         });
     }
+    pendingPurges(projectId) {
+        this.getProject(projectId);
+        return this.#all('SELECT * FROM purge_cleanups WHERE project_id = ? ORDER BY created_at, id', projectId).map(doc);
+    }
+    completePurge(projectId, cleanupId) {
+        this.#write(projectId, refs(['maintenance', projectId]), () => {
+            this.#database.prepare('DELETE FROM purge_cleanups WHERE project_id = ? AND id = ?').run(projectId, cleanupId);
+        });
+    }
+    artifactPathReferenced(relativePath) {
+        return this.#count('SELECT COUNT(*) AS count FROM artifacts WHERE relative_path = ?', relativePath) > 0;
+    }
     snapshot(projectId, maxEntities) {
         const project = this.getProject(projectId);
         const workspaces = this.listWorkspaces(projectId);
@@ -1948,7 +2586,47 @@ export class Store {
         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());
     }
+    #observationStates(changes) {
+        const values = new Map();
+        for (const entry of changes) {
+            if (!['call', 'run', 'agent'].includes(entry.type))
+                continue;
+            const row = this.#database.prepare(`SELECT state, ${entry.type === 'agent' ? 'NULL' : 'outcome'} AS outcome FROM ${entry.type}s WHERE id = ?`).get(entry.id);
+            if (row !== undefined)
+                values.set(`${entry.type}:${entry.id}`, `${String(row.state)}:${String(row.outcome)}`);
+        }
+        return values;
+    }
+    #observe(changes, previous = new Map()) {
+        if (this.observability === undefined)
+            return;
+        const seen = new Set();
+        for (const entry of changes) {
+            const key = `${entry.type}:${entry.id}`;
+            if (seen.has(key) || !['call', 'run', 'agent'].includes(entry.type))
+                continue;
+            seen.add(key);
+            const row = this.#database.prepare(`SELECT * FROM ${entry.type}s WHERE id = ?`).get(entry.id);
+            if (row === undefined || previous.get(key) === `${String(row.state)}:${typeof row.outcome === 'string' ? row.outcome : 'null'}`)
+                continue;
+            const result = entry.type === 'call' ? this.#database.prepare('SELECT error_code FROM results WHERE call_id = ?').get(entry.id) : undefined;
+            this.observability.record(entry.type === 'call' ? 'call' : 'agent', entry.type, String(row.outcome ?? row.state).toLowerCase(), 0, {
+                [`${entry.type}_id`]: entry.id,
+                project_id: typeof row.project_id === 'string' ? row.project_id : null,
+                agent_id: entry.type === 'agent' ? entry.id : typeof row.agent_id === 'string' ? row.agent_id : null,
+                state: String(row.state), outcome: typeof row.outcome === 'string' ? row.outcome : null,
+                error_code: typeof result?.error_code === 'string' ? result.error_code : typeof row.error_code === 'string' ? row.error_code : null,
+                outcome_unknown: row.outcome_unknown === 1
+            });
+        }
+    }
     #write(projectId, changes, command) {
+        if (this.#batchChanges !== undefined) {
+            this.#batchChanges.push(...changes);
+            return command();
+        }
+        const previous = this.observability === undefined ? new Map() : this.#observationStates(changes);
+        const before = new Map(changes.map((entry) => [`${entry.type}:${entry.id}`, this.#describeChange(entry)]));
         const transaction = this.#database.transaction(() => {
             const value = command();
             this.#database.prepare('UPDATE instance SET state_revision = state_revision + 1 WHERE id = 1').run();
@@ -1961,9 +2639,14 @@ export class Store {
         const change = {
             projectId,
             stateRevision: result.stateRevision,
-            changes: changes.map((entry) => this.#describeChange(entry))
+            changes: changes.map((entry) => {
+                const current = this.#describeChange(entry);
+                const prior = before.get(`${entry.type}:${entry.id}`);
+                return current.change === 'deleted' && prior !== undefined ? { ...prior, change: 'deleted', revision: null } : current;
+            })
         };
         this.#events.publish(change);
+        this.#observe(changes, previous);
         return result.value;
     }
     /**
@@ -1978,7 +2661,7 @@ export class Store {
         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];
+            : this.#all(`SELECT * FROM ${TABLE_BY_ENTITY[entry.type] ?? ''} WHERE ${entry.type === 'agent_plan' ? 'agent_id' : 'id'} = ?`, entry.id)[0];
         const ownerId = owner === undefined || row === undefined ? null : row[owner.column];
         return {
             type: entry.type,
@@ -1986,7 +2669,7 @@ export class Store {
             entity_type: entry.type,
             entity_id: entry.id,
             owner_id: typeof ownerId === 'string' ? ownerId : null,
-            read_route: readRouteFor(entry.type, entry.id),
+            read_route: readRouteFor(entry.type, entry.id, row),
             revision: typeof row?.revision === 'number' ? row.revision : null,
             change: row === undefined && TABLE_BY_ENTITY[entry.type] !== undefined ? 'deleted' : 'updated',
             ...this.#changeScope(entry.type, row)
@@ -2068,35 +2751,65 @@ export class Store {
             if (input.loadedCapabilities.includes(capabilityId))
                 load.run(agentId, capabilityId, timestamp);
         }
+        this.#syncWorkingContext(agentId);
         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);
+    #copyContextRange(sourceAgentId, targetAgentId, throughOrdinal, timestamp, selectedIds, working = false) {
+        // Copy archived Full Context too, so checkpoint provenance survives independently of the parent.
+        const selected = selectedIds === undefined ? undefined : new Set(selectedIds);
+        let source = (working
+            ? this.#all(`SELECT c.*, w.content AS content, w.snipped AS snipped FROM working_context_items w
+          JOIN context_items c ON c.id = w.context_item_id WHERE w.agent_id = ? AND c.ordinal <= ? AND c.visible = 1 ORDER BY c.ordinal`, sourceAgentId, throughOrdinal)
+            : this.#all('SELECT * FROM context_items WHERE agent_id = ? AND ordinal <= ? AND visible = 1 ORDER BY ordinal', sourceAgentId, throughOrdinal))
+            .filter((row) => selected === undefined || selected.has(String(row.id)));
         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)
+        if (!working && 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 active = activeContextItems(source.map(doc));
+        const boundaries = assertContextBoundaries(boundaryMessages(active), { allowOpenTail: working, unsettledItemIds: this.#unsettledContextItems(sourceAgentId) });
+        if (working) {
+            // The child inherits observations, never the parent's live execution obligations.
+            const unfinished = new Set(boundaries.protectedRanges.filter((range) => !range.complete)
+                .flatMap((range) => active.slice(range.start, range.end).map((row) => stringField(row.id))));
+            const overrides = new Map(this.#all('SELECT target_kind, target_id, instructions FROM context_overrides WHERE agent_id = ?', sourceAgentId)
+                .map((row) => [`${String(row.target_kind)}:${String(row.target_id)}`, String(row.instructions)]));
+            source = source.map((row) => {
+                const override = overrides.get(`${String(row.kind)}:${String(row.source_id)}`);
+                const content = override === undefined ? row.content : `${override}\n\n${String(row.content)}`;
+                if (!unfinished.has(String(row.id)))
+                    return { ...row, content };
+                if (row.kind === 'tool_calls') {
+                    const metadata = { ...jsonRecord(parseJson(typeof row.metadata_json === 'string' ? row.metadata_json : null)) };
+                    delete metadata.model_response;
+                    return { ...row, kind: 'message', role: 'assistant', content: `Unfinished parent tool calls at fork time (historical evidence, not requests to execute):\n${String(row.content)}`, tool_call_id: null, tool_name: null, metadata_json: json(metadata) };
+                }
+                return { ...row, content, tool_call_id: null, tool_name: null };
+            });
+            const instructions = overrides.get(`agent:${sourceAgentId}`);
+            if (instructions !== undefined)
+                this.#insertStandaloneContextMessage(targetAgentId, 'system', instructions, 'message', timestamp);
+        }
         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')
+            if (!working && 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, ?, ?)`);
+        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, metadata_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?)`);
+        const contextIds = new Map(source.map((row) => [String(row.id), id('context')]));
         let ordinal = this.#nextOrdinal('context_items', 'agent_id', targetAgentId);
         for (const row of source) {
-            const contextId = id('context');
+            const contextId = contextIds.get(String(row.id));
             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);
+                this.#database.prepare(`INSERT INTO messages(id, agent_id, source_agent_id, role, content, metadata_json, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)`)
+                    .run(messageId, targetAgentId, sourceAgentId, row.role, row.content, json({ ingress_origin: 'agent', context_copy: true }), timestamp);
                 sourceId = messageId;
             }
             else if (row.kind !== 'result')
@@ -2104,27 +2817,43 @@ export class Store {
             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);
+            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, row.locked, timestamp, timestamp, row.metadata_json);
+            const coverage = this.#database.prepare('SELECT * FROM context_compactions WHERE context_item_id = ?').get(row.id);
+            if (coverage !== undefined) {
+                const coveredIds = strings(parseJson(String(coverage.covered_item_ids_json))).map((itemId) => contextIds.get(itemId) ?? itemId);
+                this.#database.prepare('INSERT INTO context_compactions(context_item_id, source_revision, covered_item_ids_json, focus) VALUES (?, ?, ?, ?)')
+                    .run(contextId, 0, json(coveredIds), coverage.focus);
+            }
             ordinal += 1;
         }
+        this.#assertContext(targetAgentId, false);
+        if (working) {
+            this.#syncWorkingContext(targetAgentId);
+            for (const row of source) {
+                if (Number(row.snipped) === 1)
+                    this.#database.prepare('UPDATE working_context_items SET snipped = 1 WHERE context_item_id = ?').run(contextIds.get(String(row.id)));
+            }
+        }
         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) {
+    #insertStandaloneContextMessage(agentId, role, content, kind, timestamp, metadata = null) {
         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.#database.prepare(`INSERT INTO messages(id, agent_id, source_agent_id, role, content, metadata_json, created_at) VALUES (?, ?, NULL, ?, ?, ?, ?)`)
+            .run(messageId, agentId, role, content, metadata === null ? null : json(metadata), 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);
+        if (metadata !== null)
+            this.#database.prepare('UPDATE context_items SET metadata_json = ? WHERE id = ?').run(json(metadata), contextId);
         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) {
+    #purgeTaskRows(projectId, taskIds, executorStateId) {
         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)
@@ -2133,6 +2862,8 @@ export class Store {
         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) }));
+        if (purgedCalls.length > 0 && !executorStateId)
+            fail('EXECUTOR_IDENTITY_REQUIRED', 503, 'Executor state identity is required before purge.');
         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})
@@ -2154,7 +2885,12 @@ export class Store {
             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 };
+        const payload = { orphaned_artifact_paths: [...orphanedPaths], purged_calls: purgedCalls };
+        if (orphanedPaths.size > 0 || purgedCalls.length > 0) {
+            this.#database.prepare('INSERT INTO purge_cleanups(id, project_id, executor_state_id, payload_json, created_at) VALUES (?, ?, ?, ?, ?)')
+                .run(id('purge'), projectId, executorStateId, json(payload), now());
+        }
+        return payload;
     }
     #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, ?)`)
@@ -2171,24 +2907,25 @@ export class Store {
         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.');
+            if (source.session_id !== agent.session_id)
+                fail('AGENT_NOT_FOUND', 404, 'Cross-Agent Messages must remain inside one Session.');
         }
         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 messages(id, agent_id, source_agent_id, role, content, metadata_json, created_at) VALUES (?, ?, ?, 'user', ?, ?, ?)`)
+            .run(ids.messageId, agentId, sourceAgentId ?? null, content, json({ ingress_origin: sourceAgentId === undefined ? 'user' : 'agent' }), 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);
+        if (agent.state === 'IDLE' || agent.state === 'STOPPED') {
+            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, this.#nextOrdinal('context_items', 'agent_id', agentId), timestamp, timestamp);
+            this.#touchContext(agentId);
+        }
         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)),
@@ -2201,7 +2938,12 @@ export class Store {
     }
     #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 };
+        const value = { ...doc(row) };
+        delete value.executor_ref;
+        return { ...value, executor_id: typeof row.executor_ref === 'string' ? row.executor_ref : String(row.executor_id), paths };
+    }
+    workspaceOwner(workspaceId) {
+        return { projectId: String(this.#require('workspaces', workspaceId).project_id) };
     }
     /**
      * 02A `AgentSummary`. `is_subagent` and `subagent_list` are derived rather than stored, per the
@@ -2232,9 +2974,49 @@ export class Store {
         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);
     }
+    #unsettledContextItems(agentId) {
+        // Follow Result -> Call provenance, including copied results in forked histories.
+        return this.#all(`SELECT i.id FROM context_items i LEFT JOIN results r ON r.id = i.source_id
+      LEFT JOIN calls c ON c.id = r.call_id WHERE i.agent_id = ? AND i.kind = 'result'
+      AND i.tool_call_id IS NOT NULL AND (c.id IS NULL OR c.state != 'TERMINAL'
+        OR c.provider_call_id IS NULL OR c.provider_call_id != i.tool_call_id OR c.capability_id != i.tool_name)`, agentId).map((row) => String(row.id));
+    }
+    #assertContext(agentId, allowOpenTail = true) {
+        const items = activeContextItems(this.#all('SELECT * FROM context_items WHERE agent_id = ? ORDER BY ordinal, id', agentId).map(doc));
+        const messages = boundaryMessages(items);
+        assertContextBoundaries(messages, { allowOpenTail, unsettledItemIds: this.#unsettledContextItems(agentId) });
+        return messages;
+    }
     #touchContext(agentId) {
         this.#database.prepare('UPDATE agents SET context_revision = context_revision + 1, revision = revision + 1, updated_at = ? WHERE id = ?')
             .run(now(), agentId);
+        this.#syncWorkingContext(agentId);
+    }
+    #workingItems(agentId) {
+        return this.#all(`SELECT c.*, w.content AS content, w.snipped AS snipped FROM working_context_items w
+      JOIN context_items c ON c.id = w.context_item_id WHERE w.agent_id = ? ORDER BY c.ordinal, c.id`, agentId).map(doc);
+    }
+    #syncWorkingContext(agentId) {
+        const active = activeContextItems(this.#all('SELECT * FROM context_items WHERE agent_id = ? ORDER BY ordinal, id', agentId).map(doc));
+        const ids = new Set(active.map((item) => stringField(item.id)));
+        const remove = this.#database.prepare('DELETE FROM working_context_items WHERE context_item_id = ?');
+        for (const row of this.#all('SELECT context_item_id FROM working_context_items WHERE agent_id = ?', agentId)) {
+            if (!ids.has(String(row.context_item_id)))
+                remove.run(row.context_item_id);
+        }
+        const upsert = this.#database.prepare(`INSERT INTO working_context_items(context_item_id, agent_id, source_revision, content) VALUES (?, ?, ?, ?)
+      ON CONFLICT(context_item_id) DO UPDATE SET source_revision = excluded.source_revision, content = excluded.content, snipped = 0
+      WHERE working_context_items.source_revision != excluded.source_revision`);
+        for (const item of active)
+            upsert.run(item.id, agentId, item.revision, item.content);
+        const sourceRevision = Number(this.#require('agents', agentId).context_revision);
+        const current = this.#database.prepare('SELECT source_revision, prefixes_json FROM working_contexts WHERE agent_id = ?').get(agentId);
+        if (current?.source_revision === sourceRevision)
+            return;
+        this.#database.prepare(`INSERT INTO working_contexts(agent_id, source_revision, revision, digest, updated_at) VALUES (?, ?, 0, ?, ?)
+      ON CONFLICT(agent_id) DO UPDATE SET source_revision = excluded.source_revision, revision = working_contexts.revision + 1,
+      digest = excluded.digest, messages_json = NULL, request_frame_json = NULL, updated_at = excluded.updated_at`)
+            .run(agentId, sourceRevision, digest({ items: this.#workingItems(agentId), prefixes: current === undefined ? [] : parseJson(String(current.prefixes_json)) }), now());
     }
     #activeProject(projectId) {
         if (this.#require('projects', projectId).archived_at !== null)
@@ -2328,6 +3110,8 @@ function doc(row) {
                 fail('DATABASE_CORRUPT', 503, 'A stored JSON field is invalid.');
             result[key.slice(0, -5)] = parseJson(value);
         }
+        else if (key === 'auto_review_passed' && value === null)
+            result[key] = null;
         else if (booleans.has(key))
             result[key] = Number(value) === 1;
         else if (value === null || typeof value === 'string' || typeof value === 'number')
@@ -2337,13 +3121,15 @@ function doc(row) {
     }
     return result;
 }
-const booleans = new Set(['is_default', 'visible', 'locked', 'complete', 'loaded', 'truncated', 'outcome_unknown', 'auto_review_passed', 'initial_step_pending', 'existed_before']);
+const booleans = new Set(['is_default', 'visible', 'locked', 'complete', 'loaded', 'truncated', 'snipped', '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'
+    context_override: 'context_overrides', result: 'results', artifact: 'artifacts',
+    call_partition: 'call_partitions', turn_group: 'context_turn_groups', projection_decision: 'projection_decisions',
+    agent_plan: 'agent_plans', side_effect_ledger: 'side_effect_ledgers'
 };
 /** The column naming each entity's owner, which a subscriber uses to refresh the owning view. */
 const OWNERSHIP = {
@@ -2351,12 +3137,23 @@ const OWNERSHIP = {
     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' }
+    context_override: { column: 'agent_id' }, result: { column: 'call_id' }, artifact: { column: 'project_id' },
+    call_partition: { column: 'step_id' }, turn_group: { column: 'agent_id' }, projection_decision: { column: 'agent_id' },
+    agent_plan: { column: 'agent_id' }, side_effect_ledger: { column: 'step_id' }
 };
 /** The Route a subscriber re-reads for a changed entity. */
-function readRouteFor(type, entityId) {
+function readRouteFor(type, entityId, row) {
+    if (row === undefined && ['workspace', 'call_partition', 'turn_group', 'projection_decision', 'side_effect_ledger'].includes(type))
+        return '/api/v1/snapshot';
     const routes = {
         project: `/api/v1/projects/${entityId}`,
+        workspace: `/api/v1/projects/${String(row?.project_id)}/workspaces`,
+        call_partition: `/api/v1/steps/${String(row?.step_id)}/partitions`,
+        turn_group: `/api/v1/agents/${String(row?.agent_id)}/context/turn-groups`,
+        projection_decision: `/api/v1/agents/${String(row?.agent_id)}/context/projection/decisions`,
+        agent_plan: `/api/v1/agents/${entityId}`,
+        side_effect_ledger: `/api/v1/steps/${String(row?.step_id)}`,
+        maintenance: '/api/v1/snapshot',
         task: `/api/v1/tasks/${entityId}`,
         session: `/api/v1/sessions/${entityId}`,
         agent: `/api/v1/agents/${entityId}`,
@@ -2413,7 +3210,8 @@ function attentionItems(calls) {
  */
 const SCOPE_PARENT = {
     step: { type: 'run', table: 'runs', column: 'run_id' },
-    partition: { type: 'step', table: 'steps', column: 'step_id' },
+    call_partition: { type: 'step', table: 'steps', column: 'step_id' },
+    side_effect_ledger: { type: 'step', table: 'steps', column: 'step_id' },
     result: { type: 'call', table: 'calls', column: 'call_id' }
 };
 /**