maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

package/node_modules/@maka/storage/dist/agent-run-store.js

@@ -18,17 +18,19 @@
  */
 import { resolve } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
-import { decodeAgentRunEvent, decodeAgentRunHeader, decodeCurrentAgentRunHeader, } from './execution-record-codec.js';
+import { decodeAgentRunEvent, decodeRuntimeEvent } from './execution-record-codec.js';
 import { normalizeSubmittedTurnIntent, submittedTurnIntentsEqual, } from './submitted-turn-intent.js';
 import { assertNoReservedWorkspaceAuthorityAppend } from './runtime-event-authority.js';
 import { acquireOperationalStateDatabase, } from './operational-state-store.js';
 import { assertEvidenceReadBudget, measureEvidenceRows, } from './bounded-evidence.js';
 import { decodeSkillInvocationResult, } from '@maka/core/skill-invocation';
-import { aggregateMessageContents, decodeMessageContent, isCanonicalAttachmentRef, messageContentsEqual, } from '@maka/core/events';
+import { aggregateMessageContents, decodeMessageContent, hasMeaningfulMessageContent, isCanonicalAttachmentRef, messageContentsEqual, } from '@maka/core/events';
 import { decodeAgentGraphIntentClaim } from '@maka/core/agent-graph-control';
 import { MAX_ATTACHMENT_BYTES, MAX_ATTACHMENT_COUNT } from '@maka/core/attachments';
 import { MODEL_CALL_ATTEMPT_EVENT_TYPE } from '@maka/core/model-call-attempt';
-import { LATEST_CONTEXT_PROJECTION_TYPE, supersedesLatestContext, isSessionInlineRun, } from '@maka/core/agent-run';
+import { LATEST_CONTEXT_PROJECTION_TYPE, RUN_COMPOSITION_RECORDED_EVENT_TYPE, supersedesLatestContext, } from '@maka/core/agent-run';
+import { isSessionInlineInvocation, } from '@maka/core/runtime-invocation';
+import { decodeRuntimeInvocationOpened, runtimeEventInvocationOpening, } from '@maka/core/runtime-event';
 import { encodeCanonicalRuntimeEvent } from '@maka/core/canonical-runtime-event';
 import { isOrchestrationMode, isTurnOrchestrationSource, } from '@maka/core/orchestration';
 import { validateGenericToolLedgerAppend, } from '@maka/core/tool-ledger-scanner';
@@ -57,188 +59,41 @@ class SqliteAgentRunStore {
     ready() {
         return Promise.resolve();
     }
-    async createRun(header, _options = {}) {
-        const normalized = normalizeCurrentAgentRunHeader(header, header.sessionId, header.runId);
-        this.#lease.transaction('write', () => {
-            const inserted = this.#lease.database
-                .prepare(`
-          INSERT OR IGNORE INTO core_agent_runs(
-            session_id, run_id, created_at, record_json
-          ) VALUES (?, ?, ?, ?)
-        `)
-                .run(normalized.sessionId, normalized.runId, normalized.createdAt, JSON.stringify(normalized, sanitizeJson));
-            if (inserted.changes !== 1) {
-                throw new Error(`Agent run already exists: ${normalized.runId}`);
-            }
-            const count = this.#lease.database
-                .prepare('SELECT COUNT(*) AS count FROM core_agent_runs WHERE session_id = ?')
-                .get(normalized.sessionId);
-            const projection = this.#lease.database
-                .prepare(`
-          SELECT 1 AS present
-          FROM core_agent_run_projections
-          WHERE session_id = ? AND event_type = 'history_compact_checkpoint_recorded'
-        `)
-                .get(normalized.sessionId);
-            if (count.count === 1 && !projection) {
-                this.#lease.database
-                    .prepare(`
-            INSERT INTO core_agent_run_projections(session_id, event_type, event_json)
-            VALUES (?, 'history_compact_checkpoint_recorded', NULL)
-          `)
-                    .run(normalized.sessionId);
-            }
-        });
-        return normalized;
-    }
-    async updateRun(sessionId, runId, patch, _options = {}) {
-        assertMutableRunHeaderPatch(patch);
-        assertSafeId(sessionId, 'Invalid session id');
-        assertSafeId(runId, 'Invalid run id');
-        return this.#lease.transaction('write', () => {
-            const current = readSqliteAgentRun(this.#lease.database, sessionId, runId);
-            if (Object.hasOwn(patch, 'runComposition')) {
-                if (!patch.runComposition) {
-                    throw new Error('AgentRun Run Composition cannot be cleared');
-                }
-                if (current.runComposition &&
-                    !isDeepStrictEqual(current.runComposition, patch.runComposition)) {
-                    throw new Error('AgentRun Run Composition is immutable');
-                }
-            }
-            const next = normalizeCurrentAgentRunHeader({ ...current, ...patch, sessionId, runId }, sessionId, runId);
-            const result = this.#lease.database
-                .prepare(`
-          UPDATE core_agent_runs
-          SET created_at = ?, record_json = ?
-          WHERE session_id = ? AND run_id = ?
-        `)
-                .run(next.createdAt, JSON.stringify(next, sanitizeJson), sessionId, runId);
-            if (result.changes !== 1)
-                throw new Error(`Failed to update run ${runId}`);
-            return next;
-        });
-    }
-    async readRun(sessionId, runId) {
-        assertSafeId(sessionId, 'Invalid session id');
-        assertSafeId(runId, 'Invalid run id');
-        return readSqliteAgentRun(this.#lease.database, sessionId, runId);
-    }
-    async listSessionRuns(sessionId) {
-        return this.listSessionRunsForRecovery(sessionId);
-    }
-    async listSessionRunsBounded(sessionId, limit) {
-        assertSafeId(sessionId, 'Invalid session id');
-        assertIdentitySearchLimit(limit);
-        const rows = this.#lease.database
-            .prepare(`
-        SELECT run_id, record_json
-        FROM core_agent_runs
-        WHERE session_id = ?
-        ORDER BY created_at, run_id
-        LIMIT ?
-      `)
-            .all(sessionId, limit + 1);
-        const truncated = rows.length > limit;
-        const runs = rows.slice(0, limit).map((row) => {
-            if (typeof row.run_id !== 'string' || typeof row.record_json !== 'string') {
-                throw new Error('Invalid SQLite AgentRun row');
-            }
-            return decodePersistedAgentRunHeader(JSON.parse(row.record_json), sessionId, row.run_id);
-        });
-        return { runs, truncated };
-    }
-    async listSessionRunsPage(sessionId, input) {
-        assertSafeId(sessionId, 'Invalid session id');
-        assertIdentitySearchLimit(input.limit);
-        if (input.before) {
-            assertSafeId(input.before.runId, 'Invalid AgentRun page cursor');
-            if (!Number.isFinite(input.before.createdAt)) {
-                throw new Error('Invalid AgentRun page cursor');
-            }
-        }
-        const rows = this.#lease.database
-            .prepare(input.before
-            ? `
-            SELECT run_id, created_at, record_json
-            FROM core_agent_runs
-            WHERE session_id = ?
-              AND (created_at < ? OR (created_at = ? AND run_id < ?))
-            ORDER BY created_at DESC, run_id DESC
-            LIMIT ?
-          `
-            : `
-            SELECT run_id, created_at, record_json
-            FROM core_agent_runs
-            WHERE session_id = ?
-            ORDER BY created_at DESC, run_id DESC
-            LIMIT ?
-          `)
-            .all(...(input.before
-            ? [
-                sessionId,
-                input.before.createdAt,
-                input.before.createdAt,
-                input.before.runId,
-                input.limit + 1,
-            ]
-            : [sessionId, input.limit + 1]));
-        const pageRows = rows.slice(0, input.limit);
-        const runs = pageRows.map((row) => {
-            if (typeof row.run_id !== 'string' ||
-                typeof row.created_at !== 'number' ||
-                typeof row.record_json !== 'string') {
-                throw new Error('Invalid SQLite AgentRun page row');
-            }
-            return decodePersistedAgentRunHeader(JSON.parse(row.record_json), sessionId, row.run_id);
-        });
-        const last = pageRows.at(-1);
-        return {
-            runs,
-            nextCursor: rows.length > input.limit &&
-                last &&
-                typeof last.run_id === 'string' &&
-                typeof last.created_at === 'number'
-                ? { createdAt: last.created_at, runId: last.run_id }
-                : null,
-        };
-    }
-    async listSessionRunsForRecovery(sessionId) {
-        assertSafeId(sessionId, 'Invalid session id');
-        const rows = this.#lease.database
-            .prepare(`
-        SELECT run_id, record_json
-        FROM core_agent_runs
-        WHERE session_id = ?
-        ORDER BY created_at, run_id
-      `)
-            .all(sessionId);
-        return rows.map((row) => {
-            if (typeof row.run_id !== 'string' || typeof row.record_json !== 'string') {
-                throw new Error('Invalid SQLite AgentRun row');
-            }
-            return decodePersistedAgentRunHeader(JSON.parse(row.record_json), sessionId, row.run_id);
-        });
-    }
     async appendEvent(sessionId, runId, event, options = {}) {
         assertSafeId(sessionId, 'Invalid session id');
         assertSafeId(runId, 'Invalid run id');
         this.#lease.transaction('write', () => {
-            const header = readSqliteAgentRun(this.#lease.database, sessionId, runId);
+            const anchor = readSqliteRunAnchor(this.#lease.database, sessionId, runId);
+            this.#openLedgerStream(sessionId, runId, anchor.openedAt);
             const normalized = decodeAgentRunEvent(JSON.parse(JSON.stringify(event, sanitizeJson)), {
                 sessionId,
                 runId,
-                turnId: header.turnId,
+                turnId: anchor.turnId,
             });
             const type = normalized.type;
+            if (type === RUN_COMPOSITION_RECORDED_EVENT_TYPE) {
+                // Write-once, enforced where the record lives. The composition is what
+                // the run was dispatched against; a second, different one would claim
+                // the run ran on a prompt and tool surface it never saw. An identical
+                // re-append is the writer retrying, so it is absorbed rather than
+                // refused.
+                const recorded = readSqliteRunCompositionEvent(this.#lease.database, sessionId, runId);
+                if (recorded) {
+                    if (!isDeepStrictEqual(recorded.data, normalized.data)) {
+                        throw new Error('AgentRun Run Composition is immutable');
+                    }
+                    return;
+                }
+            }
             const projectsCheckpoint = type === 'history_compact_checkpoint_recorded';
             const projection = projectsCheckpoint
-                ? readSqliteAgentRunProjection(this.#lease.database, sessionId, type)
+                ? inspectSqliteAgentRunProjection(this.#lease.database, sessionId, type)
                 : undefined;
             insertAgentRunEvent(this.#lease.database, normalized);
-            if (projectsCheckpoint) {
-                const row = shouldPreserveCheckpointProjectionDuringAppend(projection, normalized)
-                    ? projection
+            if (projection && projection.state !== 'malformed') {
+                const current = projectionValue(projection);
+                const row = shouldPreserveCheckpointProjectionDuringAppend(current, normalized)
+                    ? current
                     : normalized;
                 writeSqliteAgentRunProjection(this.#lease.database, sessionId, type, row);
             }
@@ -248,13 +103,53 @@ class SqliteAgentRunStore {
             //
             // Skipped for a subagent's run: those requests are real, but presenting
             // one as the SESSION's latest context attributes another agent's prompt
-            // to this one. The header is already loaded here, so the check is free.
+            // to this one. The opening fact is already loaded here, so the check is
+            // free.
             const latestContext = options.latestContext;
-            if (latestContext && isSessionInlineRun(header)) {
+            if (latestContext && anchor.sessionInline) {
                 this.#writeLatestContextProjection(sessionId, normalized, latestContext);
             }
         });
     }
+    /**
+     * Give this run's ledger its stream row, and the Session its first one.
+     *
+     * The row carries no semantic state: it is the parent `core_agent_run_events`
+     * hangs off and the place the model-call high water lives. Creating it on the
+     * first append is what stops it from being a second record of the run's
+     * existence — the opening fact already is that.
+     *
+     * The Session's first stream also initialises the compaction-checkpoint
+     * projection to an explicit empty, which is how a reader tells "no checkpoint
+     * yet" from "projection never built".
+     */
+    #openLedgerStream(sessionId, runId, createdAt) {
+        const inserted = this.#lease.database
+            .prepare('INSERT OR IGNORE INTO core_agent_runs(session_id, run_id, created_at) VALUES (?, ?, ?)')
+            .run(sessionId, runId, createdAt);
+        if (inserted.changes !== 1)
+            return;
+        const count = this.#lease.database
+            .prepare('SELECT COUNT(*) AS count FROM core_agent_runs WHERE session_id = ?')
+            .get(sessionId);
+        if (count.count !== 1)
+            return;
+        const projection = this.#lease.database
+            .prepare(`
+        SELECT 1 AS present
+        FROM core_agent_run_projections
+        WHERE session_id = ? AND event_type = 'history_compact_checkpoint_recorded'
+      `)
+            .get(sessionId);
+        if (projection)
+            return;
+        this.#lease.database
+            .prepare(`
+        INSERT INTO core_agent_run_projections(session_id, event_type, event_json)
+        VALUES (?, 'history_compact_checkpoint_recorded', NULL)
+      `)
+            .run(sessionId);
+    }
     /**
      * Monotonic by the request's own completion, not by arrival.
      *
@@ -265,7 +160,13 @@ class SqliteAgentRunStore {
      * sharing a millisecond still order the same way everywhere.
      */
     #writeLatestContextProjection(sessionId, event, latest) {
-        const existing = readSqliteAgentRunProjection(this.#lease.database, sessionId, LATEST_CONTEXT_PROJECTION_TYPE);
+        const inspected = inspectSqliteAgentRunProjection(this.#lease.database, sessionId, LATEST_CONTEXT_PROJECTION_TYPE);
+        // The canonical append must survive a damaged derived row, but the row's
+        // ordering is unknowable. Leave it untouched until a ledger rebuild can
+        // select the real latest attempt and repair it without guessing.
+        if (inspected.state === 'malformed')
+            return;
+        const existing = projectionValue(inspected);
         // Compared against the stored row's own completion, which the snapshot
         // carries — not against an ordering field the row does not have, which is
         // how the first version of this guard silently never fired. The rule
@@ -317,14 +218,27 @@ class SqliteAgentRunStore {
         assertSafeId(sessionId, 'Invalid session id');
         return readSqliteAgentRunProjection(this.#lease.database, sessionId, type);
     }
-    async repairEventProjection(sessionId, type, event, options = {}) {
+    async readEventLedgerRevision(sessionId) {
+        assertSafeId(sessionId, 'Invalid session id');
+        return readSqliteAgentRunLedgerRevision(this.#lease.database, sessionId);
+    }
+    async repairEventProjection(sessionId, type, event, options) {
         assertSafeId(sessionId, 'Invalid session id');
+        if (!options || typeof options.ifLedgerRevision !== 'string') {
+            throw new Error('AgentRun projection repair requires a canonical ledger revision');
+        }
         if (event !== null && !isProjectedAgentRunEvent(event, sessionId, type)) {
             throw new Error(`Invalid AgentRun event projection repair for ${type}`);
         }
         this.#lease.transaction('write', () => {
-            const current = readSqliteAgentRunProjection(this.#lease.database, sessionId, type);
-            if (current?.id !== options.replaceEventId &&
+            if (readSqliteAgentRunLedgerRevision(this.#lease.database, sessionId) !==
+                options.ifLedgerRevision) {
+                return;
+            }
+            const inspected = inspectSqliteAgentRunProjection(this.#lease.database, sessionId, type);
+            const current = projectionValue(inspected);
+            if (inspected.state !== 'malformed' &&
+                current?.id !== options.replaceEventId &&
                 shouldPreserveProjectionDuringRepair(current, event, type)) {
                 return;
             }
@@ -344,6 +258,26 @@ class SqliteAgentRunStore {
             if (readSqliteRootTurnStartRejection(this.#lease.database, admission.sessionId, admission.turnId)) {
                 throw new Error('Root Turn identity is already rejected');
             }
+            if (admission.execution.kind === 'safe_boundary_continuation') {
+                const sourceOwner = this.#lease.database
+                    .prepare(`
+            SELECT turn_id
+            FROM core_root_turn_admissions
+            WHERE session_id = ?
+              AND json_extract(record_json, '$.execution.sourceTurnId') = ?
+              AND json_extract(record_json, '$.execution.sourceRunId') = ?
+              AND json_extract(record_json, '$.execution.kind') = 'safe_boundary_continuation'
+            ORDER BY admitted_at, turn_id
+            LIMIT 1
+          `)
+                    .get(admission.sessionId, admission.execution.sourceTurnId, admission.execution.sourceRunId);
+                if (typeof sourceOwner?.turn_id === 'string') {
+                    const owner = readSqliteRootTurnAdmission(this.#lease.database, admission.sessionId, sourceOwner.turn_id);
+                    if (!owner)
+                        throw new Error('Root continuation index has no durable admission');
+                    return { kind: 'conflict', admission: owner };
+                }
+            }
             for (const source of admission.sourceMessages) {
                 const proof = this.#lease.database
                     .prepare(`
@@ -379,6 +313,30 @@ class SqliteAgentRunStore {
         assertSafeId(turnId, 'Invalid turn id');
         return readSqliteRootTurnAdmission(this.#lease.database, sessionId, turnId);
     }
+    async readRootTurnContinuationAdmission(sessionId, sourceTurnId, sourceRunId) {
+        assertSafeId(sessionId, 'Invalid session id');
+        assertSafeId(sourceTurnId, 'Invalid source turn id');
+        assertSafeId(sourceRunId, 'Invalid source run id');
+        const row = this.#lease.database
+            .prepare(`
+        SELECT turn_id, record_json
+        FROM core_root_turn_admissions
+        WHERE session_id = ?
+          AND json_extract(record_json, '$.execution.sourceTurnId') = ?
+          AND json_extract(record_json, '$.execution.sourceRunId') = ?
+          AND json_extract(record_json, '$.execution.kind') = 'safe_boundary_continuation'
+        ORDER BY admitted_at, turn_id
+        LIMIT 1
+      `)
+            .get(sessionId, sourceTurnId, sourceRunId);
+        if (!row)
+            return undefined;
+        if (typeof row.turn_id !== 'string' || typeof row.record_json !== 'string') {
+            throw new Error('Invalid SQLite root turn continuation admission row');
+        }
+        const admission = normalizeRootTurnAdmission(JSON.parse(row.record_json), sessionId, row.turn_id);
+        return admission;
+    }
     async readRootTurnStartRejection(sessionId, turnId) {
         assertSafeId(sessionId, 'Invalid session id');
         assertSafeId(turnId, 'Invalid turn id');
@@ -454,35 +412,71 @@ class SqliteAgentRunStore {
         this.#lease.close();
     }
 }
-function normalizeCurrentAgentRunHeader(value, sessionId, runId) {
-    assertSafeId(sessionId, 'Invalid session id');
-    assertSafeId(runId, 'Invalid run id');
-    return decodeCurrentAgentRunHeader(JSON.parse(JSON.stringify(value, sanitizeJson)), {
-        sessionId,
-        runId,
-    });
-}
-function decodePersistedAgentRunHeader(value, sessionId, runId) {
-    assertSafeId(sessionId, 'Invalid session id');
-    assertSafeId(runId, 'Invalid run id');
-    return decodeAgentRunHeader(value, { sessionId, runId });
+function readSqliteAgentRunLedgerRevision(db, sessionId) {
+    const rows = db
+        .prepare(`
+      SELECT run.run_id, COUNT(event.sequence) AS event_count,
+             COALESCE(MAX(event.sequence), -1) AS high_water
+      FROM core_agent_runs AS run
+      LEFT JOIN core_agent_run_events AS event
+        ON event.session_id = run.session_id AND event.run_id = run.run_id
+      WHERE run.session_id = ?
+      GROUP BY run.run_id
+      ORDER BY run.run_id
+    `)
+        .all(sessionId);
+    return JSON.stringify(rows.map((row) => {
+        if (typeof row.run_id !== 'string' ||
+            typeof row.event_count !== 'number' ||
+            !Number.isSafeInteger(row.event_count) ||
+            typeof row.high_water !== 'number' ||
+            !Number.isSafeInteger(row.high_water)) {
+            throw new Error('Invalid SQLite AgentRun ledger revision');
+        }
+        return [row.run_id, row.event_count, row.high_water];
+    }));
 }
-function readSqliteAgentRun(db, sessionId, runId) {
-    const row = db
+function readSqliteRunAnchor(db, sessionId, runId) {
+    const opening = db
         .prepare(`
-      SELECT record_json
-      FROM core_agent_runs
+      SELECT turn_id, committed_at, payload_json
+      FROM runtime_events
+      WHERE session_id = ? AND run_id = ? AND event_kind = 'invocation_opened'
+      LIMIT 1
+    `)
+        .get(sessionId, runId);
+    if (opening) {
+        const content = runtimeEventInvocationOpening(decodeRuntimeEvent(JSON.parse(opening.payload_json), {
+            sessionId,
+            runId,
+            turnId: opening.turn_id,
+        }));
+        if (!content)
+            throw new Error(`RuntimeEvent for run ${runId} is not an opening fact`);
+        return {
+            turnId: opening.turn_id,
+            openedAt: opening.committed_at,
+            sessionInline: isSessionInlineInvocation(content),
+        };
+    }
+    const legacy = db
+        .prepare(`
+      SELECT turn_id, opened_at, opening_json
+      FROM runtime_legacy_invocation_openings
       WHERE session_id = ? AND run_id = ?
+      LIMIT 1
     `)
         .get(sessionId, runId);
-    if (!row) {
-        const error = new Error(`Agent run does not exist: ${runId}`);
-        error.code = 'ENOENT';
-        throw error;
+    if (legacy) {
+        return {
+            turnId: legacy.turn_id,
+            openedAt: legacy.opened_at,
+            sessionInline: isSessionInlineInvocation(decodeRuntimeInvocationOpened(JSON.parse(legacy.opening_json))),
+        };
     }
-    if (typeof row.record_json !== 'string')
-        throw new Error('Invalid SQLite AgentRun row');
-    return decodePersistedAgentRunHeader(JSON.parse(row.record_json), sessionId, runId);
+    const error = new Error(`Agent run does not exist: ${runId}`);
+    error.code = 'ENOENT';
+    throw error;
 }
 function readSqliteAgentRunEvents(db, sessionId, runId) {
     const rows = db
@@ -495,7 +489,7 @@ function readSqliteAgentRunEvents(db, sessionId, runId) {
         .all(sessionId, runId);
     if (rows.length === 0)
         return [];
-    const header = readSqliteAgentRun(db, sessionId, runId);
+    const anchor = readSqliteRunAnchor(db, sessionId, runId);
     return rows.map((row) => {
         if (typeof row.record_json !== 'string') {
             throw new Error('Invalid SQLite AgentRun event row');
@@ -503,10 +497,33 @@ function readSqliteAgentRunEvents(db, sessionId, runId) {
         return decodeAgentRunEvent(JSON.parse(row.record_json), {
             sessionId,
             runId,
-            turnId: header.turnId,
+            turnId: anchor.turnId,
         });
     });
 }
+/** The run's one composition row, or nothing if it has not been dispatched yet. */
+function readSqliteRunCompositionEvent(db, sessionId, runId) {
+    const row = db
+        .prepare(`
+      SELECT record_json
+      FROM core_agent_run_events
+      WHERE session_id = ? AND run_id = ? AND event_type = ?
+      ORDER BY sequence
+      LIMIT 1
+    `)
+        .get(sessionId, runId, RUN_COMPOSITION_RECORDED_EVENT_TYPE);
+    if (!row)
+        return undefined;
+    if (typeof row.record_json !== 'string') {
+        throw new Error('Invalid SQLite AgentRun event row');
+    }
+    const anchor = readSqliteRunAnchor(db, sessionId, runId);
+    return decodeAgentRunEvent(JSON.parse(row.record_json), {
+        sessionId,
+        runId,
+        turnId: anchor.turnId,
+    });
+}
 function readSqliteAgentRunEventsForEvidence(db, sessionId, runId, type) {
     const rows = (type === undefined
         ? db
@@ -527,7 +544,7 @@ function readSqliteAgentRunEventsForEvidence(db, sessionId, runId, type) {
             .all(sessionId, runId, type));
     if (rows.length === 0)
         return [];
-    const header = readSqliteAgentRun(db, sessionId, runId);
+    const anchor = readSqliteRunAnchor(db, sessionId, runId);
     return rows.map((row) => {
         const lineNumber = typeof row.sequence === 'number' && Number.isSafeInteger(row.sequence) ? row.sequence + 1 : 0;
         try {
@@ -537,7 +554,7 @@ function readSqliteAgentRunEventsForEvidence(db, sessionId, runId, type) {
             return decodeAgentRunEvent(JSON.parse(row.record_json), {
                 sessionId,
                 runId,
-                turnId: header.turnId,
+                turnId: anchor.turnId,
             });
         }
         catch (error) {
@@ -546,8 +563,8 @@ function readSqliteAgentRunEventsForEvidence(db, sessionId, runId, type) {
                 id: `run-event-corrupt-${lineNumber}`,
                 runId,
                 sessionId,
-                turnId: header.turnId,
-                ts: header.updatedAt,
+                turnId: anchor.turnId,
+                ts: anchor.openedAt,
                 message: error instanceof Error ? error.message : 'Invalid SQLite AgentRun event row',
                 data: { lineNumber },
             };
@@ -616,6 +633,13 @@ function readSqliteAgentRunProjection(db, sessionId,
 // A projection key, not necessarily an event type: `latest_context` names a
 // derived row nothing ever appends under (#2323).
 type) {
+    const inspected = inspectSqliteAgentRunProjection(db, sessionId, type);
+    if (inspected.state === 'malformed') {
+        throw new Error(`Invalid AgentRun event projection for ${type}`);
+    }
+    return projectionValue(inspected);
+}
+function inspectSqliteAgentRunProjection(db, sessionId, type) {
     const row = db
         .prepare(`
       SELECT event_json
@@ -624,17 +648,27 @@ type) {
     `)
         .get(sessionId, type);
     if (!row)
-        return undefined;
+        return { state: 'missing' };
     if (row.event_json === null)
-        return null;
-    if (typeof row.event_json !== 'string') {
-        throw new Error(`Invalid AgentRun event projection for ${type}`);
+        return { state: 'empty' };
+    if (typeof row.event_json !== 'string')
+        return { state: 'malformed' };
+    let event;
+    try {
+        event = JSON.parse(row.event_json);
+    }
+    catch {
+        return { state: 'malformed' };
     }
-    const event = JSON.parse(row.event_json);
     if (!isProjectedAgentRunEvent(event, sessionId, type)) {
-        throw new Error(`Invalid AgentRun event projection for ${type}`);
+        return { state: 'malformed' };
     }
-    return event;
+    return { state: 'valid', event };
+}
+function projectionValue(inspected) {
+    if (inspected.state === 'valid')
+        return inspected.event;
+    return inspected.state === 'empty' ? null : undefined;
 }
 function writeSqliteAgentRunProjection(db, sessionId, type, event) {
     db.prepare(`
@@ -766,20 +800,14 @@ function normalizeAdmitRootTurnInput(input) {
     assertRootTurnAdmissionRecordSize(admission);
     return deepFreezeRootTurnAdmission(admission);
 }
-const MUTABLE_AGENT_RUN_HEADER_FIELDS = new Set([
-    'status',
-    'updatedAt',
-    'completedAt',
-    'runComposition',
-    'failureClass',
-    'failureMessage',
-    'abortSource',
-    'traceWriteError',
-]);
-function assertMutableRunHeaderPatch(patch) {
-    const immutable = Object.keys(patch).filter((key) => !MUTABLE_AGENT_RUN_HEADER_FIELDS.has(key));
-    if (immutable.length > 0) {
-        throw new Error(`AgentRun admission identity is immutable: ${immutable.sort().join(', ')}`);
+/** Whether a proposed admission satisfies the complete durable record contract and size bound. */
+export function rootTurnAdmissionRecordFits(input) {
+    try {
+        normalizeAdmitRootTurnInput(input);
+        return true;
+    }
+    catch {
+        return false;
     }
 }
 function shouldPreserveCheckpointProjectionDuringAppend(current, candidate) {
@@ -1024,7 +1052,10 @@ function normalizeRootTurnMessageContent(value, description, maxAttachments) {
         }
         throw new Error(`Invalid ${description}`);
     }
-    if (normalized.text.length === 0 || (normalized.attachments?.length ?? 0) > maxAttachments) {
+    // Quote- or attachment-only input is meaningful (#4804): the text carrier
+    // alone no longer decides durability admission.
+    if (!hasMeaningfulMessageContent(normalized) ||
+        (normalized.attachments?.length ?? 0) > maxAttachments) {
         throw new Error(`Invalid ${description}`);
     }
     for (const [index, attachment] of (normalized.attachments ?? []).entries()) {
@@ -1078,11 +1109,13 @@ function normalizeRootTurnSourceMessages(value) {
                 'placement',
                 'disposition',
                 ...(Object.hasOwn(item, 'submittedContentDigest') ? ['submittedContentDigest'] : []),
+                ...(Object.hasOwn(item, 'submittedPlacement') ? ['submittedPlacement'] : []),
                 ...(Object.hasOwn(item, 'submittedIntent') ? ['submittedIntent'] : []),
+                ...(Object.hasOwn(item, 'skillInvocation') ? ['skillInvocation'] : []),
             ])) {
             throw new Error(`Invalid root turn source message at index ${index}`);
         }
-        const { messageId, content, submittedContentDigest, submittedIntent, placement, disposition } = item;
+        const { messageId, content, submittedContentDigest, submittedPlacement, submittedIntent, skillInvocation, placement, disposition, } = item;
         if (typeof messageId !== 'string' ||
             !isSafeId(messageId) ||
             (placement !== 'current_turn' && placement !== 'next_turn') ||
@@ -1091,6 +1124,9 @@ function normalizeRootTurnSourceMessages(value) {
                 disposition !== 'turn_started') ||
             (disposition === 'steering' && placement !== 'current_turn') ||
             (disposition === 'followup' && placement !== 'next_turn') ||
+            (submittedPlacement !== undefined &&
+                submittedPlacement !== 'current_turn' &&
+                submittedPlacement !== 'next_turn') ||
             (submittedContentDigest !== undefined && !isSha256Digest(submittedContentDigest))) {
             throw new Error(`Invalid root turn source message at index ${index}`);
         }
@@ -1102,9 +1138,13 @@ function normalizeRootTurnSourceMessages(value) {
             messageId,
             content: normalizeRootTurnMessageContent(content, `root turn source message content at index ${index}`, MAX_ATTACHMENT_COUNT),
             ...(submittedContentDigest !== undefined ? { submittedContentDigest } : {}),
+            ...(submittedPlacement !== undefined ? { submittedPlacement } : {}),
             ...(submittedIntent !== undefined
                 ? { submittedIntent: normalizeSubmittedTurnIntent(submittedIntent) }
                 : {}),
+            ...(skillInvocation !== undefined
+                ? { skillInvocation: decodeSkillInvocationResult(skillInvocation) }
+                : {}),
             placement,
             disposition,
         });
@@ -1127,7 +1167,10 @@ function rootTurnAdmissionPayloadsEqual(left, right) {
                 source.placement === other.placement &&
                 source.disposition === other.disposition &&
                 source.submittedContentDigest === other.submittedContentDigest &&
+                (source.submittedPlacement ?? source.placement) ===
+                    (other.submittedPlacement ?? other.placement) &&
                 submittedTurnIntentsEqual(source.submittedIntent, other.submittedIntent) &&
+                isDeepStrictEqual(source.skillInvocation, other.skillInvocation) &&
                 messageContentsEqual(source.content, other.content));
         }));
 }
@@ -1143,7 +1186,9 @@ function assertRootTurnAdmissionContract(admission) {
     const execution = admission.execution;
     const providerRetry = execution.kind === 'linked_child_provider_retry';
     const inputlessExecution = execution.kind === 'safe_boundary_continuation' || execution.kind === 'context_compact';
-    const sourceBatch = execution.kind === 'external_message' && admission.sourceMessages.length > 1;
+    const allowsQueueSources = execution.kind === 'external_message' ||
+        (execution.kind === 'workhub_coordination' && execution.operation !== 'action');
+    const sourceBatch = allowsQueueSources && admission.sourceMessages.length > 1;
     const messageLessExecution = inputlessExecution || providerRetry || sourceBatch;
     if (execution.kind === 'agent_graph_supervisor_wake') {
         if (admission.turnOrchestration?.mode !== 'graph' ||
@@ -1160,14 +1205,16 @@ function assertRootTurnAdmissionContract(admission) {
     if ((admission.normalizedInput === null) !== inputlessExecution) {
         throw new Error('Invalid root turn admission contract: execution has an invalid input requirement');
     }
-    if (execution.kind !== 'external_message' && admission.sourceMessages.length !== 0) {
+    if (!allowsQueueSources && admission.sourceMessages.length !== 0) {
         throw new Error('Invalid root turn admission contract: host-authored execution cannot have source messages');
     }
     if (admission.skillInvocation && execution.kind !== 'external_message') {
         throw new Error('Invalid root turn admission contract: Skill invocation requires external message execution');
     }
-    if (admission.authorization && execution.kind !== 'external_message') {
-        throw new Error('Invalid root turn admission contract: authorization proof requires external message execution');
+    if (admission.authorization &&
+        execution.kind !== 'external_message' &&
+        execution.kind !== 'regenerate') {
+        throw new Error('Invalid root turn admission contract: authorization proof requires external message or regenerate execution');
     }
     if (execution.kind === 'claimed_agent_graph_intent') {
         if (execution.claim.targetSessionId !== admission.sessionId ||
@@ -1305,12 +1352,33 @@ function normalizeRootExecutionDescriptor(value) {
         });
     }
     if (value.kind === 'workhub_coordination') {
-        if (!hasExactKeys(value, ['kind', 'inputDigest']) || !isSha256Digest(value.inputDigest)) {
+        const routingDecision = normalizeWorkHubRoutingDecision(value.routingDecision);
+        if (!hasExactKeys(value, [
+            'kind',
+            'inputDigest',
+            ...(value.capabilityBinding === undefined ? [] : ['capabilityBinding']),
+            ...(value.routingDecision === undefined ? [] : ['routingDecision']),
+            ...(value.operation === undefined ? [] : ['operation']),
+            ...(value.actionId === undefined ? [] : ['actionId']),
+        ]) ||
+            (value.capabilityBinding !== undefined && !isSha256Digest(value.capabilityBinding)) ||
+            (value.actionId !== undefined && value.operation !== 'action') ||
+            (value.operation !== undefined && routingDecision !== undefined) ||
+            (value.operation !== undefined && value.operation !== 'action') ||
+            (value.actionId !== undefined &&
+                (typeof value.actionId !== 'string' || !isSafeId(value.actionId))) ||
+            !isSha256Digest(value.inputDigest)) {
             throw new Error('Invalid root execution descriptor');
         }
         return Object.freeze({
             kind: 'workhub_coordination',
+            ...(value.operation === 'action' ? { operation: 'action' } : {}),
             inputDigest: value.inputDigest,
+            ...(isSha256Digest(value.capabilityBinding)
+                ? { capabilityBinding: value.capabilityBinding }
+                : {}),
+            ...(typeof value.actionId === 'string' ? { actionId: value.actionId } : {}),
+            ...(routingDecision ? { routingDecision } : {}),
         });
     }
     if (value.kind === 'regenerate') {
@@ -1327,12 +1395,23 @@ function normalizeRootExecutionDescriptor(value) {
         return Object.freeze({ kind: 'context_compact' });
     }
     if (value.kind === 'scheduled_task') {
-        if (!hasExactKeys(value, ['kind', 'scheduledTaskId']) ||
+        if (!hasExactKeys(value, [
+            'kind',
+            'scheduledTaskId',
+            ...(Object.hasOwn(value, 'executionFingerprint') ? ['executionFingerprint'] : []),
+        ]) ||
             typeof value.scheduledTaskId !== 'string' ||
-            !isSafeId(value.scheduledTaskId)) {
+            !isSafeId(value.scheduledTaskId) ||
+            (value.executionFingerprint !== undefined && !isSha256Digest(value.executionFingerprint))) {
             throw new Error('Invalid root execution descriptor');
         }
-        return Object.freeze({ kind: 'scheduled_task', scheduledTaskId: value.scheduledTaskId });
+        return Object.freeze({
+            kind: 'scheduled_task',
+            scheduledTaskId: value.scheduledTaskId,
+            ...(value.executionFingerprint !== undefined
+                ? { executionFingerprint: value.executionFingerprint }
+                : {}),
+        });
     }
     if (value.kind === 'automation' || value.kind === 'legacy_automation') {
         if (!hasExactKeys(value, ['kind', 'automationId']) ||
@@ -1467,6 +1546,40 @@ function normalizeRootExecutionDescriptor(value) {
         sourceRunId: value.sourceRunId,
     });
 }
+function normalizeWorkHubRoutingDecision(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isPlainRecord(value) || typeof value.kind !== 'string') {
+        throw new Error('Invalid WorkHub routing decision');
+    }
+    if (value.kind === 'routing' &&
+        (value.disposition === 'answer_here' ||
+            value.disposition === 'create_new' ||
+            value.disposition === 'clarify') &&
+        hasExactKeys(value, ['kind', 'disposition'])) {
+        return Object.freeze({ kind: 'routing', disposition: value.disposition });
+    }
+    if (value.kind === 'routing' &&
+        value.disposition === 'delegate_existing' &&
+        typeof value.candidateSetId === 'string' &&
+        /^sha256:[a-f0-9]{64}$/.test(value.candidateSetId) &&
+        typeof value.candidateRef === 'string' &&
+        isSafeId(value.candidateRef) &&
+        hasExactKeys(value, ['kind', 'disposition', 'candidateSetId', 'candidateRef'])) {
+        return Object.freeze({
+            kind: 'routing',
+            disposition: 'delegate_existing',
+            candidateSetId: value.candidateSetId,
+            candidateRef: value.candidateRef,
+        });
+    }
+    if (value.kind === 'linked' &&
+        (value.operation === 'correct' || value.operation === 'stop' || value.operation === 'resume') &&
+        hasExactKeys(value, ['kind', 'operation'])) {
+        return Object.freeze({ kind: 'linked', operation: value.operation });
+    }
+    throw new Error('Invalid WorkHub routing decision');
+}
 function deepFreezeRootTurnMessageContent(content) {
     for (const attachment of content.attachments ?? []) {
         Object.freeze(attachment.ref);
@@ -1474,6 +1587,10 @@ function deepFreezeRootTurnMessageContent(content) {
     }
     if (content.attachments)
         Object.freeze(content.attachments);
+    for (const reference of content.directoryReferences ?? [])
+        Object.freeze(reference);
+    if (content.directoryReferences)
+        Object.freeze(content.directoryReferences);
     for (const quote of content.quotes ?? [])
         Object.freeze(quote);
     if (content.quotes)