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

package/node_modules/@maka/storage/dist/sqlite-session-metadata-store.js

@@ -22,6 +22,7 @@ import { dirname, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { existsSync, mkdirSync } from 'node:fs';
 import { isDeepStrictEqual } from 'node:util';
+import { isCanonicalReadOnlyPermissionProfile } from '@maka/core/permission-profile';
 import { AGENT_GRAPH_CLIENT_PROJECTION_SCHEMA_VERSION, AgentGraphClientProjectionConflictError, AgentGraphClientTerminalCursorError, } from '@maka/core/agent-graph-client-projection';
 import { assessSandboxBoundaryExpansion, assertExecutionBoundaryCapacity, decodeExecutionBoundary, createGenesisExecutionBoundary, SANDBOX_BOUNDARY_CLOSURE_REASONS, SANDBOX_BOUNDARY_HOST_RESTART_CLOSURE_REASON, validateSandboxBoundaryExpansion, } from '@maka/core/sandbox-boundary';
 import { AGENT_GRAPH_EPOCH_SCHEMA_VERSION, AgentGraphEpochConflictError, assertAdvanceAgentGraphEpochRequest, assertResolveAgentGraphEpochRequest, decodeAgentGraphEpochBinding, } from '@maka/core/agent-graph-epoch';
@@ -36,15 +37,15 @@ import { messageContentDigest, messageContentsEqual, normalizeMessageContent, }
 import { AGENT_GRAPH_SUPERVISOR_WAKE_SCHEMA_VERSION, } from '@maka/core/agent-graph-supervisor-wake';
 import { assertSafeSessionId, decodePersistedSessionHeader, normalizeSessionHeader, SessionNotFoundError, } from './session-store.js';
 import { isDiscardableConversationCopy, isValidConversationCopyTransition, } from './session-conversation-copy.js';
-import { catalogPreviewForUserMessage } from './session-message-projection.js';
+import { projectSessionCatalogMessages } from './session-message-projection.js';
 import { configureSqliteSessionMetadataDatabase, migrateSqliteSessionMetadataDatabase, readSqliteSessionMetadataSchemaVersion, SQLITE_AGENT_GRAPH_CONTROL_TABLES, SQLITE_SESSION_MESSAGE_CHUNK_BYTES, SQLITE_SESSION_MESSAGE_CHUNK_MARKER, } from './sqlite-session-metadata-schema.js';
 import { buildSqliteSessionCatalogPageQuery, } from './sqlite-session-catalog-query.js';
 import { sqliteOrdinarySessionRolePredicate, sqliteRecoverableSessionRolePredicate, } from './sqlite-session-role-scope.js';
 export { SQLITE_SESSION_METADATA_SCHEMA_VERSION } from './sqlite-session-metadata-schema.js';
 const SQLITE_TRANSCRIPT_MESSAGE_LOOKUP_BATCH_SIZE = 256;
-const SQLITE_TURN_CONTRIBUTION_MAX_SOURCE_MESSAGES = 1_024;
-const SQLITE_TURN_CONTRIBUTION_MAX_SOURCE_BYTES = 4 * 1024 * 1024;
-const SQLITE_TURN_LANDMARK_LEGACY_NEIGHBOR_MESSAGES = 32;
+// Each target Session binds three parameters in the linkage query. Stay well
+// inside SQLite's bound-parameter limit.
+const WORKHUB_TARGET_LINKAGE_MAX_SESSIONS = 256;
 function decodeStoredMessage(value) {
     return decodePersistedStoredMessage(markPersisted(value));
 }
@@ -72,6 +73,7 @@ function decodeMessageAdmissionRow(sessionId, row) {
         typeof row.run_id !== 'string' ||
         typeof row.message_id !== 'string' ||
         typeof row.content_json !== 'string' ||
+        typeof row.skill_invocation_json !== 'string' ||
         typeof row.submitted_content_digest !== 'string' ||
         (row.submitted_placement !== 'current_turn' && row.submitted_placement !== 'next_turn') ||
         (row.placement !== 'current_turn' && row.placement !== 'next_turn') ||
@@ -95,6 +97,7 @@ function decodeMessageAdmissionRow(sessionId, row) {
         ...(typeof row.submitted_intent_json === 'string'
             ? { submittedIntent: normalizeSubmittedTurnIntent(JSON.parse(row.submitted_intent_json)) }
             : {}),
+        skillInvocation: JSON.parse(row.skill_invocation_json),
         admittedAt: row.admitted_at,
     });
 }
@@ -346,6 +349,32 @@ export class SqliteSessionMetadataStore {
             return rows.map(decodeSandboxBoundaryRequestRow);
         });
     }
+    async hasExplicitSandboxBoundaryDenial(identities) {
+        this.assertOpen();
+        const query = this.db.prepare(`
+      SELECT
+        MAX(CASE WHEN outcome_reason = 'client_denied' THEN 1 ELSE 0 END) AS explicit,
+        MAX(CASE WHEN outcome_reason IN ('client_denied', 'turn_stopped', 'turn_terminal', 'host_restarted')
+          THEN 0 ELSE 1 END) AS ambiguous
+      FROM sandbox_boundary_log
+      WHERE session_id = ? AND run_id = ? AND turn_id = ?
+        AND entry_kind = 'expansion_request' AND status = 'denied'
+    `);
+        let denied = false;
+        for (const identity of identities) {
+            assertSafeSessionId(identity.sessionId);
+            assertSandboxBoundaryProvenanceId(identity.runId, 'run id');
+            assertSandboxBoundaryProvenanceId(identity.turnId, 'turn id');
+            const evidence = query.get(identity.sessionId, identity.runId, identity.turnId);
+            // Legacy NULL also meant internal cleanup. Do not invent a user decision
+            // or erase a possible denial; ambiguous provenance blocks this continuation.
+            if (evidence.ambiguous === 1) {
+                throw new Error('Historical sandbox denial cannot be attributed safely; start a new user Turn.');
+            }
+            denied ||= evidence.explicit === 1;
+        }
+        return denied;
+    }
     async settleSandboxBoundaryRequest(input) {
         this.assertOpen();
         assertSafeSessionId(input.sessionId);
@@ -373,7 +402,7 @@ export class SqliteSessionMetadataStore {
                     sessionId: input.sessionId,
                     requestId: input.requestId,
                     status: 'denied',
-                    ...(input.closureReason ? { outcomeReason: input.closureReason } : {}),
+                    outcomeReason: input.closureReason ?? 'client_denied',
                     settledAt,
                 });
                 return {
@@ -702,10 +731,12 @@ export class SqliteSessionMetadataStore {
             throw new SessionNotFoundError(sessionId);
         return record;
     }
-    async readCatalogRecord(sessionId) {
+    async readCatalogRecord(sessionId, roleScope = 'ordinary') {
         this.assertOpen();
         assertSafeSessionId(sessionId);
-        const role = sqliteOrdinarySessionRolePredicate();
+        const role = roleScope === 'recoverable'
+            ? sqliteRecoverableSessionRolePredicate()
+            : sqliteOrdinarySessionRolePredicate();
         const row = this.db
             .prepare(`
         SELECT
@@ -903,6 +934,10 @@ export class SqliteSessionMetadataStore {
                 .run(sessionId);
         });
     }
+    /**
+     * Session records in catalog order, each carrying the projection the Session
+     * list shows.
+     */
     async list(filter, roleScope) {
         this.assertOpen();
         const { where, parameters } = buildSessionListPredicate(filter ?? {});
@@ -918,17 +953,21 @@ export class SqliteSessionMetadataStore {
         }
         const rows = this.db
             .prepare(`
-        SELECT session_id, payload_json, metadata_version, committed_at
+        SELECT
+          metadata.session_id,
+          metadata.payload_json,
+          metadata.metadata_version,
+          metadata.committed_at,
+          COALESCE(projection.activity_at, 0) AS activity_at,
+          projection.last_message_preview
         FROM session_metadata metadata
+        LEFT JOIN session_catalog_projection projection
+          ON projection.session_id = metadata.session_id
         ${where.length > 0 ? `WHERE ${where.join(' AND ')}` : ''}
-        ORDER BY (
-          SELECT activity_at
-          FROM session_catalog_projection projection
-          WHERE projection.session_id = metadata.session_id
-        ) DESC, session_id ASC
+        ORDER BY activity_at DESC, metadata.session_id ASC
       `)
             .all(...parameters);
-        return rows.map(decodeRecord);
+        return rows.map(decodeCatalogRecord);
     }
     async listCatalogPage(filter, cursor, limit) {
         this.assertOpen();
@@ -1114,7 +1153,7 @@ export class SqliteSessionMetadataStore {
             .prepare(`
         SELECT turn_id, run_id, message_id, content_json, submitted_content_digest,
           submitted_placement, placement, disposition, queue_order, admitted_at,
-          submitted_intent_json
+          submitted_intent_json, skill_invocation_json
         FROM message_admissions
         WHERE session_id = ? AND message_id = ?
       `)
@@ -1143,14 +1182,20 @@ export class SqliteSessionMetadataStore {
           INSERT INTO message_admissions(
             session_id, turn_id, run_id, message_id, content_json, submitted_content_digest,
             submitted_placement, placement, disposition, queue_order, admitted_at,
-            submitted_intent_json
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            submitted_intent_json, skill_invocation_json
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         `)
-            .run(stored.sessionId, stored.turnId, stored.runId, stored.messageId, JSON.stringify(stored.content), stored.submittedContentDigest, stored.submittedPlacement, stored.placement, stored.disposition, orderRow.next_order, stored.admittedAt, stored.submittedIntent ? JSON.stringify(stored.submittedIntent) : null);
+            .run(stored.sessionId, stored.turnId, stored.runId, stored.messageId, JSON.stringify(stored.content), stored.submittedContentDigest, stored.submittedPlacement, stored.placement, stored.disposition, orderRow.next_order, stored.admittedAt, stored.submittedIntent ? JSON.stringify(stored.submittedIntent) : null, JSON.stringify(stored.skillInvocation));
     }
     async assignWorkHubMessage(request) {
         const assignmentJson = JSON.stringify(request.assignment);
         const assignment = decodeCanonicalMessage(JSON.parse(assignmentJson));
+        const supersessionJson = request.supersession
+            ? JSON.stringify(request.supersession)
+            : undefined;
+        const supersession = supersessionJson
+            ? decodeCanonicalMessage(JSON.parse(supersessionJson))
+            : undefined;
         const admission = normalizePendingMessageAdmission(request.admission);
         const suffix = createHash('sha256')
             .update(request.assignment.actionId)
@@ -1164,13 +1209,37 @@ export class SqliteSessionMetadataStore {
             assignment.id !== `wha_${suffix}` ||
             assignment.targetMessageId !== `whm_${suffix}` ||
             assignment.delegationId !== `whd_${suffix}` ||
-            !messageContentsEqual(admission.content, normalizeMessageContent({ text: assignment.userText })) ||
+            !workHubAssignmentAttachmentsMatchTarget(assignment) ||
+            !messageContentsEqual(admission.content, normalizeMessageContent({
+                text: assignment.delegationText ?? assignment.userText,
+                ...(assignment.targetAttachments ? { attachments: assignment.targetAttachments } : {}),
+            })) ||
             admission.submittedContentDigest !== messageContentDigest(admission.content) ||
             admission.submittedPlacement !== 'current_turn' ||
             admission.placement !== 'current_turn' ||
             admission.disposition !== 'steering') {
             throw new SessionMetadataConflictError('Invalid WorkHub assignment identity');
         }
+        if ((assignment.replacesActionId === undefined) !==
+            (assignment.replacesDelegationId === undefined) ||
+            (assignment.replacesDelegationId === undefined) !== (supersession === undefined) ||
+            (supersession !== undefined &&
+                (supersession.type !== 'workhub_coordination' ||
+                    supersession.kind !== 'delegation_superseded' ||
+                    supersession.actionId !== assignment.actionId ||
+                    supersession.actionFingerprint !== assignment.actionFingerprint ||
+                    supersession.coordinationTurnId !== assignment.coordinationTurnId ||
+                    supersession.turnId !== assignment.coordinationTurnId ||
+                    supersession.supersededActionId !== assignment.replacesActionId ||
+                    supersession.supersededDelegationId !== assignment.replacesDelegationId ||
+                    supersession.replacementDelegationId !== assignment.delegationId ||
+                    supersession.id !==
+                        `whx_${createHash('sha256')
+                            .update(supersession.supersededDelegationId)
+                            .digest('hex')
+                            .slice(0, 48)}`))) {
+            throw new SessionMetadataConflictError('Invalid WorkHub supersession identity');
+        }
         const create = request.create
             ? {
                 header: normalizeSessionHeader(request.create.header),
@@ -1207,6 +1276,39 @@ export class SqliteSessionMetadataStore {
                     assignment: existingAssignment,
                 };
             }
+            if (supersession && assignment.replacesActionId && assignment.replacesDelegationId) {
+                const replacedSuffix = createHash('sha256')
+                    .update(assignment.replacesActionId)
+                    .digest('hex')
+                    .slice(0, 48);
+                const replaced = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `wha_${replacedSuffix}`);
+                if (replaced?.type !== 'workhub_coordination' ||
+                    replaced.kind !== 'delegation_assigned' ||
+                    replaced.delegationId !== assignment.replacesDelegationId) {
+                    throw new SessionMetadataConflictError('WorkHub supersession source is unavailable');
+                }
+                const abortSuffix = createHash('sha256')
+                    .update(assignment.replacesDelegationId)
+                    .digest('hex')
+                    .slice(0, 48);
+                const stopRequest = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whq_${abortSuffix}`);
+                if (stopRequest) {
+                    const stopResolution = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whz_${abortSuffix}`);
+                    if (stopResolution?.type !== 'workhub_coordination' ||
+                        stopResolution.kind !== 'delegation_stop_resolved' ||
+                        stopResolution.outcome !== 'not_owned') {
+                        throw new SessionMetadataConflictError('WorkHub delegation already has a stop claim');
+                    }
+                }
+                const existingAbort = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whb_${abortSuffix}`);
+                if (existingAbort) {
+                    throw new SessionMetadataConflictError('WorkHub delegation replacement is aborted');
+                }
+                const existingSupersession = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, supersession.id);
+                if (existingSupersession) {
+                    throw new SessionMetadataConflictError('WorkHub delegation is already superseded');
+                }
+            }
             let targetCreated = false;
             if (create) {
                 const probe = this.probeStableSessionCreateSync(create.header.id, create.requestFingerprint);
@@ -1232,8 +1334,19 @@ export class SqliteSessionMetadataStore {
             if (target.header.status === 'waiting_for_user') {
                 throw new SessionMetadataConflictError('WorkHub target Session is waiting for user input');
             }
+            let committedAssignment = assignment;
+            let committedAssignmentJson = assignmentJson;
             if (target.header.name !== assignment.targetSessionName) {
-                throw new SessionMetadataConflictError('WorkHub target display identity changed');
+                if (assignment.disposition !== 'delegate_existing' ||
+                    assignment.replacesDelegationId === undefined) {
+                    throw new SessionMetadataConflictError('WorkHub target display identity changed');
+                }
+                // A durable replacement owns the target Session id before retiring the
+                // source. Canonicalize its display-only name at the same transaction
+                // boundary that validates the target so a concurrent rename cannot
+                // strand the already-retired delegation.
+                committedAssignment = { ...assignment, targetSessionName: target.header.name };
+                committedAssignmentJson = JSON.stringify(committedAssignment);
             }
             if (this.readMessageAdmissionSync(admission.sessionId, admission.messageId)) {
                 throw new SessionMetadataConflictError('WorkHub target Message identity belongs to another admission');
@@ -1247,9 +1360,14 @@ export class SqliteSessionMetadataStore {
                 sequenceRow.last_sequence < -1) {
                 throw new SessionMetadataConflictError('Invalid WorkHub transcript sequence');
             }
-            this.insertSessionMessagesSync(WORKHUB_COORDINATION_SESSION_ID, sequenceRow.last_sequence + 1, [{ message: assignment, json: assignmentJson }]);
+            this.insertSessionMessagesSync(WORKHUB_COORDINATION_SESSION_ID, sequenceRow.last_sequence + 1, [
+                { message: committedAssignment, json: committedAssignmentJson },
+                ...(supersession && supersessionJson
+                    ? [{ message: supersession, json: supersessionJson }]
+                    : []),
+            ]);
             this.updateCatalogProjectionSync(WORKHUB_COORDINATION_SESSION_ID, request.projection, false);
-            return { kind: 'assigned', targetCreated, assignment };
+            return { kind: 'assigned', targetCreated, assignment: committedAssignment };
         });
     }
     async readMessageAdmission(sessionId, messageId) {
@@ -1261,7 +1379,7 @@ export class SqliteSessionMetadataStore {
                 .prepare(`
           SELECT turn_id, run_id, message_id, content_json, submitted_content_digest,
             submitted_placement, placement, disposition, queue_order, admitted_at,
-            submitted_intent_json
+            submitted_intent_json, skill_invocation_json
           FROM message_admissions
           WHERE session_id = ? AND message_id = ?
         `)
@@ -1280,6 +1398,106 @@ export class SqliteSessionMetadataStore {
             return row !== undefined;
         });
     }
+    /**
+     * Binds one WorkHub action identity to one exact operation, for good.
+     *
+     * Every other durable WorkHub record is keyed by what it is about, so none of
+     * them can see an action id that moved to a second delegation or a second
+     * disposition. This row is the global owner that rejects both, and it is
+     * written before the action's effect so a rejected or recovering attempt can
+     * never leak its identity into a different operation.
+     */
+    async claimWorkHubAction(claim) {
+        this.assertOpen();
+        assertSafeSessionId(claim.actionId);
+        assertSafeSessionId(claim.subject);
+        if (!/^sha256:[a-f0-9]{64}$/u.test(claim.actionFingerprint)) {
+            throw new SessionMetadataConflictError('Invalid WorkHub action fingerprint');
+        }
+        return this.transaction(() => {
+            const existing = this.readWorkHubActionClaimSync(claim.actionId);
+            if (existing) {
+                return existing.operation === claim.operation &&
+                    existing.actionFingerprint === claim.actionFingerprint &&
+                    existing.subject === claim.subject
+                    ? 'same_claim'
+                    : 'conflict';
+            }
+            this.db
+                .prepare(`
+          INSERT INTO workhub_action_claims(
+            action_id, operation, action_fingerprint, subject, claimed_at
+          ) VALUES (?, ?, ?, ?, ?)
+        `)
+                .run(claim.actionId, claim.operation, claim.actionFingerprint, claim.subject, this.now());
+            return 'claimed';
+        });
+    }
+    async readWorkHubActionClaim(actionId) {
+        this.assertOpen();
+        assertSafeSessionId(actionId);
+        return this.readTransaction(() => this.readWorkHubActionClaimSync(actionId));
+    }
+    readWorkHubActionClaimSync(actionId) {
+        const row = this.db
+            .prepare('SELECT operation, action_fingerprint, subject FROM workhub_action_claims WHERE action_id = ?')
+            .get(actionId);
+        if (!row)
+            return undefined;
+        if (!isWorkHubActionOperation(row.operation) ||
+            typeof row.action_fingerprint !== 'string' ||
+            !/^sha256:[a-f0-9]{64}$/u.test(row.action_fingerprint) ||
+            typeof row.subject !== 'string') {
+            throw new SessionMetadataConflictError('Invalid WorkHub action claim row');
+        }
+        return {
+            actionId,
+            operation: row.operation,
+            actionFingerprint: row.action_fingerprint,
+            subject: row.subject,
+        };
+    }
+    async claimMessageAdmissionCancellation(sessionId, messageId, claimId) {
+        this.assertOpen();
+        assertSafeSessionId(sessionId);
+        assertSafeSessionId(messageId);
+        assertSafeSessionId(claimId);
+        return this.transaction(() => {
+            const cancelled = this.db
+                .prepare('SELECT cancellation_claim_id FROM cancelled_message_admissions WHERE session_id = ? AND message_id = ?')
+                .get(sessionId, messageId);
+            if (cancelled) {
+                return cancelled.cancellation_claim_id === claimId ? 'same_claim' : 'already_cancelled';
+            }
+            const admission = this.db
+                .prepare(`
+          SELECT submitted_content_digest, submitted_placement
+          FROM message_admissions
+          WHERE session_id = ? AND message_id = ?
+        `)
+                .get(sessionId, messageId);
+            if (typeof admission?.submitted_content_digest !== 'string' ||
+                (admission.submitted_placement !== 'current_turn' &&
+                    admission.submitted_placement !== 'next_turn')) {
+                throw new SessionMetadataConflictError('Message admission cancellation identity conflict');
+            }
+            this.db
+                .prepare(`
+          INSERT INTO cancelled_message_admissions(
+            session_id, message_id, submitted_content_digest, submitted_placement,
+            cancellation_claim_id
+          ) VALUES (?, ?, ?, ?, ?)
+        `)
+                .run(sessionId, messageId, admission.submitted_content_digest, admission.submitted_placement, claimId);
+            const deleted = this.db
+                .prepare('DELETE FROM message_admissions WHERE session_id = ? AND message_id = ?')
+                .run(sessionId, messageId);
+            if (deleted.changes !== 1) {
+                throw new SessionMetadataConflictError('Message admission cancellation identity conflict');
+            }
+            return 'cancelled_by_claim';
+        });
+    }
     async listMessageAdmissions(sessionId) {
         this.assertOpen();
         assertSafeSessionId(sessionId);
@@ -1288,7 +1506,7 @@ export class SqliteSessionMetadataStore {
                 .prepare(`
           SELECT turn_id, run_id, message_id, content_json, submitted_content_digest,
             submitted_placement, placement, disposition, queue_order, admitted_at,
-            submitted_intent_json
+            submitted_intent_json, skill_invocation_json
           FROM message_admissions
           WHERE session_id = ?
           ORDER BY queue_order, sequence
@@ -1297,6 +1515,109 @@ export class SqliteSessionMetadataStore {
             return rows.map((row) => decodeMessageAdmissionRow(sessionId, row));
         });
     }
+    async readActiveWorkHubAssignmentsByTarget(targetSessionIds, maxAssignmentsPerTarget) {
+        this.assertOpen();
+        for (const sessionId of targetSessionIds)
+            assertSafeSessionId(sessionId);
+        if (targetSessionIds.length > WORKHUB_TARGET_LINKAGE_MAX_SESSIONS) {
+            throw new Error('Invalid WorkHub target Session count');
+        }
+        if (maxAssignmentsPerTarget !== undefined &&
+            (!Number.isSafeInteger(maxAssignmentsPerTarget) ||
+                maxAssignmentsPerTarget < 1 ||
+                maxAssignmentsPerTarget > 256)) {
+            throw new Error('Invalid WorkHub target Message limit');
+        }
+        const targets = [...new Set(targetSessionIds)];
+        if (targets.length === 0)
+            return [];
+        return this.readTransaction(() => {
+            const list = targets.map(() => '?').join(', ');
+            // One Message moves between these lifecycle tables — pending, admitted
+            // into a Turn, cancelled. Combine every target's identities once, then
+            // resolve activity from the canonical Coordination ledger in this same
+            // read transaction. That avoids rebuilding the target set once per page
+            // or once per candidate, without introducing another durable
+            // representation.
+            const rows = this.db
+                .prepare(`
+          WITH target_messages(session_id, message_id) AS (
+            SELECT session_id, message_id
+            FROM message_admissions
+            WHERE session_id IN (${list})
+              AND message_id GLOB 'whm_*'
+              AND length(message_id) = 52
+            UNION
+            SELECT session_id, message_id
+            FROM core_root_source_message_proofs
+            WHERE session_id IN (${list})
+              AND message_id GLOB 'whm_*'
+              AND length(message_id) = 52
+            UNION
+            SELECT session_id, message_id
+            FROM cancelled_message_admissions
+            WHERE session_id IN (${list})
+              AND message_id GLOB 'whm_*'
+              AND length(message_id) = 52
+          )
+          SELECT target.session_id, target.message_id
+          FROM target_messages AS target
+          CROSS JOIN session_messages AS assignment INDEXED BY session_messages_by_identity
+          WHERE assignment.session_id = ?
+            AND assignment.message_id = 'wha_' || substr(target.message_id, 5)
+          ORDER BY assignment.sequence DESC
+        `)
+                .iterate(...targets, ...targets, ...targets, WORKHUB_COORDINATION_SESSION_ID);
+            const assignments = [];
+            const acceptedPerTarget = new Map();
+            for (const row of rows) {
+                if (typeof row.message_id !== 'string' || typeof row.session_id !== 'string') {
+                    throw new SessionMetadataConflictError('Invalid WorkHub target Message identity');
+                }
+                const targetSessionId = row.session_id;
+                if (maxAssignmentsPerTarget !== undefined &&
+                    (acceptedPerTarget.get(targetSessionId) ?? 0) >= maxAssignmentsPerTarget) {
+                    continue;
+                }
+                const assignment = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `wha_${row.message_id.slice('whm_'.length)}`);
+                if (assignment?.type !== 'workhub_coordination' ||
+                    assignment.kind !== 'delegation_assigned' ||
+                    assignment.targetSessionId !== targetSessionId ||
+                    assignment.targetMessageId !== row.message_id) {
+                    continue;
+                }
+                const terminalSuffix = createHash('sha256')
+                    .update(assignment.delegationId, 'utf8')
+                    .digest('hex')
+                    .slice(0, 48);
+                const supersession = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whx_${terminalSuffix}`);
+                if (supersession?.type === 'workhub_coordination' &&
+                    supersession.kind === 'delegation_superseded') {
+                    continue;
+                }
+                const replacementAbort = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whb_${terminalSuffix}`);
+                if (replacementAbort?.type === 'workhub_coordination' &&
+                    replacementAbort.kind === 'delegation_replacement_aborted') {
+                    continue;
+                }
+                const stopResolution = this.readMessageByIdSync(WORKHUB_COORDINATION_SESSION_ID, `whz_${terminalSuffix}`);
+                if (stopResolution?.type === 'workhub_coordination' &&
+                    stopResolution.kind === 'delegation_stop_resolved' &&
+                    stopResolution.outcome !== 'not_owned') {
+                    continue;
+                }
+                assignments.push(assignment);
+                acceptedPerTarget.set(targetSessionId, (acceptedPerTarget.get(targetSessionId) ?? 0) + 1);
+            }
+            return assignments;
+        });
+    }
+    async readMessageById(sessionId, messageId) {
+        this.assertOpen();
+        assertSafeSessionId(sessionId);
+        assertSafeSessionId(messageId);
+        return this.readTransaction(() => this.readMessageByIdSync(sessionId, messageId));
+    }
     async markMessagesHandedOff(input) {
         this.assertOpen();
         assertSafeSessionId(input.sessionId);
@@ -1331,19 +1652,6 @@ export class SqliteSessionMetadataStore {
             provenSteeringMessages.set(normalized.messageId, normalized);
         }
         this.transaction(() => {
-            const lastSequenceRow = this.db
-                .prepare('SELECT COALESCE(MAX(sequence), -1) AS last_sequence FROM session_messages WHERE session_id = ?')
-                .get(input.sessionId);
-            if (typeof lastSequenceRow.last_sequence !== 'number' ||
-                !Number.isSafeInteger(lastSequenceRow.last_sequence) ||
-                lastSequenceRow.last_sequence < -1) {
-                throw new SessionMetadataConflictError('Invalid Session message sequence');
-            }
-            const lastSequence = lastSequenceRow.last_sequence;
-            const historicalMissingMessages = new Map();
-            const ordinaryMissingMessages = new Map();
-            const historicalMessageIdSet = new Set();
-            const existingSequences = new Map();
             for (const messageId of unique) {
                 const fallback = provenRootMessages.get(messageId);
                 const steeringProof = provenSteeringMessages.get(messageId);
@@ -1351,7 +1659,7 @@ export class SqliteSessionMetadataStore {
                     .prepare(`
             SELECT turn_id, run_id, message_id, content_json, submitted_content_digest,
               submitted_placement, placement, disposition, queue_order, admitted_at,
-            submitted_intent_json
+            submitted_intent_json, skill_invocation_json
             FROM message_admissions
             WHERE session_id = ? AND message_id = ?
           `)
@@ -1380,69 +1688,14 @@ export class SqliteSessionMetadataStore {
                     !messageContentsEqual(admission.content, fallback.content)) {
                     throw new SessionMetadataConflictError('Message admission fallback content conflict');
                 }
-                if (admission === undefined && fallback !== undefined) {
-                    historicalMessageIdSet.add(messageId);
-                }
                 if (!admission &&
                     this.db
                         .prepare('SELECT 1 AS present FROM cancelled_message_admissions WHERE session_id = ? AND message_id = ?')
                         .get(input.sessionId, messageId)) {
                     throw new SessionMetadataConflictError('Message admission is already cancelled');
                 }
-                const rows = this.db
-                    .prepare(`
-            SELECT message.sequence, message.record_json, payload.record_bytes, payload.sha256
-            FROM session_messages AS message
-            LEFT JOIN session_message_payloads AS payload
-              ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-            WHERE message.session_id = ? AND message.message_id = ?
-          `)
-                    .all(input.sessionId, messageId);
-                if (rows.length > 1) {
-                    throw new SessionMetadataConflictError('Message admission transcript identity is ambiguous');
-                }
-                if (rows.length === 0) {
-                    const source = admission ?? fallback;
-                    if (!source)
-                        throw new SessionMetadataConflictError('Message admission does not exist');
-                    const message = decodeCanonicalMessage({
-                        type: 'user',
-                        id: messageId,
-                        turnId: input.turnId,
-                        ts: steeringProof?.eventTs ?? source.admittedAt,
-                        ...source.content,
-                        steeringEventId: steeringProof?.eventId ?? messageId,
-                    });
-                    const json = JSON.stringify(message);
-                    (historicalMessageIdSet.has(messageId)
-                        ? historicalMissingMessages
-                        : ordinaryMissingMessages).set(messageId, { message, json });
-                }
-                else {
-                    const sequence = rows[0]?.sequence;
-                    if (typeof sequence !== 'number' || !Number.isSafeInteger(sequence)) {
-                        throw new SessionMetadataConflictError('Invalid Message transcript sequence');
-                    }
-                    const row = rows[0];
-                    const recordJson = readStoredMessageRecordJson(this.db, input.sessionId, sequence, row);
-                    const message = decodeStoredMessage(JSON.parse(recordJson));
-                    const expectedSource = admission ?? fallback ?? steeringProof;
-                    if (message.type !== 'user' ||
-                        message.id !== messageId ||
-                        (expectedSource !== undefined &&
-                            !messageContentsEqual(normalizeMessageContent(message), expectedSource.content))) {
-                        throw new SessionMetadataConflictError('Message admission transcript identity conflict');
-                    }
-                    if (message.turnId !== input.turnId) {
-                        throw new SessionMetadataConflictError('Message admission transcript Turn conflict');
-                    }
-                    if (steeringProof !== undefined &&
-                        (message.ts !== steeringProof.eventTs ||
-                            message.turnId !== steeringProof.executionTurnId ||
-                            message.steeringEventId !== steeringProof.eventId)) {
-                        throw new SessionMetadataConflictError('Proven steering transcript identity conflict');
-                    }
-                    existingSequences.set(messageId, sequence);
+                if (admission === undefined && fallback === undefined && steeringProof === undefined) {
+                    throw new SessionMetadataConflictError('Message admission does not exist');
                 }
                 if (admission) {
                     const deleted = this.db
@@ -1453,94 +1706,21 @@ export class SqliteSessionMetadataStore {
                     }
                 }
             }
-            let tailLatest;
-            if (historicalMessageIdSet.size > 0) {
-                const transcript = this.readSessionMessageOrderingSync(input.sessionId);
-                let previousExistingSequence = -1;
-                const historicalMessageIds = unique.filter((messageId) => historicalMessageIdSet.has(messageId));
-                for (const messageId of historicalMessageIds) {
-                    const sequence = existingSequences.get(messageId);
-                    if (sequence === undefined)
-                        continue;
-                    const admittedAt = provenRootMessages.get(messageId).admittedAt;
-                    const blockingRow = transcript.find(({ sequence: candidateSequence, message }) => candidateSequence > previousExistingSequence &&
-                        candidateSequence < sequence &&
-                        !historicalMessageIdSet.has(message.id) &&
-                        (message.turnId === input.turnId || message.ts >= admittedAt));
-                    if (sequence <= previousExistingSequence || blockingRow !== undefined) {
-                        throw new SessionMetadataConflictError('Message admission transcript source order conflict');
-                    }
-                    previousExistingSequence = sequence;
-                }
-                const insertionGroups = [];
-                let pending = [];
-                let previousAnchor = -1;
-                for (const messageId of historicalMessageIds) {
-                    const missing = historicalMissingMessages.get(messageId);
-                    if (missing) {
-                        pending.push(missing);
-                        continue;
-                    }
-                    const boundary = existingSequences.get(messageId);
-                    if (pending.length > 0 && boundary !== undefined) {
-                        const admittedAt = Math.min(...pending.map(({ message }) => message.ts));
-                        const earlierBoundary = transcript.find(({ sequence, message }) => sequence > previousAnchor &&
-                            sequence < boundary &&
-                            !historicalMessageIdSet.has(message.id) &&
-                            (message.turnId === input.turnId || message.ts >= admittedAt));
-                        if (earlierBoundary) {
-                            throw new SessionMetadataConflictError('Message admission transcript source order conflict');
-                        }
-                        insertionGroups.push({ boundary, entries: pending });
-                        pending = [];
-                    }
-                    if (boundary !== undefined)
-                        previousAnchor = boundary;
-                }
-                if (pending.length > 0) {
-                    const admittedAt = Math.min(...pending.map(({ message }) => message.ts));
-                    const repairBoundary = transcript.find(({ sequence, message }) => sequence > previousAnchor &&
-                        !historicalMessageIdSet.has(message.id) &&
-                        (message.turnId === input.turnId || message.ts >= admittedAt))?.sequence;
-                    insertionGroups.push({
-                        boundary: repairBoundary ?? lastSequence + 1,
-                        entries: pending,
-                    });
-                }
-                for (const group of insertionGroups.reverse()) {
-                    this.shiftSessionMessageSuffixSync(input.sessionId, group.boundary, group.entries.length);
-                    this.insertSessionMessagesSync(input.sessionId, group.boundary, group.entries);
-                    if (group.boundary === lastSequence + 1) {
-                        tailLatest = group.entries.at(-1)?.message;
-                    }
-                }
-            }
-            if (ordinaryMissingMessages.size > 0) {
-                const ordinaryEntries = unique.flatMap((messageId) => {
-                    const entry = ordinaryMissingMessages.get(messageId);
-                    return entry ? [entry] : [];
-                });
-                const currentLastSequenceRow = this.db
-                    .prepare('SELECT COALESCE(MAX(sequence), -1) AS last_sequence FROM session_messages WHERE session_id = ?')
-                    .get(input.sessionId);
-                const currentLastSequence = currentLastSequenceRow.last_sequence;
-                if (typeof currentLastSequence !== 'number' ||
-                    !Number.isSafeInteger(currentLastSequence) ||
-                    currentLastSequence < -1) {
-                    throw new SessionMetadataConflictError('Invalid Session message sequence');
-                }
-                this.insertSessionMessagesSync(input.sessionId, currentLastSequence + 1, ordinaryEntries);
-                tailLatest = ordinaryEntries.at(-1)?.message;
-            }
-            if (tailLatest?.type === 'user') {
-                this.updateCatalogProjectionSync(input.sessionId, {
-                    lastMessageAt: tailLatest.ts,
-                    lastMessagePreview: catalogPreviewForUserMessage(tailLatest),
-                }, false, true);
-            }
-            else if (historicalMissingMessages.size > 0 || ordinaryMissingMessages.size > 0) {
-                this.updateCatalogProjectionSync(input.sessionId, {}, false, true);
-            }
+        });
+    }
+    /**
+     * The catalog facts a durable message carries, committed without a transcript
+     * row to carry them: the Session list's preview line, its time, and the
+     * connection lock a Session takes on its first user message.
+     */
+    async commitMessageCatalogProjection(sessionId, message) {
+        this.assertOpen();
+        assertSafeSessionId(sessionId);
+        this.transaction(() => {
+            const record = this.readRecordSync(sessionId);
+            if (!record)
+                throw new SessionNotFoundError(sessionId);
+            this.updateCatalogProjectionSync(sessionId, projectSessionCatalogMessages([message]), false, message.type === 'user' && !record.header.connectionLocked);
         });
     }
     async updateMessageAdmission(admission) {
@@ -1551,7 +1731,7 @@ export class SqliteSessionMetadataStore {
                 .prepare(`
           SELECT turn_id, run_id, message_id, content_json, submitted_content_digest,
             submitted_placement, placement, disposition, queue_order, admitted_at,
-            submitted_intent_json
+            submitted_intent_json, skill_invocation_json
           FROM message_admissions
           WHERE session_id = ? AND message_id = ?
         `)
@@ -1568,10 +1748,11 @@ export class SqliteSessionMetadataStore {
             this.db
                 .prepare(`
           UPDATE message_admissions
-          SET content_json = ?, submitted_content_digest = ?, placement = ?, disposition = ?
+          SET content_json = ?, submitted_content_digest = ?, placement = ?, disposition = ?,
+            skill_invocation_json = ?
           WHERE session_id = ? AND message_id = ?
         `)
-                .run(JSON.stringify(stored.content), stored.submittedContentDigest, stored.placement, stored.disposition, stored.sessionId, stored.messageId);
+                .run(JSON.stringify(stored.content), stored.submittedContentDigest, stored.placement, stored.disposition, JSON.stringify(stored.skillInvocation), stored.sessionId, stored.messageId);
         });
     }
     async cancelMessageAdmissions(sessionId, messageIds) {
@@ -1619,7 +1800,7 @@ export class SqliteSessionMetadataStore {
             }
         });
     }
-    async reorderMessageAdmissions(sessionId, messageIds) {
+    async reorderMessageAdmissions(sessionId, messageIds, disposition = 'followup') {
         this.assertOpen();
         assertSafeSessionId(sessionId);
         const unique = [...new Set(messageIds)];
@@ -1633,13 +1814,13 @@ export class SqliteSessionMetadataStore {
                 .prepare(`
           SELECT message_id
           FROM message_admissions
-          WHERE session_id = ? AND disposition = 'followup'
+          WHERE session_id = ? AND disposition = ?
           ORDER BY queue_order, sequence
         `)
-                .all(sessionId);
+                .all(sessionId, disposition);
             const current = rows.map((row) => row.message_id);
             const currentIds = new Set(current);
-            if (current.length !== unique.length ||
+            if ((disposition === 'followup' && current.length !== unique.length) ||
                 unique.some((messageId) => !currentIds.has(messageId))) {
                 throw new SessionMetadataConflictError('Message admission reorder identity conflict');
             }
@@ -1648,118 +1829,109 @@ export class SqliteSessionMetadataStore {
         SET queue_order = ?
         WHERE session_id = ? AND message_id = ?
       `);
-            unique.forEach((messageId, index) => update.run(index, sessionId, messageId));
+            // Older steering may already be in flight. Keep those entries in their
+            // slots so recovery never interleaves them with a newly reordered batch.
+            const selected = new Set(unique);
+            let next = 0;
+            current.forEach((messageId, index) => {
+                const orderedId = selected.has(messageId) ? unique[next++] : messageId;
+                update.run(index, sessionId, orderedId);
+            });
         });
     }
+    async readCoordinationTranscriptIndexState() {
+        this.assertOpen();
+        return this.db
+            .prepare(`SELECT (SELECT MAX(sequence) FROM coordination_transcript_index) AS highWater,
+      (SELECT MAX(source_sequence) FROM coordination_transcript_index WHERE source = 'legacy') AS legacy,
+      (SELECT MAX(source_sequence) FROM coordination_transcript_index WHERE source = 'runtime') AS runtime`)
+            .get();
+    }
+    async appendCoordinationTranscriptIndex(records) {
+        this.assertOpen();
+        if (records.length > 64)
+            throw new Error('Coordination transcript index batch exceeds limit');
+        this.transaction(() => {
+            let sequence = this.db
+                .prepare('SELECT MAX(sequence) AS value FROM coordination_transcript_index')
+                .get().value ?? -1;
+            const insert = this.db.prepare(`INSERT INTO coordination_transcript_index
+        (sequence, source, source_sequence) VALUES (?, ?, ?)
+        ON CONFLICT(source, source_sequence) DO NOTHING`);
+            for (const record of records) {
+                if (!Number.isSafeInteger(record.sourceSequence) || record.sourceSequence < 0)
+                    throw new Error('Invalid Coordination source sequence');
+                const result = insert.run(sequence + 1, record.source, record.sourceSequence);
+                if (result.changes)
+                    sequence++;
+            }
+        });
+    }
+    async readCoordinationTranscriptIndex(request) {
+        this.assertOpen();
+        if (!Number.isSafeInteger(request.limit) || request.limit < 1 || request.limit > 64)
+            throw new Error('Invalid Coordination transcript index limit');
+        const older = request.direction === 'older';
+        return this.db
+            .prepare(`SELECT sequence, source, source_sequence AS sourceSequence
+      FROM coordination_transcript_index WHERE sequence <= ? AND sequence ${older ? '<=' : '>='} ?
+      ORDER BY sequence ${older ? 'DESC' : 'ASC'} LIMIT ?`)
+            .all(request.throughSequence, request.position, request.limit);
+    }
     async readMessages(sessionId) {
         return this.readMessagesWith(sessionId, decodeStoredMessage);
     }
-    async readTranscriptPage(sessionId, request) {
+    async readMessagesAfter(sessionId, request) {
         this.assertOpen();
         assertSafeSessionId(sessionId);
-        assertTranscriptPageRequest(request);
+        if (!Number.isSafeInteger(request.maxMessages) || request.maxMessages < 1) {
+            throw new Error('Invalid Session message count limit');
+        }
+        if (!Number.isSafeInteger(request.maxStoredBytes) || request.maxStoredBytes < 1) {
+            throw new Error('Invalid Session message byte limit');
+        }
+        if (request.afterSequence !== undefined && request.beforeSequence !== undefined) {
+            throw new Error('Invalid Session message scan bounds');
+        }
+        const backward = request.beforeSequence !== undefined;
         return this.readTransaction(() => {
             if (!this.readRecordSync(sessionId))
                 throw new SessionNotFoundError(sessionId);
-            const highWaterRow = this.db
-                .prepare('SELECT MAX(sequence) AS high_water FROM session_messages WHERE session_id = ?')
-                .get(sessionId);
-            const actualHighWater = nullableStoredMessageSequence(highWaterRow.high_water, sessionId);
-            const throughSequence = request.throughSequence === undefined ? actualHighWater : request.throughSequence;
-            if (throughSequence === null) {
-                return {
-                    throughSequence: null,
-                    fragments: [],
-                    rawBytes: 0,
-                    next: null,
-                };
-            }
-            if (actualHighWater === null || throughSequence > actualHighWater) {
-                throw new Error(`Session transcript watermark is ahead of durable storage: ${sessionId}`);
-            }
-            const position = request.position ?? (request.direction === 'older' ? throughSequence : 0);
-            const comparison = request.direction === 'older' ? '<=' : '>=';
-            const order = request.direction === 'older' ? 'DESC' : 'ASC';
             const rows = this.db
                 .prepare(`
-          SELECT message.sequence,
-            coalesce(payload.record_bytes, length(CAST(message.record_json AS BLOB))) AS total_bytes,
-            payload.record_bytes IS NOT NULL AS chunked,
-            payload.sha256 AS payload_sha256
+          SELECT message.sequence, message.record_json, payload.record_bytes, payload.sha256
           FROM session_messages AS message
           LEFT JOIN session_message_payloads AS payload
             ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-          WHERE message.session_id = ?
-            AND message.sequence <= ?
-            AND message.sequence ${comparison} ?
-          ORDER BY message.sequence ${order}
+          WHERE message.session_id = ? AND message.sequence ${backward ? '<' : '>'} ?
+          ORDER BY message.sequence ${backward ? 'DESC' : 'ASC'}
           LIMIT ?
         `)
-                .all(sessionId, throughSequence, position, request.maxMessages + 1);
-            const slices = [];
-            let rawBytes = 0;
-            let next = null;
+                .all(sessionId, backward ? request.beforeSequence : (request.afterSequence ?? -1), request.maxMessages);
+            const records = [];
+            let storedBytes = 0;
             for (const row of rows) {
-                if (slices.length >= request.maxMessages || rawBytes >= request.maxBytes)
-                    break;
                 const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-                const totalBytes = requireTranscriptRecordByteLength(row.total_bytes, sessionId, sequence);
-                const chunked = row.chunked === 1;
-                const payloadDigest = chunked
-                    ? requireTranscriptPayloadDigest(row.payload_sha256, sessionId, sequence)
-                    : null;
-                const continued = sequence === position && request.byteOffset !== undefined;
-                const edge = continued
-                    ? request.byteOffset
-                    : request.direction === 'older'
-                        ? totalBytes
-                        : 0;
-                if ((request.direction === 'older' && (edge < 1 || edge > totalBytes)) ||
-                    (request.direction === 'newer' && (edge < 0 || edge >= totalBytes))) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-                }
-                const available = request.maxBytes - rawBytes;
-                const byteOffset = request.direction === 'older' ? Math.max(0, edge - available) : edge;
-                const byteLength = request.direction === 'older'
-                    ? edge - byteOffset
-                    : Math.min(totalBytes - edge, available);
-                const complete = request.direction === 'older' ? byteOffset === 0 : byteOffset + byteLength === totalBytes;
-                slices.push({
+                // A record too large for one row is stored in chunks, with only a
+                // marker inline; its size is the chunk total, not the marker's.
+                const recordBytes = typeof row.record_bytes === 'number' ? row.record_bytes : String(row.record_json).length;
+                // The first record of a page is always taken, so a single row larger
+                // than the budget still makes progress instead of stalling the scan.
+                if (records.length > 0 && storedBytes + recordBytes > request.maxStoredBytes)
+                    break;
+                storedBytes += recordBytes;
+                records.push({
                     sequence,
-                    byteOffset,
-                    totalBytes,
-                    byteLength,
-                    chunked,
-                    payloadDigest,
+                    message: decodeStoredMessageRecordRow(this.db, sessionId, row),
                 });
-                rawBytes += byteLength;
-                if (!complete) {
-                    next = {
-                        position: sequence,
-                        byteOffset: request.direction === 'older' ? byteOffset : byteOffset + byteLength,
-                    };
-                    break;
-                }
             }
-            if (next === null && slices.length > 0 && slices.length < rows.length) {
-                const sequence = slices.at(-1).sequence;
-                next = {
-                    position: sequence + (request.direction === 'older' ? -1 : 1),
-                    byteOffset: null,
-                };
-            }
-            const dataBySequence = readTranscriptSlices(this.db, sessionId, slices);
-            const fragments = slices.map(({ sequence, byteOffset, totalBytes, byteLength, payloadDigest }) => {
-                const data = dataBySequence.get(sequence);
-                if (!data || data.byteLength !== byteLength) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-                }
-                if (byteOffset === 0 && byteLength === totalBytes) {
-                    validateTranscriptRecord(data, sessionId, sequence);
-                }
-                return { sequence, byteOffset, totalBytes, payloadDigest, data };
-            });
-            return { throughSequence, fragments, rawBytes, next };
+            const highWater = this.db
+                .prepare('SELECT MAX(sequence) AS high_water FROM session_messages WHERE session_id = ?')
+                .get(sessionId);
+            return {
+                records,
+                highWaterSequence: nullableStoredMessageSequence(highWater.high_water, sessionId),
+            };
         });
     }
     async readTranscriptMessages(sessionId, request) {
@@ -1846,80 +2018,6 @@ export class SqliteSessionMetadataStore {
             return messages;
         });
     }
-    async readTranscriptRecords(sessionId, request) {
-        this.assertOpen();
-        assertSafeSessionId(sessionId);
-        assertTranscriptRecordScanRequest(request);
-        return this.readTransaction(() => {
-            if (!this.readRecordSync(sessionId))
-                throw new SessionNotFoundError(sessionId);
-            const highWaterRow = this.db
-                .prepare('SELECT MAX(sequence) AS high_water FROM session_messages WHERE session_id = ?')
-                .get(sessionId);
-            const actualHighWater = nullableStoredMessageSequence(highWaterRow.high_water, sessionId);
-            const throughSequence = request.throughSequence === undefined ? actualHighWater : request.throughSequence;
-            if (throughSequence === null) {
-                return { throughSequence: null, records: [], nextPosition: null };
-            }
-            if (actualHighWater === null || throughSequence > actualHighWater) {
-                throw new Error(`Session transcript watermark is ahead of durable storage: ${sessionId}`);
-            }
-            const position = request.position ?? (request.direction === 'older' ? throughSequence : 0);
-            const comparison = request.direction === 'older' ? '<=' : '>=';
-            const order = request.direction === 'older' ? 'DESC' : 'ASC';
-            const rows = this.db
-                .prepare(`
-          SELECT message.sequence,
-            coalesce(payload.record_bytes, length(CAST(message.record_json AS BLOB))) AS stored_bytes
-          FROM session_messages AS message
-          LEFT JOIN session_message_payloads AS payload
-            ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-          WHERE message.session_id = ?
-            AND message.sequence <= ?
-            AND message.sequence ${comparison} ?
-          ORDER BY message.sequence ${order}
-          LIMIT ?
-        `)
-                .all(sessionId, throughSequence, position, request.maxMessages + 1);
-            const selected = [];
-            let storedBytes = 0;
-            for (const row of rows) {
-                if (selected.length >= request.maxMessages)
-                    break;
-                const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-                const bytes = requireTranscriptRecordByteLength(row.stored_bytes, sessionId, sequence);
-                if (selected.length > 0 && storedBytes + bytes > request.maxStoredBytes)
-                    break;
-                selected.push(sequence);
-                storedBytes += bytes;
-            }
-            const decoded = new Map();
-            for (const row of readStoredMessageRows(this.db, sessionId, selected)) {
-                try {
-                    decoded.set(row.sequence, decodeStoredMessage(JSON.parse(row.recordJson)));
-                }
-                catch (error) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, row.sequence, {
-                        cause: error,
-                    });
-                }
-            }
-            const records = selected.map((sequence) => {
-                const message = decoded.get(sequence);
-                if (!message)
-                    throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-                return { sequence, message };
-            });
-            const last = selected.at(-1);
-            return {
-                throughSequence,
-                records,
-                nextPosition: last !== undefined && rows.length > selected.length
-                    ? last + (request.direction === 'older' ? -1 : 1)
-                    : null,
-            };
-        });
-    }
     async readTranscriptHighWater(sessionId) {
         this.assertOpen();
         assertSafeSessionId(sessionId);
@@ -1930,295 +2028,6 @@ export class SqliteSessionMetadataStore {
             .get(sessionId);
         return nullableStoredMessageSequence(row.high_water, sessionId);
     }
-    async readTurnContributions(sessionId, throughSequence, position, maxContributions) {
-        this.assertOpen();
-        assertSafeSessionId(sessionId);
-        if ((throughSequence !== null &&
-            (!Number.isSafeInteger(throughSequence) || throughSequence < 0)) ||
-            !Number.isSafeInteger(position) ||
-            position < 0 ||
-            !Number.isSafeInteger(maxContributions) ||
-            maxContributions < 1 ||
-            maxContributions > 128) {
-            throw new Error('Invalid Session turn contribution request');
-        }
-        return this.readTransaction(() => {
-            if (!this.readRecordSync(sessionId))
-                throw new SessionNotFoundError(sessionId);
-            const highWaterRow = this.db
-                .prepare('SELECT MAX(sequence) AS high_water FROM session_messages WHERE session_id = ?')
-                .get(sessionId);
-            const actualHighWater = nullableStoredMessageSequence(highWaterRow.high_water, sessionId);
-            const fixedThrough = throughSequence ?? actualHighWater;
-            if (fixedThrough === null) {
-                return { throughSequence: null, contributions: [], nextPosition: null };
-            }
-            if (actualHighWater === null || fixedThrough > actualHighWater) {
-                throw new Error(`Session turn watermark is ahead of durable storage: ${sessionId}`);
-            }
-            const contributions = new Map();
-            let nextPosition = position;
-            let sourceMessages = 0;
-            let sourceBytes = 0;
-            while (nextPosition <= fixedThrough) {
-                const rows = this.db
-                    .prepare(`
-            SELECT message.sequence, message.record_json, payload.record_bytes, payload.sha256
-            FROM session_messages AS message
-            LEFT JOIN session_message_payloads AS payload
-              ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-            WHERE message.session_id = ?
-              AND message.sequence >= ?
-              AND message.sequence <= ?
-            ORDER BY message.sequence ASC
-            LIMIT 128
-          `)
-                    .all(sessionId, nextPosition, fixedThrough);
-                if (rows.length === 0) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, nextPosition);
-                }
-                for (const row of rows) {
-                    const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-                    const recordBytes = storedMessageRecordBytes(row, sessionId, sequence);
-                    if (sourceMessages > 0 &&
-                        (sourceMessages >= SQLITE_TURN_CONTRIBUTION_MAX_SOURCE_MESSAGES ||
-                            sourceBytes + recordBytes > SQLITE_TURN_CONTRIBUTION_MAX_SOURCE_BYTES)) {
-                        return {
-                            throughSequence: fixedThrough,
-                            contributions: [...contributions.values()],
-                            nextPosition: sequence,
-                        };
-                    }
-                    const message = decodeStoredMessageRecordRow(this.db, sessionId, row);
-                    sourceMessages += 1;
-                    sourceBytes += recordBytes;
-                    if (!('turnId' in message) || typeof message.turnId !== 'string') {
-                        nextPosition = sequence + 1;
-                        continue;
-                    }
-                    const turnId = message.turnId;
-                    if (turnId && !contributions.has(turnId) && contributions.size >= maxContributions) {
-                        nextPosition = sequence;
-                        return {
-                            throughSequence: fixedThrough,
-                            contributions: [...contributions.values()],
-                            nextPosition,
-                        };
-                    }
-                    contributions.set(turnId, foldTurnContribution(contributions.get(turnId), turnId, sequence, message));
-                    nextPosition = sequence + 1;
-                }
-            }
-            return {
-                throughSequence: fixedThrough,
-                contributions: [...contributions.values()],
-                nextPosition: null,
-            };
-        });
-    }
-    async readTurnLandmarks(sessionId, maxLandmarks) {
-        this.assertOpen();
-        assertSafeSessionId(sessionId);
-        if (!Number.isSafeInteger(maxLandmarks) || maxLandmarks < 1 || maxLandmarks > 64) {
-            throw new Error('Invalid Session turn landmark limit');
-        }
-        return this.readTransaction(() => {
-            if (!this.readRecordSync(sessionId))
-                throw new SessionNotFoundError(sessionId);
-            const throughRow = this.db
-                .prepare(`
-          SELECT sequence AS through_sequence
-          FROM session_messages
-          WHERE session_id = ?
-          ORDER BY sequence DESC
-          LIMIT 1
-        `)
-                .get(sessionId);
-            const throughSequence = nullableStoredMessageSequence(throughRow?.through_sequence, sessionId);
-            if (throughSequence === null) {
-                return { throughSequence: null, landmarks: [] };
-            }
-            const promptRows = this.db
-                .prepare(`
-          SELECT admission.admitted_at, message.sequence
-          FROM core_root_turn_admissions AS admission
-          JOIN session_messages AS message
-            ON message.session_id = admission.session_id
-            AND message.message_id = json_extract(admission.record_json, '$.userMessageId')
-          LEFT JOIN session_message_payloads AS payload
-            ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-          WHERE admission.session_id = ? AND payload.sequence IS NULL
-          ORDER BY admission.admitted_at ASC, admission.turn_id ASC
-          LIMIT ?
-        `)
-                .all(sessionId, maxLandmarks + 1);
-            const selected = new Set();
-            if (promptRows.length <= maxLandmarks) {
-                for (const row of promptRows) {
-                    selected.add(requireStoredMessageSequence(row.sequence, sessionId));
-                }
-            }
-            const forward = this.db.prepare(`
-        SELECT admission.admitted_at, message.sequence
-        FROM core_root_turn_admissions AS admission
-        JOIN session_messages AS message
-          ON message.session_id = admission.session_id
-          AND message.message_id = json_extract(admission.record_json, '$.userMessageId')
-        LEFT JOIN session_message_payloads AS payload
-          ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-        WHERE admission.session_id = ? AND admission.admitted_at >= ? AND payload.sequence IS NULL
-        ORDER BY admission.admitted_at ASC, admission.turn_id ASC
-        LIMIT 1
-      `);
-            const backward = this.db.prepare(`
-        SELECT admission.admitted_at, message.sequence
-        FROM core_root_turn_admissions AS admission
-        JOIN session_messages AS message
-          ON message.session_id = admission.session_id
-          AND message.message_id = json_extract(admission.record_json, '$.userMessageId')
-        LEFT JOIN session_message_payloads AS payload
-          ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-        WHERE admission.session_id = ? AND admission.admitted_at < ? AND payload.sequence IS NULL
-        ORDER BY admission.admitted_at DESC, admission.turn_id DESC
-        LIMIT 1
-      `);
-            if (promptRows.length > maxLandmarks) {
-                const firstAdmittedAt = requireTurnLandmarkAdmittedAt(promptRows[0]?.admitted_at);
-                const lastRow = this.db
-                    .prepare(`
-            SELECT admitted_at
-            FROM core_root_turn_admissions
-            WHERE session_id = ?
-            ORDER BY admitted_at DESC, turn_id DESC
-            LIMIT 1
-          `)
-                    .get(sessionId);
-                const lastAdmittedAt = requireTurnLandmarkAdmittedAt(lastRow?.admitted_at);
-                for (let index = 0; index < maxLandmarks; index += 1) {
-                    const target = maxLandmarks === 1
-                        ? lastAdmittedAt
-                        : firstAdmittedAt +
-                            Math.floor(((lastAdmittedAt - firstAdmittedAt) * index) / (maxLandmarks - 1));
-                    const candidates = [
-                        ...forward.all(sessionId, target),
-                        ...backward.all(sessionId, target),
-                    ];
-                    let nearest;
-                    for (const candidate of candidates) {
-                        const admittedAt = requireTurnLandmarkAdmittedAt(candidate.admitted_at);
-                        if (nearest === undefined ||
-                            Math.abs(admittedAt - target) <
-                                Math.abs(requireTurnLandmarkAdmittedAt(nearest.admitted_at) - target)) {
-                            nearest = candidate;
-                        }
-                    }
-                    if (nearest)
-                        selected.add(requireStoredMessageSequence(nearest.sequence, sessionId));
-                }
-            }
-            const firstIndexedSequence = promptRows.length > 0
-                ? requireStoredMessageSequence(promptRows[0]?.sequence, sessionId)
-                : null;
-            const legacyThrough = firstIndexedSequence === null ? throughSequence : firstIndexedSequence - 1;
-            if (legacyThrough >= 0) {
-                const firstRow = this.db
-                    .prepare(`
-            SELECT sequence AS first_sequence
-            FROM session_messages
-            WHERE session_id = ?
-            ORDER BY sequence ASC
-            LIMIT 1
-          `)
-                    .get(sessionId);
-                const firstSequence = nullableStoredMessageSequence(firstRow?.first_sequence, sessionId);
-                if (firstSequence === null || firstSequence > legacyThrough) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, legacyThrough);
-                }
-                const forwardLegacy = this.db.prepare(`
-          SELECT message.sequence, message.message_type, payload.sequence AS payload_sequence
-          FROM session_messages AS message
-          LEFT JOIN session_message_payloads AS payload
-            ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-          WHERE message.session_id = ? AND message.sequence >= ? AND message.sequence <= ?
-          ORDER BY message.sequence ASC
-          LIMIT ${SQLITE_TURN_LANDMARK_LEGACY_NEIGHBOR_MESSAGES}
-        `);
-                const backwardLegacy = this.db.prepare(`
-          SELECT message.sequence, message.message_type, payload.sequence AS payload_sequence
-          FROM session_messages AS message
-          LEFT JOIN session_message_payloads AS payload
-            ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-          WHERE message.session_id = ? AND message.sequence < ? AND message.sequence >= ?
-          ORDER BY message.sequence DESC
-          LIMIT ${SQLITE_TURN_LANDMARK_LEGACY_NEIGHBOR_MESSAGES}
-        `);
-                const targetCount = Math.min(maxLandmarks, legacyThrough - firstSequence + 1);
-                for (let index = 0; index < targetCount; index += 1) {
-                    const target = targetCount === 1
-                        ? legacyThrough
-                        : firstSequence +
-                            Math.floor(((legacyThrough - firstSequence) * index) / (targetCount - 1));
-                    const candidates = [
-                        ...forwardLegacy.all(sessionId, target, legacyThrough),
-                        ...backwardLegacy.all(sessionId, target, firstSequence),
-                    ];
-                    let nearest;
-                    for (const candidate of candidates) {
-                        const sequence = requireStoredMessageSequence(candidate.sequence, sessionId);
-                        if (candidate.message_type !== 'user' || candidate.payload_sequence !== null)
-                            continue;
-                        if (nearest === undefined || Math.abs(sequence - target) < Math.abs(nearest - target)) {
-                            nearest = sequence;
-                        }
-                    }
-                    if (nearest !== undefined)
-                        selected.add(nearest);
-                }
-            }
-            const selectedSequences = [...selected].sort((left, right) => left - right);
-            const sampledSequences = selectedSequences.length <= maxLandmarks
-                ? selectedSequences
-                : Array.from({ length: maxLandmarks }, (_, index) => selectedSequences[maxLandmarks === 1
-                    ? selectedSequences.length - 1
-                    : Math.floor(((selectedSequences.length - 1) * index) / (maxLandmarks - 1))]);
-            const landmarks = readStoredMessageRows(this.db, sessionId, sampledSequences).flatMap(({ sequence, recordJson }) => {
-                let message;
-                try {
-                    message = decodeStoredMessage(JSON.parse(recordJson));
-                }
-                catch (error) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, sequence, { cause: error });
-                }
-                if (message.type !== 'user') {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-                }
-                const label = (message.displayText ?? message.text).trim();
-                return label ? [{ turnId: message.turnId, sequence, label }] : [];
-            });
-            return { throughSequence, landmarks };
-        });
-    }
-    async readMessagesForRecovery(sessionId) {
-        return this.readMessagesWith(sessionId, decodeStoredMessage);
-    }
-    async readPreviewMessages(sessionId, limit = 10) {
-        this.assertOpen();
-        assertSafeSessionId(sessionId);
-        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 128) {
-            throw new Error('Session message preview limit must be between 1 and 128');
-        }
-        if (!this.readRecordSync(sessionId))
-            throw new SessionNotFoundError(sessionId);
-        const sequences = this.db
-            .prepare(`
-          SELECT sequence FROM session_messages
-          WHERE session_id = ? ORDER BY sequence DESC LIMIT ?
-        `)
-            .all(sessionId, limit)
-            .map((row) => requireStoredMessageSequence(row.sequence, sessionId))
-            .reverse();
-        return readStoredMessageRows(this.db, sessionId, sequences, sequences.map(() => '?').join(', ')).map((row) => decodeStoredMessageRow({ sequence: row.sequence, record_json: row.recordJson }, sessionId));
-    }
     async beginCatalogProjectionWrite() {
         this.assertOpen();
         this.transaction(() => {
@@ -3522,7 +3331,7 @@ export class SqliteSessionMetadataStore {
             if (boundary.kind !== 'managed') {
                 throw new SessionMetadataConflictError(`Managed sandbox boundary history is invalid: ${sessionId}`);
             }
-            if (!isCanonicalReadOnlySandboxProfile(boundary.profile))
+            if (!isCanonicalReadOnlyPermissionProfile(boundary.profile))
                 return boundary.profile;
         }
         return requireManagedProfile(createGenesisExecutionBoundary('ask'));
@@ -3668,7 +3477,7 @@ export class SqliteSessionMetadataStore {
         const nextManagedProfile = kind === 'managed'
             ? projectedMode === 'explore'
                 ? requireManagedProfile(createGenesisExecutionBoundary('explore'))
-                : current.kind === 'managed' && !isCanonicalReadOnlySandboxProfile(current.profile)
+                : current.kind === 'managed' && !isCanonicalReadOnlyPermissionProfile(current.profile)
                     ? current.profile
                     : this.readLatestAutoSandboxProfileSync(sessionId)
             : undefined;
@@ -3739,64 +3548,6 @@ export class SqliteSessionMetadataStore {
             .get(sessionId, messageId);
         return row ? decodeStoredMessageRecordRow(this.db, sessionId, row) : undefined;
     }
-    readSessionMessageOrderingSync(sessionId) {
-        const rows = this.db
-            .prepare(`
-        SELECT message.sequence, message.record_json, payload.record_bytes, payload.sha256
-        FROM session_messages AS message
-        LEFT JOIN session_message_payloads AS payload
-          ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-        WHERE message.session_id = ?
-        ORDER BY message.sequence
-      `)
-            .all(sessionId);
-        return rows.map((row) => {
-            const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-            const recordJson = readStoredMessageRecordJson(this.db, sessionId, sequence, row);
-            return {
-                sequence,
-                message: decodeStoredMessage(JSON.parse(recordJson)),
-            };
-        });
-    }
-    shiftSessionMessageSuffixSync(sessionId, firstSequence, amount) {
-        if (!Number.isSafeInteger(firstSequence) || firstSequence < 0) {
-            throw new SessionMetadataConflictError('Invalid transcript insertion sequence');
-        }
-        if (!Number.isSafeInteger(amount) || amount < 1) {
-            throw new SessionMetadataConflictError('Invalid transcript insertion size');
-        }
-        const sequences = this.db
-            .prepare(`
-          SELECT sequence
-          FROM session_messages
-          WHERE session_id = ? AND sequence >= ?
-          ORDER BY sequence DESC
-        `)
-            .all(sessionId, firstSequence).map((row) => requireStoredMessageSequence(row.sequence, sessionId));
-        const highest = sequences[0];
-        if (highest !== undefined && highest > Number.MAX_SAFE_INTEGER - amount) {
-            throw new SessionMetadataConflictError('Session message sequence overflow');
-        }
-        if (sequences.length === 0)
-            return;
-        this.db.exec('PRAGMA defer_foreign_keys = ON');
-        const moveChunks = this.db.prepare('UPDATE session_message_chunks SET sequence = ? WHERE session_id = ? AND sequence = ?');
-        const movePayload = this.db.prepare('UPDATE session_message_payloads SET sequence = ? WHERE session_id = ? AND sequence = ?');
-        const moveMessage = this.db.prepare('UPDATE session_messages SET sequence = ? WHERE session_id = ? AND sequence = ?');
-        for (const sequence of sequences) {
-            const shifted = sequence + amount;
-            moveChunks.run(shifted, sessionId, sequence);
-            const payload = movePayload.run(shifted, sessionId, sequence);
-            if (payload.changes !== 0 && payload.changes !== 1) {
-                throw new SessionMetadataConflictError('Message payload sequence is ambiguous');
-            }
-            const message = moveMessage.run(shifted, sessionId, sequence);
-            if (message.changes !== 1) {
-                throw new SessionMetadataConflictError('Message transcript sequence changed during repair');
-            }
-        }
-    }
     insertSessionMessagesSync(sessionId, firstSequence, entries) {
         if (!Number.isSafeInteger(firstSequence) ||
             firstSequence < 0 ||
@@ -3897,12 +3648,19 @@ export class SqliteSessionMetadataStore {
         if (!current)
             throw new SessionNotFoundError(sessionId);
         const lastMessageAt = maxTimestamp(current.header.lastMessageAt, projection.lastMessageAt);
+        // The preview refuses to move backwards for the same reason the timestamp
+        // does: a message older than the one on show is a repair of something the
+        // catalog already passed, and recovery replays exactly those.
+        const stale = !replacePreview &&
+            projection.lastMessageAt !== undefined &&
+            current.header.lastMessageAt !== undefined &&
+            projection.lastMessageAt < current.header.lastMessageAt;
         this.updateHeaderSync(sessionId, {
             ...(lockConnection ? { connectionLocked: true } : {}),
             ...(lastMessageAt === undefined ? {} : { lastMessageAt }),
         }, {
             skipNoop: true,
-            ...(replacePreview || projection.lastMessagePreview !== undefined
+            ...(!stale && (replacePreview || projection.lastMessagePreview !== undefined)
                 ? {
                     catalogPreview: {
                         kind: 'replace',
@@ -4650,11 +4408,6 @@ function requireManagedProfile(boundary) {
         throw new Error('Expected a managed execution boundary');
     return boundary.profile;
 }
-function isCanonicalReadOnlySandboxProfile(profile) {
-    const { name: _profileName, ...profilePolicy } = profile;
-    const { name: _canonicalName, ...canonicalPolicy } = requireManagedProfile(createGenesisExecutionBoundary('explore'));
-    return isDeepStrictEqual(profilePolicy, canonicalPolicy);
-}
 function assertGraphLookupIdentity(value, name) {
     if (typeof value !== 'string' ||
         value.length === 0 ||
@@ -4822,22 +4575,6 @@ function decodeStoredMessageRow(row, sessionId) {
         });
     }
 }
-function requireTurnLandmarkAdmittedAt(value) {
-    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
-        throw new Error('Invalid root Turn admission timestamp');
-    }
-    return value;
-}
-function storedMessageRecordBytes(row, sessionId, sequence) {
-    if (row.record_bytes !== null) {
-        return requireTranscriptRecordByteLength(row.record_bytes, sessionId, sequence);
-    }
-    if (typeof row.record_json !== 'string' ||
-        row.record_json === SQLITE_SESSION_MESSAGE_CHUNK_MARKER) {
-        throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-    }
-    return Buffer.byteLength(row.record_json, 'utf8');
-}
 function decodeStoredMessageRecordRow(db, sessionId, row) {
     const sequence = requireStoredMessageSequence(row.sequence, sessionId);
     return decodeStoredMessageRow({
@@ -4869,6 +4606,29 @@ function readStoredMessageRecordJson(db, sessionId, sequence, row) {
     }
     return recordJson;
 }
+function isWorkHubActionOperation(value) {
+    return (value === 'answer_here' ||
+        value === 'clarify' ||
+        value === 'delegate_existing' ||
+        value === 'create_new' ||
+        value === 'replace' ||
+        value === 'stop');
+}
+function workHubAssignmentAttachmentsMatchTarget(assignment) {
+    const source = assignment.attachments ?? [];
+    const target = assignment.targetAttachments ?? [];
+    return (source.length === target.length &&
+        source.every((attachment, index) => {
+            const copied = target[index];
+            const { ref: sourceRef, ...sourceMetadata } = attachment;
+            const { ref: targetRef, ...targetMetadata } = copied;
+            return (sourceRef.kind === 'session_file' &&
+                sourceRef.sessionId === WORKHUB_COORDINATION_SESSION_ID &&
+                targetRef.kind === 'session_file' &&
+                targetRef.sessionId === assignment.targetSessionId &&
+                isDeepStrictEqual(sourceMetadata, targetMetadata));
+        }));
+}
 function sameWorkHubAssignmentRequest(existing, requested) {
     return isDeepStrictEqual({
         actionId: existing.actionId,
@@ -4877,7 +4637,11 @@ function sameWorkHubAssignmentRequest(existing, requested) {
         targetSessionId: existing.targetSessionId,
         disposition: existing.disposition,
         userText: existing.userText,
+        delegationText: existing.delegationText,
+        attachments: existing.attachments,
         create: existing.create,
+        replacesActionId: existing.replacesActionId,
+        replacesDelegationId: existing.replacesDelegationId,
     }, {
         actionId: requested.actionId,
         actionFingerprint: requested.actionFingerprint,
@@ -4885,34 +4649,13 @@ function sameWorkHubAssignmentRequest(existing, requested) {
         targetSessionId: requested.targetSessionId,
         disposition: requested.disposition,
         userText: requested.userText,
+        delegationText: requested.delegationText,
+        attachments: requested.attachments,
         create: requested.create,
+        replacesActionId: requested.replacesActionId,
+        replacesDelegationId: requested.replacesDelegationId,
     });
 }
-function foldTurnContribution(current, turnId, sequence, message) {
-    const contribution = current ?? {
-        turnId,
-        firstSequence: sequence,
-        latestState: null,
-        userPromptPreview: null,
-        hasAssistantMessage: false,
-        hasAssistantOutput: false,
-        hasToolResult: false,
-        hasFailedToolResult: false,
-        hasAbortNote: false,
-    };
-    const userPrompt = message.type === 'user' ? (message.displayText ?? message.text).trim() : '';
-    return {
-        ...contribution,
-        latestState: message.type === 'turn_state' ? { sequence, message } : contribution.latestState,
-        userPromptPreview: contribution.userPromptPreview ?? (userPrompt || null),
-        hasAssistantMessage: contribution.hasAssistantMessage || message.type === 'assistant',
-        hasAssistantOutput: contribution.hasAssistantOutput ||
-            (message.type === 'assistant' && message.text.trim().length > 0),
-        hasToolResult: contribution.hasToolResult || message.type === 'tool_result',
-        hasFailedToolResult: contribution.hasFailedToolResult || (message.type === 'tool_result' && message.isError),
-        hasAbortNote: contribution.hasAbortNote || (message.type === 'system_note' && message.kind === 'abort'),
-    };
-}
 function readStoredMessageRows(db, sessionId, sequences, placeholders = sequences.map(() => '?').join(', ')) {
     if (sequences.length === 0)
         return [];
@@ -4979,173 +4722,9 @@ function nullableStoredMessageSequence(value, sessionId) {
         return null;
     return requireStoredMessageSequence(value, sessionId);
 }
-function requireTranscriptPayloadDigest(value, sessionId, sequence) {
-    if (typeof value !== 'string' || !/^[0-9a-f]{64}$/.test(value)) {
-        throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-    }
-    return `sha256:${value}`;
-}
 function requireTranscriptRecordByteLength(value, sessionId, sequence) {
     if (!Number.isSafeInteger(value) || value < 1) {
         throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
     }
     return value;
 }
-function readTranscriptSlices(db, sessionId, slices) {
-    if (slices.length === 0)
-        return new Map();
-    const chunkedSlices = slices.filter((slice) => slice.chunked);
-    const values = chunkedSlices.map(() => '(?, ?, ?)').join(', ');
-    const parameters = chunkedSlices.flatMap((slice) => [
-        slice.sequence,
-        Math.floor(slice.byteOffset / SQLITE_SESSION_MESSAGE_CHUNK_BYTES),
-        Math.floor((slice.byteOffset + slice.byteLength - 1) / SQLITE_SESSION_MESSAGE_CHUNK_BYTES),
-    ]);
-    const rows = chunkedSlices.length === 0
-        ? []
-        : db
-            .prepare(`
-        WITH requested(sequence, first_chunk, last_chunk) AS (VALUES ${values})
-        SELECT requested.sequence, chunk.chunk_index, chunk.data, chunk.sha256
-        FROM requested
-        INNER JOIN session_message_chunks AS chunk
-          ON chunk.session_id = ?
-          AND chunk.sequence = requested.sequence
-          AND chunk.chunk_index BETWEEN requested.first_chunk AND requested.last_chunk
-        ORDER BY requested.sequence, chunk.chunk_index
-      `)
-            .all(...parameters, sessionId);
-    const rowsBySequence = new Map();
-    for (const row of rows) {
-        const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-        const grouped = rowsBySequence.get(sequence);
-        if (grouped)
-            grouped.push(row);
-        else
-            rowsBySequence.set(sequence, [row]);
-    }
-    const result = new Map();
-    for (const slice of slices) {
-        if (!slice.chunked)
-            continue;
-        const selected = rowsBySequence.get(slice.sequence) ?? [];
-        const firstChunk = Math.floor(slice.byteOffset / SQLITE_SESSION_MESSAGE_CHUNK_BYTES);
-        const lastChunk = Math.floor((slice.byteOffset + slice.byteLength - 1) / SQLITE_SESSION_MESSAGE_CHUNK_BYTES);
-        if (selected.length !== lastChunk - firstChunk + 1) {
-            throw new StoredSessionMessageIncompatibleError(sessionId, slice.sequence);
-        }
-        const chunks = [];
-        for (let index = 0; index < selected.length; index += 1) {
-            const row = selected[index];
-            if (row.chunk_index !== firstChunk + index ||
-                !(row.data instanceof Uint8Array) ||
-                typeof row.sha256 !== 'string') {
-                throw new StoredSessionMessageIncompatibleError(sessionId, slice.sequence);
-            }
-            const chunk = Buffer.from(row.data);
-            if (createHash('sha256').update(chunk).digest('hex') !== row.sha256) {
-                throw new StoredSessionMessageIncompatibleError(sessionId, slice.sequence);
-            }
-            chunks.push(chunk);
-        }
-        const joined = Buffer.concat(chunks);
-        const start = slice.byteOffset - firstChunk * SQLITE_SESSION_MESSAGE_CHUNK_BYTES;
-        const data = joined.subarray(start, start + slice.byteLength);
-        if (data.byteLength !== slice.byteLength) {
-            throw new StoredSessionMessageIncompatibleError(sessionId, slice.sequence);
-        }
-        result.set(slice.sequence, data);
-    }
-    const inlineSlices = slices.filter((slice) => !slice.chunked);
-    if (inlineSlices.length > 0) {
-        const inlineValues = inlineSlices.map(() => '(?, ?, ?)').join(', ');
-        const inlineParameters = inlineSlices.flatMap((slice) => [
-            slice.sequence,
-            slice.byteOffset + 1,
-            slice.byteLength,
-        ]);
-        const inlineRows = db
-            .prepare(`
-          WITH requested(sequence, byte_start, byte_length) AS (VALUES ${inlineValues})
-          SELECT requested.sequence,
-            substr(CAST(message.record_json AS BLOB), requested.byte_start, requested.byte_length)
-              AS data
-          FROM requested
-          INNER JOIN session_messages AS message
-            ON message.session_id = ? AND message.sequence = requested.sequence
-        `)
-            .all(...inlineParameters, sessionId);
-        for (const row of inlineRows) {
-            const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-            if (!(row.data instanceof Uint8Array)) {
-                throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-            }
-            result.set(sequence, Buffer.from(row.data));
-        }
-    }
-    return result;
-}
-function validateTranscriptRecord(data, sessionId, sequence) {
-    try {
-        decodeStoredMessage(markPersisted(JSON.parse(typeof data === 'string' ? data : data.toString('utf8'))));
-    }
-    catch (error) {
-        throw new StoredSessionMessageIncompatibleError(sessionId, sequence, {
-            cause: error,
-        });
-    }
-}
-function assertTranscriptPageRequest(request) {
-    if (request.direction !== 'older' && request.direction !== 'newer') {
-        throw new Error('Invalid Session transcript page direction');
-    }
-    if (request.throughSequence !== undefined &&
-        request.throughSequence !== null &&
-        (!Number.isSafeInteger(request.throughSequence) || request.throughSequence < 0)) {
-        throw new Error('Invalid Session transcript watermark');
-    }
-    if (request.position !== undefined &&
-        (!Number.isSafeInteger(request.position) || request.position < 0)) {
-        throw new Error('Invalid Session transcript position');
-    }
-    if (request.byteOffset !== undefined &&
-        (request.position === undefined ||
-            !Number.isSafeInteger(request.byteOffset) ||
-            request.byteOffset < 0)) {
-        throw new Error('Invalid Session transcript byte offset');
-    }
-    if (!Number.isSafeInteger(request.maxBytes) ||
-        request.maxBytes < 1 ||
-        request.maxBytes > 1024 * 1024) {
-        throw new Error('Session transcript page byte limit must be between 1 and 1048576');
-    }
-    if (!Number.isSafeInteger(request.maxMessages) ||
-        request.maxMessages < 1 ||
-        request.maxMessages > 256) {
-        throw new Error('Session transcript page message limit must be between 1 and 256');
-    }
-}
-function assertTranscriptRecordScanRequest(request) {
-    if (request.direction !== 'older' && request.direction !== 'newer') {
-        throw new Error('Invalid Session transcript record direction');
-    }
-    if (request.throughSequence !== undefined &&
-        request.throughSequence !== null &&
-        (!Number.isSafeInteger(request.throughSequence) || request.throughSequence < 0)) {
-        throw new Error('Invalid Session transcript watermark');
-    }
-    if (request.position !== undefined &&
-        (!Number.isSafeInteger(request.position) || request.position < 0)) {
-        throw new Error('Invalid Session transcript position');
-    }
-    if (!Number.isSafeInteger(request.maxStoredBytes) ||
-        request.maxStoredBytes < 1 ||
-        request.maxStoredBytes > 16 * 1024 * 1024) {
-        throw new Error('Invalid Session transcript record byte limit');
-    }
-    if (!Number.isSafeInteger(request.maxMessages) ||
-        request.maxMessages < 1 ||
-        request.maxMessages > 256) {
-        throw new Error('Invalid Session transcript record count limit');
-    }
-}