maka-agent 0.2.0-dev.25.20260908 → 0.2.0-dev.26.20260909

package/node_modules/@maka/runtime-host/dist/server/operation-dispatcher.js

@@ -16,14 +16,13 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { truncateUtf8 } from '@maka/core/diagnostic-log';
-import { redactSecrets } from '@maka/core/redaction';
 import { HOST_OPERATION_SPECS, decodeOperationOutcome, } from '../protocol/index.js';
 import { HOST_BOOTSTRAP_OPERATION_SPECS } from '../protocol/host-status.js';
 import { HOST_RESOURCE_OPERATION_SPECS } from '../protocol/host-resources.js';
 import { ACCESS_AUTHORITY_OPERATION_SPECS } from '../protocol/access-authority.js';
 import { SESSION_COLLABORATION_OPERATION_SPECS } from '../protocol/session-collaboration.js';
 import { PEER_MESH_OPERATION_SPECS } from '../protocol/peer-mesh.js';
+import { boundedFailureDiagnostic } from './failure-diagnostic.js';
 import { createPeerMeshOperationHandlers } from './peer-mesh-authority.js';
 /**
  * The spec objects a Runtime Host serves from its own core — operations that
@@ -144,7 +143,7 @@ async function dispatchTypedOperation(request, handlers, context) {
         outcome = decodeOperationOutcome(request.operation, await handler(request.input, context));
     }
     catch (error) {
-        console.error(`[runtime-host] unexpected ${request.operation} failure: ${boundedUnexpectedFailure(error)}`);
+        console.error(`[runtime-host] unexpected ${request.operation} failure: ${boundedFailureDiagnostic(error)}`);
         return operationFailureResponse(request, 'internal_failure', 'Runtime Host operation failed');
     }
     return outcome.ok
@@ -161,7 +160,3 @@ async function dispatchTypedOperation(request, handlers, context) {
             error: outcome.error,
         };
 }
-function boundedUnexpectedFailure(error) {
-    const details = error instanceof Error ? error.stack || `${error.name}: ${error.message}` : String(error);
-    return truncateUtf8(redactSecrets(details), 8 * 1024, '\n<diagnostic truncated>');
-}

package/node_modules/@maka/runtime-host/dist/server/root-turn-coordinator.js

@@ -21,7 +21,7 @@ import { isDeepStrictEqual } from 'node:util';
 import { readLogicalRuntimeExecution, readLogicalRuntimeExecutionForRun, } from '@maka/core/runtime-logical-execution';
 import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
 import { INLINE_REFERENCE_MAX_COUNT, messageContentDigest, messageContentsEqual, normalizeMessageContent, } from '@maka/core/events';
-import { isWorkHubCoordinationSessionId } from '@maka/core/session';
+import { WORKHUB_COORDINATION_SESSION_ID, isWorkHubCoordinationSessionId, } from '@maka/core/session';
 import { resolveEffectiveOrchestration } from '@maka/core/orchestration';
 import { decodeSkillInvocationResult, } from '@maka/core/skill-invocation';
 import { agentGraphIdForRootSession } from '@maka/runtime/stream-graph-coordinator';
@@ -222,6 +222,10 @@ export class RootTurnCoordinator {
             throw error;
         }
     }
+    /** Called under Session admission before changing an execution's authority ceiling. */
+    isSessionExecutionIdle(sessionId) {
+        return (!this.#recoveryPlansBySession.has(sessionId) && this.readRootState(sessionId).kind === 'idle');
+    }
     readRootState(sessionId) {
         const active = this.#executions.get(sessionId);
         if (active) {
@@ -565,7 +569,10 @@ export class RootTurnCoordinator {
         if (isWorkHubCoordinationSessionId(input.sessionId)) {
             return Promise.reject(new RuntimeHostedRootUnavailableError(input.sessionId, WORKHUB_COORDINATION_EXECUTION_UNAVAILABLE_REASON));
         }
-        return this.runCommand(async () => {
+        // Admission is active work even while queued behind a Session gate. Its
+        // residency overlaps the execution residency until admission settles.
+        const residency = this.acquireRecoveryResidency();
+        const admission = this.runCommand(async () => {
             const activeAtEntry = this.#executions.has(input.sessionId);
             let reservation = preparedReservation ?? (activeAtEntry ? undefined : this.reserveRootTurn(input.sessionId));
             if (preparedReservation && this.#admissions.get(input.sessionId) !== preparedReservation) {
@@ -674,6 +681,7 @@ export class RootTurnCoordinator {
                 throw error.cause;
             throw error;
         });
+        return admission.finally(() => residency.release());
     }
     lookup(sessionId, turnId) {
         return this.runCommand(async () => {
@@ -1090,15 +1098,92 @@ export class RootTurnCoordinator {
         if (!isWorkHubCoordinationSessionId(request.sessionId)) {
             return Promise.resolve(operationUnavailable('WorkHub Coordination execution requires its reserved Session'));
         }
+        if ((request.execution.operation === 'action') !== (request.operation !== undefined)) {
+            return Promise.resolve(operationUnavailable('Coordination execution mode does not match its runner'));
+        }
         return this.startRootMessage(request, context);
     }
-    /**
-     * Whether a durable root Turn already owns this identity. WorkHub also writes
-     * Coordination Turns outside this coordinator, and must not append a second
-     * triplet into a Turn this admission ledger already owns.
-     */
-    async hasRootTurnAdmission(sessionId, turnId) {
-        return (await this.stores.agentRunStore.readRootTurnAdmission(sessionId, turnId)) !== undefined;
+    async runWorkHubCoordinationOperation(request, context) {
+        if (request.execution.operation !== 'action' || !request.operation) {
+            return operationUnavailable('Coordination action requires a Host operation');
+        }
+        let turnId = request.turnId;
+        let recoveredReceipt;
+        // A retry preserves the action identity, but never reopens a terminal Run.
+        // The existing admission chain and terminal facts identify prior attempts.
+        for (;;) {
+            const admission = await this.stores.agentRunStore.readRootTurnAdmission(request.sessionId, turnId);
+            if (!admission)
+                break;
+            if (!rootExecutionMatches(admission.execution, request.execution))
+                return operationConflict('Coordination action identity belongs to different content');
+            const run = await this.readRunIfPresent(request.sessionId, admission.runId);
+            if (!run)
+                break;
+            const snapshot = await this.readCanonicalSnapshot(request.sessionId, turnId, admission.runId, run);
+            if (!isTerminalSnapshot(snapshot) || snapshot.status === 'completed')
+                break;
+            // A crash after the receipt does not erase a completed Host effect.
+            const events = await this.stores.runtimeEventStore.readImmutableRuntimeEvents(request.sessionId, admission.runId);
+            recoveredReceipt ??= events.find((event) => event.actions?.coordination)?.actions
+                ?.coordination;
+            turnId = `whretry_${createHash('sha256').update(admission.runId).digest('hex').slice(0, 48)}`;
+        }
+        const receiptToReplay = recoveredReceipt;
+        const started = await this.startWorkHubCoordinationMessage({
+            ...request,
+            turnId,
+            ...(receiptToReplay ? { operation: async () => receiptToReplay } : {}),
+        }, context);
+        if (!started.ok)
+            return started;
+        const active = this.#executions.get(request.sessionId);
+        if (active?.turnId === turnId)
+            await active.done;
+        const snapshot = await this.readCanonicalSnapshot(request.sessionId, turnId, started.result.runId);
+        if (snapshot.status !== 'completed')
+            return operationUnavailable('Coordination operation did not complete');
+        const events = await this.stores.runtimeEventStore.readImmutableRuntimeEvents(request.sessionId, started.result.runId);
+        const receipt = events.find((event) => event.actions?.coordination)?.actions?.coordination;
+        return receipt
+            ? { ok: true, result: receipt }
+            : operationUnavailable('Coordination receipt is unavailable');
+    }
+    coordinationOperation(request, admission) {
+        if (request.execution.kind !== 'workhub_coordination' ||
+            !('operation' in request) ||
+            !request.operation)
+            return undefined;
+        const execute = request.operation;
+        const content = requireHostedExecutionMessageContent(admission);
+        return {
+            sessionId: admission.sessionId,
+            turnId: admission.turnId,
+            runId: admission.runId,
+            userMessageId: admission.userMessageId,
+            execution: admission.execution,
+            content,
+            start: ({ runId, userMessageId, onRunStarted }) => this.manager.runCoordinationOperation(admission.sessionId, { turnId: admission.turnId, ...content }, { runId, userMessageId, onRunStarted }, () => execute(admission.turnId)),
+        };
+    }
+    /** Accepts a model action against the exact live WorkHub root and its durable user input. */
+    readActiveWorkHubRequest(turnId) {
+        const sessionId = WORKHUB_COORDINATION_SESSION_ID;
+        return this.sessionAdmission.run(sessionId, async () => {
+            const active = this.#executions.get(sessionId);
+            if (!active || active.turnId !== turnId)
+                return undefined;
+            const [admission, header] = await Promise.all([
+                this.stores.agentRunStore.readRootTurnAdmission(sessionId, turnId),
+                this.stores.sessionStore.readHeaderSnapshot(sessionId),
+            ]);
+            if (this.#executions.get(sessionId) !== active ||
+                admission?.runId !== active.runId ||
+                admission.execution.kind !== 'workhub_coordination' ||
+                header.toolProfile !== 'workhub-coordination-v2')
+                return undefined;
+            return requireHostedExecutionMessageContent(admission);
+        });
     }
     startRootMessage(request, context) {
         return this.runCommand(async () => {
@@ -1115,7 +1200,7 @@ export class RootTurnCoordinator {
                     if (existing.execution.kind !== request.execution.kind) {
                         return completedStart(operationConflict('Turn identity belongs to a different execution kind'));
                     }
-                    if (!isDeepStrictEqual(existing.execution, request.execution)) {
+                    if (!rootExecutionMatches(existing.execution, request.execution)) {
                         return completedStart(operationConflict('Turn identity belongs to a different execution payload'));
                     }
                     let content;
@@ -1141,7 +1226,7 @@ export class RootTurnCoordinator {
                             return completedStart({ ok: true, result: snapshot });
                         }
                     }
-                    return this.prepareAdmittedTurn(activationInputForAdmission(existing), existing, context.acquireResidency, lease, undefined, undefined, reservation);
+                    return this.prepareAdmittedTurn(activationInputForAdmission(existing), existing, context.acquireResidency, lease, undefined, this.coordinationOperation(request, existing), reservation);
                 }
                 reservation ??= this.reserveRootTurn(request.sessionId);
                 if (!reservation) {
@@ -1186,7 +1271,8 @@ export class RootTurnCoordinator {
                 const attachmentError = await this.attachmentValidator?.validateTurnAttachments(request.sessionId, attachments);
                 if (attachmentError)
                     return completedStart(operationConflict(attachmentError));
-                const binding = request.execution.kind === 'workhub_coordination'
+                const binding = request.execution.kind === 'workhub_coordination' &&
+                    header.toolProfile === 'workhub-coordination-v1'
                     ? undefined
                     : prepared.commitCapabilityBinding
                         ? await prepared.commitCapabilityBinding()
@@ -1226,7 +1312,7 @@ export class RootTurnCoordinator {
                 if (!rootMessageAdmissionMatches(admitted.admission, request, canonicalContent.content, context.turnAdmissionAuthorization)) {
                     return completedStart(operationConflict('Turn identity was already admitted with a different payload'));
                 }
-                return this.prepareAdmittedTurn(activationInputForAdmission(admitted.admission), admitted.admission, context.acquireResidency, lease, undefined, undefined, reservation);
+                return this.prepareAdmittedTurn(activationInputForAdmission(admitted.admission), admitted.admission, context.acquireResidency, lease, undefined, this.coordinationOperation(request, admitted.admission), reservation);
             });
             const disposition = await admissionTask.finally(() => {
                 if (reservation)
@@ -2198,8 +2284,18 @@ function throwHostedStopError(sessionId, outcome) {
             throw new RuntimeHostedRootUnavailableError(sessionId, outcome.error.message);
     }
 }
+/** Compatibility may omit only the action identity absent from an older admission. */
+function rootExecutionMatches(stored, incoming) {
+    if (stored.kind === 'workhub_coordination' &&
+        incoming.kind === 'workhub_coordination' &&
+        stored.actionId === undefined) {
+        const { actionId: _actionId, ...legacyIncoming } = incoming;
+        return isDeepStrictEqual(stored, legacyIncoming);
+    }
+    return isDeepStrictEqual(stored, incoming);
+}
 function rootMessageAdmissionMatches(admission, request, content, authorization) {
-    return (isDeepStrictEqual(admission.execution, request.execution) &&
+    return (rootExecutionMatches(admission.execution, request.execution) &&
         (request.execution.kind === 'external_message' && request.execution.inputDigest
             ? true
             : messageContentsEqual(requireHostedExecutionMessageContent(admission), content)) &&

package/node_modules/@maka/runtime-host/dist/server/runtime-resource-coordinator.js

@@ -23,6 +23,7 @@ import { ShellRunPtyControlClosedError, isShellRunResourceRef, } from '@maka/run
 import { defaultShellPlan, ShellPreferenceError } from '@maka/runtime/shell-detect';
 import { isSessionNotFoundError } from '@maka/storage/execution-stores';
 import { decodeRuntimeResourceControllerAcquireResult, decodeRuntimeResourceControllerControlResult, decodeRuntimeResourceQueryResult, decodeRuntimeResourceStopResult, decodeRuntimeResourceStartResult, RUNTIME_RESOURCE_CONTROLLER_ACQUIRE_RESULT_MAX_BYTES, RUNTIME_RESOURCE_MAX_CONTROL_SEQUENCE, } from '../protocol/index.js';
+import { boundedFailureDiagnostic } from './failure-diagnostic.js';
 import { boundedRuntimeResourceSnapshot, canonicalRuntimeResources, createRuntimeResourcePage, runtimeResourceRevision, runtimeResourceSnapshotFromResult, } from './runtime-resource-projection.js';
 const MAX_CONTROL_REPLAYS = 128;
 /** Owns Host Shell/PTY tools plus the connection-scoped Client controller fence. */
@@ -186,8 +187,7 @@ export class HostRuntimeResourceCoordinator {
                 if (isSessionNotFoundError(error)) {
                     return queryFailure('not_found', 'Session was not found');
                 }
-                this.#requestDrain();
-                return queryFailure('internal_failure', 'Session state is unavailable');
+                return this.#canonicalReadFailure(error, 'Session state is unavailable');
             }
             if (input.kind === 'get') {
                 try {
@@ -206,9 +206,8 @@ export class HostRuntimeResourceCoordinator {
                         }),
                     };
                 }
-                catch {
-                    this.#requestDrain();
-                    return queryFailure('internal_failure', 'Runtime Resource state is unavailable');
+                catch (error) {
+                    return this.#canonicalReadFailure(error, 'Runtime Resource state is unavailable');
                 }
             }
             let updates;
@@ -218,9 +217,8 @@ export class HostRuntimeResourceCoordinator {
                     updates = updates.filter((update) => update.sessionId === input.sessionId);
                 }
             }
-            catch {
-                this.#requestDrain();
-                return queryFailure('internal_failure', 'Runtime Resource state is unavailable');
+            catch (error) {
+                return this.#canonicalReadFailure(error, 'Runtime Resource state is unavailable');
             }
             try {
                 const resources = canonicalRuntimeResources(updates);
@@ -251,6 +249,11 @@ export class HostRuntimeResourceCoordinator {
             ? queryFailure('not_found', 'Session was not found')
             : outcome;
     }
+    #canonicalReadFailure(error, message) {
+        console.error(`[runtime-host] canonical Runtime Resource read failed: ${boundedFailureDiagnostic(error)}`);
+        this.#requestDrain();
+        return queryFailure('internal_failure', message);
+    }
     #guestObservationGrantId(context, sessionId) {
         if (context.principalKind !== 'session_guest')
             return;

package/node_modules/@maka/runtime-host/dist/server/scheduled-task-coordinator.js

@@ -418,28 +418,38 @@ export class HostScheduledTaskCoordinator {
         }
     }
     async #refresh() {
-        await this.#exclusive(async () => {
-            if (this.#handoffHeld || this.#draining)
-                return;
-            for (const claim of await this.#store.listPendingFires()) {
+        if (this.#handoffHeld || this.#draining)
+            return;
+        // Cover claim admission, native delivery, and persistence, while an idle
+        // schedule or a read-only catalog query does not claim active work.
+        const residency = this.#acquireResidency();
+        try {
+            await this.#exclusive(async () => {
                 if (this.#handoffHeld || this.#draining)
-                    break;
-                if (claim.nativeState === 'waiting_for_provider') {
-                    await this.#fulfill(claim, true);
+                    return;
+                for (const claim of await this.#store.listPendingFires()) {
+                    if (this.#handoffHeld || this.#draining)
+                        break;
+                    if (claim.nativeState === 'waiting_for_provider') {
+                        await this.#fulfill(claim, true);
+                    }
                 }
-            }
-            while (!this.#draining && !this.#handoffHeld) {
-                const scan = await this.#store.claimNextDue(this.#now());
-                for (const expired of scan.expired)
-                    this.#publish('updated', expired.id);
-                const claim = scan.claim;
-                if (!claim)
-                    break;
-                await this.#refreshResidency();
-                await this.#fulfill(claim, false);
-            }
-            await this.#refreshSchedule();
-        });
+                while (!this.#draining && !this.#handoffHeld) {
+                    const scan = await this.#store.claimNextDue(this.#now());
+                    for (const expired of scan.expired)
+                        this.#publish('updated', expired.id);
+                    const claim = scan.claim;
+                    if (!claim)
+                        break;
+                    await this.#refreshResidency();
+                    await this.#fulfill(claim, false);
+                }
+                await this.#refreshSchedule();
+            });
+        }
+        finally {
+            residency.release();
+        }
     }
     async #fulfill(claim, recovering) {
         const incognito = (await this.#runtimePolicy.runtimePolicy.getSnapshot()).policy.privacy
@@ -680,7 +690,7 @@ export class HostScheduledTaskCoordinator {
             (claims.length > 0 ||
                 tasks.some((task) => task.status === 'active' && task.nextFireAt !== null));
         if (shouldHold && !this.#residency)
-            this.#residency = this.#acquireResidency();
+            this.#residency = this.#acquireResidency('idle');
         if (!shouldHold)
             this.#releaseResidency();
     }

package/node_modules/@maka/runtime-host/dist/server/serial-outbound-writer.js

@@ -134,7 +134,7 @@ export class BoundedSerialOutboundWriter {
         if (this.#closed)
             return;
         this.close(error);
-        this.#onFailure();
+        this.#onFailure(error);
     }
     #nextFrame() {
         // Close acknowledgements are fences: no lower-priority subscription

package/node_modules/@maka/runtime-host/dist/server/session-catalog-coordinator.js

@@ -24,7 +24,7 @@ import { thinkingVariantsForConnection } from '@maka/core/model-thinking';
 import { executionBoundaryDisplayMode, } from '@maka/core/sandbox-boundary';
 import { DEFAULT_SESSION_NAME, normalizeUserSessionName } from '@maka/core/session-name';
 import { isSessionStartModeLabel as isExecutionSemanticLabel, sessionStartModeSpec, } from '@maka/core/session-start-mode';
-import { isWorkHubCoordinationSessionId, isWorkHubCoordinationSessionTarget, } from '@maka/core/session';
+import { WORKHUB_COORDINATION_SESSION_ID, isWorkHubCoordinationSession, isWorkHubCoordinationSessionId, isWorkHubCoordinationSessionTarget, } from '@maka/core/session';
 import { isSessionNotFoundError, SessionMetadataConflictError, SessionMetadataVersionConflictError, } from '@maka/storage/execution-stores';
 import { isVisibleSessionMessage } from '@maka/storage/session-message-projection';
 import { SessionConfigurationRevisionConflictError, SessionConfigurationTransitionError, } from '@maka/runtime/session-manager';
@@ -438,15 +438,27 @@ export class HostSessionCatalogCoordinator {
             }
         });
     }
-    async #updateConfiguration(input) {
-        if (isWorkHubCoordinationSessionId(input.sessionId)) {
+    configureWorkHubModel(input) {
+        return this.#updateConfiguration({
+            sessionId: WORKHUB_COORDINATION_SESSION_ID,
+            expectedRevision: input.expectedRevision,
+            patch: { modelTarget: input.modelTarget },
+        }, 'workhub');
+    }
+    async #updateConfiguration(input, authority = 'ordinary') {
+        if (authority === 'ordinary' && isWorkHubCoordinationSessionId(input.sessionId)) {
             return configurationFailure('operation_conflict', 'WorkHub Coordination Session configuration requires WorkHub authority');
         }
         return this.#admission.run(input.sessionId, async (lease) => {
             let commitAttempted = false;
             try {
                 const current = await this.#stores.readHeaderRecordSnapshot(input.sessionId);
-                if (isWorkHubCoordinationSessionTarget(current.header)) {
+                if (authority === 'workhub' &&
+                    (!isWorkHubCoordinationSessionId(current.header.id) ||
+                        !isWorkHubCoordinationSession(current.header))) {
+                    return configurationFailure('operation_conflict', 'WorkHub Coordination Session identity is unavailable');
+                }
+                if (authority === 'ordinary' && isWorkHubCoordinationSessionTarget(current.header)) {
                     return configurationFailure('operation_conflict', 'WorkHub Coordination Session configuration requires WorkHub authority');
                 }
                 if (current.revision !== input.expectedRevision) {
@@ -461,7 +473,7 @@ export class HostSessionCatalogCoordinator {
                 if (!clearsConnectionBlock && sessionConfigurationMatches(current.header, configuration)) {
                     return configurationSuccess({
                         kind: 'committed',
-                        session: projectSessionCatalogRecord(await this.#stores.readCatalogRecord(input.sessionId)),
+                        session: projectSessionCatalogRecord(await this.#stores.readCatalogRecord(input.sessionId, authority === 'workhub' ? 'recoverable' : 'ordinary')),
                     });
                 }
                 commitAttempted = true;
@@ -470,7 +482,7 @@ export class HostSessionCatalogCoordinator {
                     clearConnectionBlock: input.patch.modelTarget !== undefined,
                     configuration,
                 });
-                return configurationSuccess(await this.#committedUpdate(input.sessionId, lease));
+                return configurationSuccess(await this.#committedUpdate(input.sessionId, lease, authority === 'workhub' ? 'recoverable' : 'ordinary'));
             }
             catch (error) {
                 if (!commitAttempted &&
@@ -597,11 +609,11 @@ export class HostSessionCatalogCoordinator {
             position = page.nextPosition;
         }
     }
-    async #committedUpdate(sessionId, lease) {
+    async #committedUpdate(sessionId, lease, roleScope = 'ordinary') {
         await this.#continuity.refreshCanonical(sessionId, lease);
         return {
             kind: 'committed',
-            session: projectSessionCatalogRecord(await this.#stores.readCatalogRecord(sessionId)),
+            session: projectSessionCatalogRecord(await this.#stores.readCatalogRecord(sessionId, roleScope)),
         };
     }
     #metadataMutationFailure(input, error, unknownMessage) {

package/node_modules/@maka/runtime-host/dist/server/session-transcript-reader.js

@@ -46,18 +46,9 @@ const TRANSCRIPT_TURN_SCAN_LIMIT = 1;
  * as absent rather than searched for down the Session.
  */
 const TRANSCRIPT_LOOKUP_MAX_TURNS = 2;
-/** One storage round trip of Coordination rows, sized like one ledger Turn. */
-const COORDINATION_TRANSCRIPT_SCAN_LIMIT = 64;
-const COORDINATION_TRANSCRIPT_SCAN_MAX_BYTES = DURABLE_TRANSCRIPT_TURN_MAX_BYTES;
 export function createSessionTranscriptReader(input) {
     const ledger = createDurableLedgerTranscriptReader(input);
-    const coordination = createCoordinationTranscriptReader(input.stores);
-    const isCoordination = (sessionId) => sessionId === WORKHUB_COORDINATION_SESSION_ID;
-    // Only a ledger-backed Session has a conversion; the Coordination Session's
-    // rows are the transcript, not something a run left behind.
     const prepared = async (sessionId) => {
-        if (isCoordination(sessionId))
-            return coordination;
         await input.ensureTranscriptLedger?.(sessionId);
         return ledger;
     };
@@ -148,6 +139,12 @@ function createDurableLedgerTranscriptReader(input) {
         if (projected.diagnostics.some(isHardRuntimeEventReadModelDiagnostic)) {
             throw new Error('Durable RuntimeEvent transcript projection is incomplete');
         }
+        const admission = turn.invocation.sessionId === WORKHUB_COORDINATION_SESSION_ID
+            ? await input.stores.agentRunStore.readRootTurnAdmission(turn.invocation.sessionId, turn.invocation.turnId)
+            : undefined;
+        const actionId = admission?.execution.kind === 'workhub_coordination'
+            ? admission.execution.actionId
+            : undefined;
         const ordinals = new Map(turn.events.map((entry) => [entry.event.id, entry.ordinal]));
         const emitted = new Map();
         return projected.messages.map((message, index) => {
@@ -160,7 +157,12 @@ function createDurableLedgerTranscriptReader(input) {
                 throw new Error('RuntimeEvent exceeds its transcript sequence stride');
             }
             emitted.set(ordinal, offset + 1);
-            return { sequence: ordinal * EVENT_SEQUENCE_STRIDE + offset, message };
+            return {
+                sequence: ordinal * EVENT_SEQUENCE_STRIDE + offset,
+                message: message.type === 'user' && actionId
+                    ? { ...message, coordinationActionId: actionId }
+                    : message,
+            };
         });
     };
     const readTurns = async (sessionId, request) => store.readTranscriptInvocations(sessionId, {
@@ -221,9 +223,11 @@ function createDurableLedgerTranscriptReader(input) {
             ordinal = older ? low - 1 : high + 1;
         }
     };
+    const source = { readHighWater: highWater, scan };
     return {
+        source,
         readHighWater: highWater,
-        ...pagedTranscriptReads({ readHighWater: highWater, scan }),
+        ...pagedTranscriptReads(source),
         /** One row per Turn, folded from the Turn's own projected messages. */
         async readTurnContributions(sessionId, throughSequence, position, maxContributions) {
             const watermark = throughSequence ?? (await highWater(sessionId));
@@ -395,99 +399,6 @@ function pagedTranscriptReads(source) {
         },
     };
 }
-/**
- * The WorkHub Coordination Session's transcript, read from the rows the WorkHub
- * writes.
- *
- * Every other Session's transcript is what its runs did, so the ledger holds
- * all of it. The Coordination Session's is not: a delegation, a stop and a
- * routing summary are appended under a Turn id that no root Turn admission ever
- * minted, so there is no invocation for the ledger to hang them on and no
- * conversion that could lift them. `workhub.coordination.answer` is the one
- * path that would admit a real Turn and nothing in the renderer calls it.
- *
- * Delete this source once the WorkHub admits a Coordination Turn for every
- * action, which its own ADR already requires (#3492,
- * `docs/architecture/workhub-coordination-session-adr.md`): the Session then
- * reads like any other and this reader has nothing left to do.
- */
-function createCoordinationTranscriptReader(stores) {
-    const store = stores.sessionStore;
-    const highWater = (sessionId) => store.readTranscriptHighWaterSnapshot(sessionId);
-    const scan = async function* (sessionId, request) {
-        const throughSequence = request.throughSequence === undefined ? await highWater(sessionId) : request.throughSequence;
-        if (throughSequence === null)
-            return;
-        const older = request.direction === 'older';
-        const position = request.position ?? (older ? throughSequence : 0);
-        let cursor = older ? Math.min(position, throughSequence) + 1 : position - 1;
-        for (;;) {
-            const page = await store.readMessagesAfter(sessionId, {
-                ...(older ? { beforeSequence: cursor } : { afterSequence: cursor }),
-                maxMessages: COORDINATION_TRANSCRIPT_SCAN_LIMIT,
-                maxStoredBytes: COORDINATION_TRANSCRIPT_SCAN_MAX_BYTES,
-            });
-            if (page.records.length === 0)
-                return;
-            for (const record of page.records) {
-                if (!older && record.sequence > throughSequence)
-                    return;
-                yield record;
-            }
-            cursor = page.records.at(-1).sequence;
-        }
-    };
-    const source = { readHighWater: highWater, scan };
-    return {
-        readHighWater: highWater,
-        ...pagedTranscriptReads(source),
-        /** Folded from the rows themselves; these Turns have nothing else. */
-        async readTurnContributions(sessionId, throughSequence, position, maxContributions) {
-            const watermark = throughSequence ?? (await highWater(sessionId));
-            if (watermark === null) {
-                return { throughSequence: null, contributions: [], nextPosition: null };
-            }
-            const byTurn = new Map();
-            let nextPosition = null;
-            for await (const { sequence, message } of scan(sessionId, {
-                direction: 'newer',
-                throughSequence: watermark,
-                position,
-            })) {
-                const turnId = message.turnId;
-                if (turnId === undefined)
-                    continue;
-                if (!byTurn.has(turnId) && byTurn.size === maxContributions) {
-                    nextPosition = sequence;
-                    break;
-                }
-                byTurn.set(turnId, foldTurnContribution(byTurn.get(turnId), turnId, sequence, message));
-            }
-            return { throughSequence: watermark, contributions: [...byTurn.values()], nextPosition };
-        },
-        /** Every prompt, in order: this transcript has no index to sample from. */
-        async readTurnLandmarks(sessionId, maxLandmarks) {
-            const throughSequence = await highWater(sessionId);
-            if (throughSequence === null)
-                return { throughSequence: null, landmarks: [] };
-            const landmarks = [];
-            for await (const { sequence, message } of scan(sessionId, {
-                direction: 'newer',
-                throughSequence,
-            })) {
-                if (message.type !== 'user' || message.turnId === undefined)
-                    continue;
-                const label = (message.displayText ?? message.text ?? '').trim();
-                if (!label)
-                    continue;
-                landmarks.push({ turnId: message.turnId, sequence, label });
-                if (landmarks.length === maxLandmarks)
-                    break;
-            }
-            return { throughSequence, landmarks };
-        },
-    };
-}
 function ordinalOf(sequence) {
     return Math.floor(sequence / EVENT_SEQUENCE_STRIDE);
 }

package/node_modules/@maka/runtime-host/dist/server/shared-session-transcript.js

@@ -44,6 +44,9 @@ export function projectSharedSessionTranscriptMessage(message, sessionId) {
                     ? {}
                     : { steeringEventId: message.steeringEventId }),
                 ...(message.origin === undefined ? {} : { origin: message.origin }),
+                ...(message.coordinationActionId === undefined
+                    ? {}
+                    : { coordinationActionId: message.coordinationActionId }),
             };
         }
         case 'assistant':