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

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

@@ -16,11 +16,12 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { DURABLE_TOOL_RESULT_PROJECTION_MAX_BYTES } from '@maka/core/durable-tool-result-projection';
 import { readRunInvocation } from '@maka/core/runtime-event-store';
 import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
 import { readLogicalRuntimeExecution } from '@maka/core/runtime-logical-execution';
 import { WORKHUB_COORDINATION_SESSION_ID } from '@maka/core/session';
-import { activePresentationRuntimeEvents, affectsRuntimeEventStoredMessageProjection, isHardRuntimeEventReadModelDiagnostic, projectRuntimeEventsToStoredMessages, projectRuntimeEventUserMessage, } from '@maka/runtime/runtime-event-read-model';
+import { createRuntimeEventStoredMessageProjector, projectTranscriptToolResult, isHardRuntimeEventReadModelDiagnostic, projectRuntimeEventUserMessage, } from '@maka/runtime/runtime-event-read-model';
 import { foldTurnContribution } from '@maka/storage/session-message-projection';
 import { SESSION_TRANSCRIPT_OVERLAY_MAX_MESSAGES } from '../protocol/index.js';
 const PERMISSION_OUTCOME_READ_CONCURRENCY = 8;
@@ -28,15 +29,13 @@ const PERMISSION_OUTCOME_READ_CONCURRENCY = 8;
 const EVENT_SEQUENCE_STRIDE = 8;
 export const ACTIVE_TRANSCRIPT_OVERLAY_MAX_MESSAGES = SESSION_TRANSCRIPT_OVERLAY_MAX_MESSAGES;
 export const ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES = 16 * 1024 * 1024;
-const ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS = ACTIVE_TRANSCRIPT_OVERLAY_MAX_MESSAGES * 2;
+const TRANSCRIPT_SOURCE_MAX_EVENTS = ACTIVE_TRANSCRIPT_OVERLAY_MAX_MESSAGES * 2;
+// One RuntimeEvent can carry both the raw Tool Result and its durable model projection.
+const TRANSCRIPT_SOURCE_MAX_RECORD_BYTES = DURABLE_TOOL_RESULT_PROJECTION_MAX_BYTES * 2 + 256 * 1024;
+// The scan releases each decoded record after projection. Its memory budget is
+// separate from the bounded amount of immutable input it may visit.
+const TRANSCRIPT_SOURCE_MAX_BYTES = TRANSCRIPT_SOURCE_MAX_EVENTS * TRANSCRIPT_SOURCE_MAX_RECORD_BYTES;
 const ACTIVE_TRANSCRIPT_SCAN_BATCH_MAX_BYTES = 256 * 1024;
-/**
- * What one durable page may read of a Turn, matching the bound the live
- * overlay already holds for a run. A Turn past it is refused rather than
- * half-projected: a prefix of a Turn is not a smaller transcript of it.
- */
-const DURABLE_TRANSCRIPT_TURN_MAX_EVENTS = ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS;
-const DURABLE_TRANSCRIPT_TURN_MAX_BYTES = ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES;
 /** Turns per storage round trip: one, so a page loads no Turn it cannot use. */
 const TRANSCRIPT_TURN_SCAN_LIMIT = 1;
 /**
@@ -66,17 +65,7 @@ export function createSessionTranscriptReader(input) {
             const root = await readRunInvocation(store, sessionId, rootTurn.runId);
             if (!root)
                 return [];
-            const budget = { events: 0, bytes: 0 };
-            const scanned = new Map();
             const invocations = new Map([[root.runId, root]]);
-            const readEvents = async (runId) => {
-                const cached = scanned.get(runId);
-                if (cached)
-                    return cached;
-                const events = await readActiveRuntimeEvents(input.stores, sessionId, runId, budget);
-                scanned.set(runId, events);
-                return events;
-            };
             let runIds = [root.runId];
             if (root.terminalEvent && runtimeHandoffPause(root.terminalEvent)) {
                 const logical = await readLogicalRuntimeExecution({
@@ -87,26 +76,20 @@ export function createSessionTranscriptReader(input) {
                             invocations.set(runId, run);
                         return run;
                     },
-                    // Authenticate only after the same bounded scan used for presentation.
-                    // Sealed prefixes cannot grow between this check and digest verification.
-                    readImmutableRuntimeEvents: async (_id, runId) => (await readEvents(runId)).filter((event) => !event.partial),
-                    readImmutableRuntimePrefix: async (prefix) => {
-                        await readEvents(prefix.runId);
-                        return store.readImmutableRuntimePrefix(prefix);
-                    },
-                }, { sessionId, turnId: rootTurn.turnId, runId: rootTurn.runId }, root);
+                    readImmutableRuntimePrefixProof: (prefix) => store.readImmutableRuntimePrefixProof(prefix, {
+                        maxEvents: TRANSCRIPT_SOURCE_MAX_EVENTS,
+                        maxBytes: TRANSCRIPT_SOURCE_MAX_BYTES,
+                        maxRecordBytes: TRANSCRIPT_SOURCE_MAX_RECORD_BYTES,
+                    }),
+                }, { sessionId, turnId: rootTurn.turnId, runId: rootTurn.runId }, root, { mode: 'membership' });
                 if (!logical)
                     return [];
                 runIds = logical.runIds;
             }
-            const events = [];
+            const pending = createTranscriptProjection(runIds.map((runId) => invocations.get(runId)), true);
             for (const runId of runIds)
-                events.push(...(await readEvents(runId)).filter(affectsRuntimeEventStoredMessageProjection));
-            const canonicalPermissionOutcomes = await readCanonicalPermissionOutcomes(events, input.canonicalPermissionOutcomes);
-            const projected = projectRuntimeEventsToStoredMessages(activePresentationRuntimeEvents(events), {
-                invocations: runIds.map((runId) => invocations.get(runId)),
-                canonicalPermissionOutcomes,
-            });
+                await scanActiveRuntimeEvents(input.stores, sessionId, runId, pending.push);
+            const projected = await pending.finish(input.canonicalPermissionOutcomes);
             if (projected.diagnostics.some(isHardRuntimeEventReadModelDiagnostic)) {
                 throw new Error('Active RuntimeEvent transcript projection is incomplete');
             }
@@ -131,11 +114,7 @@ function createDurableLedgerTranscriptReader(input) {
     };
     /** One Turn's rows, each at the sequence its own event sits at. */
     const projectTurn = async (turn) => {
-        const events = turn.events.map((entry) => entry.event);
-        const projected = projectRuntimeEventsToStoredMessages(events, {
-            invocations: [turn.invocation],
-            canonicalPermissionOutcomes: await readCanonicalPermissionOutcomes(events, input.canonicalPermissionOutcomes),
-        });
+        const projected = await turn.projection.finish(input.canonicalPermissionOutcomes);
         if (projected.diagnostics.some(isHardRuntimeEventReadModelDiagnostic)) {
             throw new Error('Durable RuntimeEvent transcript projection is incomplete');
         }
@@ -145,7 +124,7 @@ function createDurableLedgerTranscriptReader(input) {
         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 ordinals = turn.ordinals;
         const emitted = new Map();
         return projected.messages.map((message, index) => {
             const ordinal = ordinals.get(projected.sourceEventIds[index]);
@@ -165,11 +144,20 @@ function createDurableLedgerTranscriptReader(input) {
             };
         });
     };
-    const readTurns = async (sessionId, request) => store.readTranscriptInvocations(sessionId, {
+    const readTurns = async (sessionId, request, limit = TRANSCRIPT_TURN_SCAN_LIMIT) => store.readTranscriptInvocations(sessionId, {
         ...request,
-        limit: TRANSCRIPT_TURN_SCAN_LIMIT,
-        maxEvents: DURABLE_TRANSCRIPT_TURN_MAX_EVENTS,
-        maxBytes: DURABLE_TRANSCRIPT_TURN_MAX_BYTES,
+        limit,
+        maxEvents: TRANSCRIPT_SOURCE_MAX_EVENTS,
+        maxBytes: TRANSCRIPT_SOURCE_MAX_BYTES,
+        maxRecordBytes: TRANSCRIPT_SOURCE_MAX_RECORD_BYTES,
+    }, (turn, events) => {
+        const projection = createTranscriptProjection([turn.invocation]);
+        const ordinals = new Map();
+        for (const { event, ordinal } of events) {
+            ordinals.set(event.id, ordinal);
+            projection.push(event);
+        }
+        return { ...turn, projection, ordinals };
     });
     const scan = async function* (sessionId, request) {
         const throughSequence = request.throughSequence === undefined ? await highWater(sessionId) : request.throughSequence;
@@ -234,14 +222,11 @@ function createDurableLedgerTranscriptReader(input) {
             if (watermark === null) {
                 return { throughSequence: null, contributions: [], nextPosition: null };
             }
-            const turns = await store.readTranscriptInvocations(sessionId, {
+            const turns = await readTurns(sessionId, {
                 direction: 'newer',
                 throughOrdinal: ordinalOf(watermark),
                 position: ordinalOf(position),
-                limit: maxContributions + 1,
-                maxEvents: DURABLE_TRANSCRIPT_TURN_MAX_EVENTS,
-                maxBytes: DURABLE_TRANSCRIPT_TURN_MAX_BYTES,
-            });
+            }, maxContributions + 1);
             const contributions = [];
             for (const turn of turns.slice(0, maxContributions)) {
                 // Folded from the Turn's own rows, so `firstSequence` lands on its first
@@ -414,11 +399,7 @@ function assertActiveOverlayBounded(messages) {
         }
     }
 }
-async function readCanonicalPermissionOutcomes(events, reader) {
-    const requestIds = new Set(events.flatMap((event) => {
-        const requestId = event.actions?.permissionAnswerAccepted?.requestId;
-        return requestId ? [requestId] : [];
-    }));
+async function readCanonicalPermissionOutcomes(requestIds, reader) {
     const outcomes = new Map();
     const ids = [...requestIds];
     let encodedBytes = 0;
@@ -439,32 +420,67 @@ async function readCanonicalPermissionOutcomes(events, reader) {
     }
     return outcomes;
 }
-async function readActiveRuntimeEvents(stores, sessionId, runId, budget) {
-    const events = [];
+async function scanActiveRuntimeEvents(stores, sessionId, runId, visit) {
     const result = await stores.runtimeEventStore.scanRuntimeEvents(sessionId, runId, {
         maxBatchBytes: ACTIVE_TRANSCRIPT_SCAN_BATCH_MAX_BYTES,
-        maxRecordBytes: ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES,
-        maxImmutableRecords: ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS,
-        maxImmutableBytes: ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES,
-        maxPartialRecords: ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS,
+        maxRecordBytes: TRANSCRIPT_SOURCE_MAX_RECORD_BYTES,
+        maxImmutableRecords: TRANSCRIPT_SOURCE_MAX_EVENTS,
+        maxImmutableBytes: TRANSCRIPT_SOURCE_MAX_BYTES,
+        maxPartialRecords: TRANSCRIPT_SOURCE_MAX_EVENTS,
         maxPartialBytes: ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES,
     }, (batch) => {
-        for (const event of batch) {
-            budget.events += 1;
-            budget.bytes += Buffer.byteLength(JSON.stringify(event), 'utf8');
-            if (budget.events > ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS) {
-                throw new Error('Active RuntimeEvent transcript exceeds its event limit');
-            }
-            if (budget.bytes > ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES) {
-                throw new Error('Active RuntimeEvent transcript exceeds its byte limit');
-            }
-        }
-        events.push(...batch);
+        for (const event of batch)
+            visit(event);
     });
     if (result.status === 'limit_exceeded') {
         throw new Error('Active RuntimeEvent transcript exceeds its storage scan limit');
     }
-    return events;
+}
+/** Keep only presentation state while the storage snapshot visits complete facts. */
+function createTranscriptProjection(invocations, active = false) {
+    const canonicalPermissionOutcomes = new Map();
+    let messageCount = 0;
+    let messageBytes = 0;
+    let eventCount = 0;
+    let sourceBytes = 0;
+    const projector = createRuntimeEventStoredMessageProjector({
+        invocations,
+        active,
+        canonicalPermissionOutcomes,
+        projectToolResult: projectTranscriptToolResult,
+        onMessage: (message) => {
+            messageCount += 1;
+            messageBytes += Buffer.byteLength(JSON.stringify(message));
+            if (messageCount > ACTIVE_TRANSCRIPT_OVERLAY_MAX_MESSAGES ||
+                messageBytes > ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES)
+                throw new Error('Session transcript projection exceeds its presentation limit');
+        },
+    });
+    return {
+        push(event) {
+            eventCount += 1;
+            const content = event.content;
+            // The durable model projection is never a transcript input. Large Bash
+            // streams are consumed into a bounded terminal preview by the read model.
+            const measured = content?.kind === 'function_response'
+                ? { ...event, content: { ...content, modelProjection: undefined, result: undefined } }
+                : event;
+            sourceBytes += Buffer.byteLength(JSON.stringify(measured));
+            if (eventCount > TRANSCRIPT_SOURCE_MAX_EVENTS)
+                throw new Error('Active RuntimeEvent transcript exceeds its event limit');
+            if (sourceBytes > ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES)
+                throw new Error('Active RuntimeEvent transcript exceeds its byte limit');
+            projector.push(event);
+        },
+        async finish(reader) {
+            const outcomes = await readCanonicalPermissionOutcomes(projector.permissionRequestIds, reader);
+            for (const [id, outcome] of outcomes)
+                canonicalPermissionOutcomes.set(id, outcome);
+            const projected = projector.finish();
+            assertActiveOverlayBounded(projected.messages);
+            return projected;
+        },
+    };
 }
 function isTerminalTurn(turn) {
     return turn.status === 'completed' || turn.status === 'failed' || turn.status === 'cancelled';

package/node_modules/@maka/runtime-host/dist/server/workhub-coordination-action-gate.js

@@ -213,15 +213,31 @@ export class WorkHubCoordinationActionGate {
             return this.#replace(intent, context);
         }
         const candidates = await this.candidates();
-        if (candidates.candidateSetId !== input.candidateSetId) {
+        if (!input.selectedTarget && candidates.candidateSetId !== input.candidateSetId) {
             throw new WorkHubActionGateFailure('candidate_set_stale', 'WorkHub Session candidates changed; refresh before delegating');
         }
-        const target = candidates.candidates.find((candidate) => candidate.candidateRef === proposal.candidateRef);
+        const target = candidates.candidates.find((candidate) => input.selectedTarget
+            ? candidate.sessionId === input.selectedTarget.sessionId &&
+                digest(candidate.workspace) === input.selectedTarget.workspaceDigest
+            : candidate.candidateRef === proposal.candidateRef);
         if (!target) {
-            throw new WorkHubActionGateFailure('candidate_unavailable', 'WorkHub target is not in the admitted candidate set');
+            throw new WorkHubActionGateFailure(input.selectedTarget ? 'candidate_set_stale' : 'candidate_unavailable', 'WorkHub target is no longer in the offered workspace');
         }
         this.#assertTarget(target);
-        return this.#assign(delegationAssignment(input, fingerprint, target.sessionId, target.sessionName), context);
+        return this.#assign({
+            ...delegationAssignment(input, fingerprint, target.sessionId, target.sessionName),
+            ...(input.selectedTarget
+                ? {
+                    validateFreshTarget: async () => {
+                        const fresh = (await this.candidates()).candidates.find((candidate) => candidate.sessionId === input.selectedTarget.sessionId &&
+                            digest(candidate.workspace) === input.selectedTarget.workspaceDigest);
+                        if (!fresh)
+                            throw new WorkHubActionGateFailure('candidate_set_stale', 'The selected work changed before admission');
+                        this.#assertTarget(fresh);
+                    },
+                }
+                : {}),
+        }, context);
     }
     /**
      * The delegation a stop names, by the only two keys that can name it.
@@ -639,6 +655,7 @@ function digest(value) {
 }
 function actionFingerprint(input) {
     const common = {
+        ...(input.selectedTarget ? { selectedTarget: input.selectedTarget } : {}),
         userText: input.userText,
         ...(input.attachments ? { attachments: input.attachments } : {}),
         ...(input.newWorkDefaults ? { newWorkDefaults: input.newWorkDefaults } : {}),

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

@@ -24,6 +24,7 @@ import { normalizeMessageContent } from '@maka/core/events';
 import { WORKHUB_COORDINATION_SESSION_ID, WORKHUB_COORDINATION_SESSION_ROLE, WORKHUB_COORDINATION_REPLACEMENT_SCHEMA_VERSION, WORKHUB_COORDINATION_STOP_SCHEMA_VERSION, isWorkHubCoordinationSession, isWorkHubCoordinationSessionId, } from '@maka/core/session';
 import { WORKHUB_COORDINATION_TEXT_MAX_BYTES } from '../protocol/index.js';
 import { SessionOperationFailure, projectSessionCatalogRecord, } from './session-catalog-coordinator.js';
+import { RuntimeInteractionAdmissionRejectedError, RuntimeInteractionFailStopError, } from '@maka/runtime/interaction-authority';
 import { WorkHubActionEffectFailure, WorkHubActionGateFailure, WorkHubCoordinationActionGate, } from './workhub-coordination-action-gate.js';
 const CREATE_FINGERPRINT = `sha256:${createHash('sha256')
     .update('maka:workhub-coordination-session:v1', 'utf8')
@@ -44,7 +45,9 @@ export const WORKHUB_ROUTING_HISTORY_MAX_MESSAGES = 32;
 export const WORKHUB_ROUTING_HISTORY_MAX_STORED_BYTES = 64 * 1024;
 /** Resolves the one durable Coordination Session owned by this Runtime Host. */
 export class HostWorkHubCoordinationCoordinator {
+    #requestForm;
     handlers = {
+        'workhub.coordination.selectAndDelegate': (input, context) => this.#selectAndDelegate(input, context),
         'workhub.coordination.resolve': () => this.#resolve(),
         'workhub.coordination.query': () => this.#query(),
         'workhub.coordination.configureModel': (input) => this.#configureModel(input),
@@ -65,6 +68,7 @@ export class HostWorkHubCoordinationCoordinator {
     #routingModel;
     #readDelegationRetirement;
     constructor(options) {
+        this.#requestForm = options.requestForm;
         this.#configureModel = options.configureModel;
         this.#routingModel = options.routingModel;
         this.#transitionConfiguration = options.transitionConfiguration;
@@ -332,7 +336,146 @@ export class HostWorkHubCoordinationCoordinator {
             };
         }
     }
-    async #actFromTurn(input, context) {
+    async #selectAndDelegate(input, context) {
+        try {
+            const authority = await this.#executions.readActiveWorkHubRoutingRequest(input.turnId);
+            if (!authority || authority.decision || !this.#requestForm) {
+                return {
+                    ok: false,
+                    error: {
+                        code: 'operation_conflict',
+                        message: 'Target selection requires an active, unbound Coordination Turn',
+                    },
+                };
+            }
+            // The interaction identity binds the complete operation and original user authority.
+            // Its durable answer can be replayed without rebuilding (or interpreting) the offer.
+            const requestId = createHash('sha256')
+                .update(JSON.stringify({
+                input,
+                runId: authority.runId,
+                content: authority.content,
+            }))
+                .digest('hex');
+            const choice = await this.#requestForm({
+                sessionId: WORKHUB_COORDINATION_SESSION_ID,
+                turnId: input.turnId,
+                runId: authority.runId,
+                requestId,
+                create: async () => {
+                    if (await this.#stores.readWorkHubAssignment(input.actionId)) {
+                        throw new WorkHubActionGateFailure('action_conflict', 'This action identity already belongs to another selection');
+                    }
+                    const page = await this.#actionGate.candidates();
+                    if (page.candidateSetId !== input.candidateSetId) {
+                        throw new WorkHubActionGateFailure('candidate_set_stale', 'Discover fresh candidates before requesting a target choice');
+                    }
+                    const options = input.candidateRefs.map((ref) => {
+                        const candidate = page.candidates.find((item) => item.candidateRef === ref);
+                        if (!candidate)
+                            throw new WorkHubActionGateFailure('candidate_unavailable', 'Target choice contains an unavailable candidate');
+                        // Keep labels inside the shared form wire budget; identity is the opaque value.
+                        const label = `${candidate.sessionName} — ${candidate.workspace.hostCwd}`;
+                        let bounded = '';
+                        for (const character of label) {
+                            if (Buffer.byteLength(bounded + character, 'utf8') > 190)
+                                break;
+                            bounded += character;
+                        }
+                        return {
+                            // An opaque, durable binding: only an exact offered value is accepted by
+                            // the form authority. Names and model-written answers never resolve identity.
+                            value: JSON.stringify([ref, candidate.sessionId, digest(candidate.workspace)]),
+                            label: page.candidates.some((other) => other.sessionId !== candidate.sessionId &&
+                                other.sessionName === candidate.sessionName &&
+                                other.workspace.hostCwd === candidate.workspace.hostCwd)
+                                ? `${bounded} [${candidate.sessionId.slice(0, 12)}]`
+                                : bounded,
+                        };
+                    });
+                    return {
+                        kind: 'form',
+                        toolUseId: input.actionId,
+                        message: 'Choose the work to continue',
+                        requester: { name: 'WorkHub' },
+                        fields: [
+                            {
+                                kind: 'single_select',
+                                name: 'target',
+                                label: 'Work / Workspace',
+                                required: true,
+                                options,
+                            },
+                        ],
+                    };
+                },
+            });
+            if (choice.answer.action !== 'accept')
+                return { ok: true, result: { kind: 'cancelled' } };
+            const value = choice.answer.values.target;
+            const binding = typeof value === 'string' ? JSON.parse(value) : undefined;
+            if (!Array.isArray(binding) ||
+                binding.length !== 3 ||
+                !binding.every((part) => typeof part === 'string') ||
+                !input.candidateRefs.includes(binding[0])) {
+                return {
+                    ok: false,
+                    error: {
+                        code: 'operation_conflict',
+                        message: 'Target choice does not belong to this operation',
+                    },
+                };
+            }
+            if (Date.now() - choice.createdAt > 10 * 60_000 &&
+                !(await this.#stores.readWorkHubAssignment(input.actionId))) {
+                return {
+                    ok: false,
+                    error: {
+                        code: 'candidate_set_stale',
+                        message: 'Target choice expired; discover candidates and ask again',
+                    },
+                };
+            }
+            const [offeredRef, sessionId, workspaceDigest] = binding;
+            const freshAuthority = await this.#executions.readActiveWorkHubRoutingRequest(input.turnId);
+            if (freshAuthority?.runId !== authority.runId) {
+                return {
+                    ok: false,
+                    error: { code: 'operation_conflict', message: 'The selecting Run is no longer active' },
+                };
+            }
+            // Re-read active authority after waiting. The Gate performs fresh candidate validation
+            // and durable action replay before it admits any target execution.
+            const outcome = await this.#actFromTurn({
+                turnId: input.turnId,
+                actionId: input.actionId,
+                proposal: { disposition: 'delegate_existing', candidateRef: offeredRef },
+                candidateSetId: input.candidateSetId,
+                delegationText: input.delegationText,
+            }, context, { sessionId, workspaceDigest });
+            return outcome.ok
+                ? { ok: true, result: { kind: 'delegated', result: outcome.result } }
+                : outcome;
+        }
+        catch (error) {
+            if (error instanceof RuntimeInteractionFailStopError)
+                throw error;
+            return {
+                ok: false,
+                error: {
+                    code: error instanceof WorkHubActionGateFailure
+                        ? error.code === 'candidate_set_stale'
+                            ? 'candidate_set_stale'
+                            : 'operation_conflict'
+                        : error instanceof RuntimeInteractionAdmissionRejectedError
+                            ? 'operation_conflict'
+                            : 'persistence_failed',
+                    message: error instanceof Error ? error.message : 'Target selection is unavailable',
+                },
+            };
+        }
+    }
+    async #actFromTurn(input, context, selectedTarget) {
         let request;
         try {
             request = await this.#executions.readActiveWorkHubRoutingRequest(input.turnId);
@@ -372,6 +515,7 @@ export class HostWorkHubCoordinationCoordinator {
                 ok: true,
                 result: await this.#actionGate.act({
                     ...action,
+                    ...(selectedTarget ? { selectedTarget } : {}),
                     userText: request.content.text,
                     ...(carriesAttachments && request.content.attachments
                         ? { attachments: request.content.attachments }

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

@@ -24,7 +24,7 @@ import { assertNoReservedWorkspaceAuthorityAppend } from './runtime-event-author
 import { acquireOperationalStateDatabase, } from './operational-state-store.js';
 import { assertEvidenceReadBudget, measureEvidenceRows, } from './bounded-evidence.js';
 import { decodeSkillInvocationResult, } from '@maka/core/skill-invocation';
-import { aggregateMessageContents, decodeMessageContent, isCanonicalAttachmentRef, messageContentsEqual, } from '@maka/core/events';
+import { aggregateMessageContents, decodeMessageContent, hasMeaningfulMessageContent, isCanonicalAttachmentRef, messageContentsEqual, } from '@maka/core/events';
 import { decodeAgentGraphIntentClaim } from '@maka/core/agent-graph-control';
 import { MAX_ATTACHMENT_BYTES, MAX_ATTACHMENT_COUNT } from '@maka/core/attachments';
 import { MODEL_CALL_ATTEMPT_EVENT_TYPE } from '@maka/core/model-call-attempt';
@@ -1052,7 +1052,10 @@ function normalizeRootTurnMessageContent(value, description, maxAttachments) {
         }
         throw new Error(`Invalid ${description}`);
     }
-    if (normalized.text.length === 0 || (normalized.attachments?.length ?? 0) > maxAttachments) {
+    // Quote- or attachment-only input is meaningful (#4804): the text carrier
+    // alone no longer decides durability admission.
+    if (!hasMeaningfulMessageContent(normalized) ||
+        (normalized.attachments?.length ?? 0) > maxAttachments) {
         throw new Error(`Invalid ${description}`);
     }
     for (const [index, attachment] of (normalized.attachments ?? []).entries()) {

package/node_modules/@maka/storage/dist/execution-stores.js

@@ -229,6 +229,7 @@ async function createExecutionStoresForWrite(lease, kind, extension) {
             readRuntimeEventsBounded: (sessionId, runId, budget) => run(() => runtimeEventStore.readRuntimeEventsBounded(sessionId, runId, budget)),
             readImmutableRuntimeEvents: (sessionId, runId) => run(() => runtimeEventStore.readImmutableRuntimeEvents(sessionId, runId)),
             readImmutableRuntimePrefix: (input) => run(() => runtimeEventStore.readImmutableRuntimePrefix(input)),
+            readImmutableRuntimePrefixProof: (input, budget) => run(() => runtimeEventStore.readImmutableRuntimePrefixProof(input, budget)),
             listSessionInvocations: (sessionId) => run(() => runtimeEventStore.listSessionInvocations(sessionId)),
             readRunInvocation: (sessionId, runId) => run(() => runtimeEventStore.readRunInvocation(sessionId, runId)),
             listSessionInvocationsBounded: (sessionId, limit) => run(() => runtimeEventStore.listSessionInvocationsBounded(sessionId, limit)),
@@ -238,7 +239,7 @@ async function createExecutionStoresForWrite(lease, kind, extension) {
             readSessionRuntimeEventEntries: (sessionId) => run(() => runtimeEventStore.readSessionRuntimeEventEntries(sessionId)),
             resequenceSessionEventOrdinals: (sessionId) => run(() => runtimeEventStore.resequenceSessionEventOrdinals(sessionId)),
             readTranscriptHighWater: (sessionId) => run(() => runtimeEventStore.readTranscriptHighWater(sessionId)),
-            readTranscriptInvocations: (sessionId, request) => run(() => runtimeEventStore.readTranscriptInvocations(sessionId, request)),
+            readTranscriptInvocations: (sessionId, request, project) => run(() => runtimeEventStore.readTranscriptInvocations(sessionId, request, project)),
             readTranscriptLandmarks: (sessionId, throughOrdinal, limit) => run(() => runtimeEventStore.readTranscriptLandmarks(sessionId, throughOrdinal, limit)),
             claimContinuation: (input) => run(() => runtimeEventStore.claimContinuation(input)),
             readContinuationClaimByBoundary: (boundaryDigest) => run(() => runtimeEventStore.readContinuationClaimByBoundary(boundaryDigest)),

package/node_modules/@maka/storage/dist/runtime-transcript-query.js

@@ -107,9 +107,12 @@ export class RuntimeTranscriptQuery {
         });
         return row?.last ?? null;
     }
-    invocations(sessionId, request) {
+    invocations(sessionId, request, project) {
         assertOrdinal(request.throughOrdinal);
         assertOrdinal(request.position);
+        assertReadLimit(request.maxEvents, 'event count');
+        assertReadLimit(request.maxBytes, 'byte');
+        assertReadLimit(request.maxRecordBytes, 'record byte');
         if (request.direction !== 'older' && request.direction !== 'newer') {
             throw new Error('Invalid transcript direction');
         }
@@ -130,12 +133,11 @@ export class RuntimeTranscriptQuery {
                 throughOrdinal: request.throughOrdinal,
                 limit: request.limit,
             }).sort((a, b) => a.first - b.first);
-        return rows.map((row) => ({
+        return rows.map((row) => project({
             invocation: this.invocation(sessionId, row.invocation_id),
             firstOrdinal: row.first,
             lastOrdinal: row.last,
-            events: this.events(row.invocation_id, request),
-        }));
+        }, this.events(row.invocation_id, request)));
     }
     landmarks(sessionId, throughOrdinal, limit) {
         assertOrdinal(throughOrdinal);
@@ -258,29 +260,35 @@ export class RuntimeTranscriptQuery {
             limit: bounds.limit,
         });
     }
-    events(invocationId, limits) {
-        // Walked row by row: the limits cap what one Turn may pull into memory, so
-        // a check after `.all()` has already paid the cost it was meant to refuse.
+    *events(invocationId, limits) {
+        // Walked row by row so cumulative limits apply to raw IO without retaining
+        // the Turn. SQLite withholds an oversized payload before it crosses into JS.
         const cursor = this.db
             .prepare(`
-      SELECT o.ordinal, e.event_id, e.session_id, e.invocation_id, e.run_id, e.turn_id, e.payload_json
+      SELECT o.ordinal, e.event_id, e.session_id, e.invocation_id, e.run_id, e.turn_id,
+        length(CAST(e.payload_json AS BLOB)) AS stored_bytes,
+        CASE WHEN length(CAST(e.payload_json AS BLOB)) <= ? THEN e.payload_json END AS payload_json
       FROM runtime_events e JOIN runtime_session_event_ordinals o ON o.event_id = e.event_id
       WHERE e.invocation_id = ? ORDER BY e.event_seq
     `)
-            .iterate(invocationId);
-        const events = [];
+            .iterate(limits.maxRecordBytes, invocationId);
+        let count = 0;
         let bytes = 0;
         for (const row of cursor) {
-            if (events.length === limits.maxEvents) {
+            if (count === limits.maxEvents) {
                 throw new RuntimeTranscriptOversizedTurnError(`Turn ${invocationId} holds more RuntimeEvents than a transcript page may read`);
             }
-            bytes += Buffer.byteLength(row.payload_json);
+            const payload = row.payload_json;
+            if (payload === null) {
+                throw new RuntimeTranscriptOversizedTurnError(`Turn ${invocationId} holds a RuntimeEvent larger than a transcript page may read`);
+            }
+            bytes += row.stored_bytes;
             if (bytes > limits.maxBytes) {
                 throw new RuntimeTranscriptOversizedTurnError(`Turn ${invocationId} holds more RuntimeEvent bytes than a transcript page may read`);
             }
-            events.push({ ordinal: row.ordinal, event: decodeStoredEvent(row) });
+            count += 1;
+            yield { ordinal: row.ordinal, event: decodeStoredEvent({ ...row, payload_json: payload }) };
         }
-        return events;
     }
     event(id) {
         const row = this.db
@@ -306,3 +314,8 @@ function assertOrdinal(value) {
     if (!Number.isSafeInteger(value) || value < 0)
         throw new Error('Invalid transcript event ordinal');
 }
+function assertReadLimit(value, name) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new RangeError(`Invalid transcript ${name} limit`);
+    }
+}