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

package/dist/acp/stdio-server.js

@@ -18,6 +18,7 @@
  */
 import { Readable, Writable } from 'node:stream';
 import { ndJsonStream } from '@agentclientprotocol/sdk';
+import { isRuntimeHostReconnectingConnection, } from '@maka/runtime-host/client';
 import { createMakaAcpAgent } from './maka-acp-agent.js';
 import { AcpSessionRegistry } from './session-registry.js';
 import { connectRuntimeHostCliConnection } from '../runtime-host-cli-context.js';
@@ -29,8 +30,16 @@ export async function runMakaAcpStdioServer(input, dependencies = {}) {
                 clientDataRoot: input.clientDataRoot,
                 signal,
             });
+            const connection = context.connection;
+            if (!isRuntimeHostReconnectingConnection(connection)) {
+                await context.close().catch(() => undefined);
+                throw new Error('ACP requires a reconnecting Runtime Host connection');
+            }
             return {
-                request: context.connection.request.bind(context.connection),
+                reconnecting: true,
+                request: connection.request.bind(connection),
+                openSessionSubscription: connection.openSessionSubscription.bind(connection),
+                openSessionSubscriptionOnce: connection.openSessionSubscriptionOnce.bind(connection),
                 close: () => context.close(),
             };
         },

package/dist/cli-core.js

@@ -101,7 +101,7 @@ function helpText(cliCommand) {
         'Commands:',
         ...[
             ['', 'Start the TUI'],
-            ['--acp', 'Serve ACP v1 over stdio (initialize, session/new, session/list)'],
+            ['--acp', 'Serve ACP v1 over stdio (sessions, prompts, streaming, cancellation)'],
             ['run ...', 'Run one non-interactive model turn'],
             ['-p ...', `Alias for ${cliCommand} run`],
             ['activate ...', 'Run one Cloud Session activation and emit JSONL'],

package/dist/pi-transcript-tools.js

@@ -378,11 +378,12 @@ function readInputRef(entry) {
 }
 /** A Read using the filesystem branch. */
 function isFilesystemReadPath(entry) {
-    return readInputPath(entry) !== undefined;
+    const path = readInputPath(entry);
+    return path !== undefined && !path.startsWith('maka:');
 }
 /** A Read using the runtime-resource branch (background-task output, etc.). */
 function isRuntimeResourceRead(entry) {
-    return readInputRef(entry)?.startsWith('maka://runtime/') ?? false;
+    return (readInputPath(entry) ?? readInputRef(entry))?.startsWith('maka:') ?? false;
 }
 /**
  * True only for the result shapes a filesystem Read uses to carry actual file

package/dist/pi-transcript.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { Markdown, visibleWidth } from '@earendil-works/pi-tui';
+import { resolveReadInput } from '@maka/runtime/read-page';
 import { deriveTurnRecords, isRuntimeSystemNoteKind, STEP_LIMIT_NOTICE_TEXT, } from '@maka/core/session';
 import { providerRetryDisplaySeconds } from '@maka/core/provider-retry-countdown';
 import { defineUiMessageCatalog, resolveUiMessageCatalog, } from '@maka/core/ui-locale';
@@ -1578,8 +1579,17 @@ function findShellRunParent(state, ref, childToolUseId) {
 }
 /** The runtime-resource ref a tool call is aimed at, when the args carry one. */
 function readArgsRef(args) {
-    const ref = args !== null && typeof args === 'object' ? args.ref : undefined;
-    return typeof ref === 'string' && ref.length > 0 ? ref : undefined;
+    const ref = args !== null && typeof args === 'object'
+        ? (args.path ?? args.ref)
+        : undefined;
+    if (typeof ref !== 'string' || !ref)
+        return undefined;
+    try {
+        return resolveReadInput({ path: ref }).path;
+    }
+    catch {
+        return undefined;
+    }
 }
 /**
  * A card whose run resource is still `running`. The transition is keyed on the

package/dist/runtime-host-session-channel.js

@@ -59,6 +59,8 @@ export class RuntimeHostSessionChannel {
     #activated = false;
     #startedTurnBarrier;
     #closing = false;
+    #closeController = new AbortController();
+    #closeTask;
     #failure;
     #recoveryTask;
     #recoveryAttemptsWithoutLiveFrame = 0;
@@ -93,18 +95,27 @@ export class RuntimeHostSessionChannel {
         });
     }
     static async open(options) {
-        const subscription = await options.connection.openSessionSubscription({
+        const openInitial = options.openInitialSessionSubscription ??
+            options.connection.openSessionSubscription.bind(options.connection);
+        const subscription = await runChannelOperation(() => openInitial({
             sessionId: options.sessionId,
             transcript: {
                 kind: 'tail',
                 maxBytes: SESSION_TRANSCRIPT_BOOTSTRAP_MAX_BYTES,
             },
-        });
+        }), options.signal, (lateSubscription) => lateSubscription.close());
         const initialRoot = structuredClone(subscription.snapshot.rootTurn);
         const channel = new RuntimeHostSessionChannel(subscription, [], options, options.connection);
+        const onAbort = () => {
+            void channel.close().catch(() => undefined);
+        };
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        if (options.signal?.aborted)
+            onAbort();
         void channel.#pump(subscription);
         try {
             const recovered = await channel.#hydrateInitial(subscription);
+            options.signal?.throwIfAborted();
             const root = recovered ? structuredClone(channel.snapshot.rootTurn) : initialRoot;
             return {
                 channel,
@@ -117,11 +128,15 @@ export class RuntimeHostSessionChannel {
             await channel.close().catch(() => undefined);
             throw error;
         }
+        finally {
+            options.signal?.removeEventListener('abort', onAbort);
+        }
     }
     async #hydrateInitial(subscription) {
         let messages;
         try {
-            messages = await subscription.loadTranscript(decodeStoredMessage);
+            messages = await runChannelOperation(() => subscription.loadTranscript(decodeStoredMessage), this.#closeController.signal);
+            this.#closeController.signal.throwIfAborted();
         }
         catch (error) {
             if (!this.#canRecover(error))
@@ -242,10 +257,13 @@ export class RuntimeHostSessionChannel {
             });
         }
     }
-    async close() {
-        if (this.#closing)
-            return;
+    close() {
+        this.#closeTask ??= this.#close();
+        return this.#closeTask;
+    }
+    async #close() {
         this.#closing = true;
+        this.#closeController.abort(new Error('Runtime Host Session channel is closed'));
         this.#clearRecoveryStableTimer();
         this.#recoveryAwaitingLiveFrame = undefined;
         this.#pendingStartedTurns.clear();
@@ -337,13 +355,13 @@ export class RuntimeHostSessionChannel {
                 return;
             let replacement;
             try {
-                replacement = await this.#connection.openSessionSubscription({
+                replacement = await runChannelOperation(() => this.#connection.openSessionSubscription({
                     sessionId: this.sessionId,
                     transcript: {
                         kind: 'tail',
                         maxBytes: SESSION_TRANSCRIPT_BOOTSTRAP_MAX_BYTES,
                     },
-                });
+                }), this.#closeController.signal, (lateSubscription) => lateSubscription.close());
             }
             catch (error) {
                 if (this.#canRecover(error))
@@ -360,7 +378,7 @@ export class RuntimeHostSessionChannel {
             this.#pendingFrames.length = 0;
             void this.#pump(replacement);
             try {
-                const messages = await replacement.loadTranscript(decodeStoredMessage);
+                const messages = await runChannelOperation(() => replacement.loadTranscript(decodeStoredMessage), this.#closeController.signal);
                 if (this.#failedSubscriptions.has(replacement)) {
                     throw new RuntimeHostSubscriptionError('connection_closed', 'Runtime Host Session subscription closed during catch-up');
                 }
@@ -759,6 +777,42 @@ function isGuaranteedOutcome(event) {
 function isTurnTerminalOutcome(event) {
     return event.type === 'complete' || event.type === 'abort' || event.type === 'error';
 }
+function runChannelOperation(operation, signal, discard) {
+    if (!signal)
+        return operation();
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        let aborted = false;
+        const onAbort = () => {
+            aborted = true;
+            signal.removeEventListener('abort', onAbort);
+            reject(signal.reason);
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        let running;
+        try {
+            running = operation();
+        }
+        catch (error) {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+            return;
+        }
+        void running.then((value) => {
+            signal.removeEventListener('abort', onAbort);
+            // The connection may finish opening after this channel has gone away.
+            // A late subscription still belongs to the operation and must be closed.
+            if (aborted)
+                void discard?.(value).catch(() => undefined);
+            else
+                resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
 /**
  * Goal identity + revision: GoalManager.commit bumps the revision on every
  * accepted transition, so this pair detects every set/settle/pause/resume/

package/node_modules/@maka/core/dist/artifacts.js

@@ -96,6 +96,12 @@ const CHILD_RESULT_OUTPUT_SOURCES = new Set([
     'deep_research',
 ]);
 export function isArtifactUserVisible(record) {
+    // A directly written HTML file is an intentional user-facing deliverable:
+    // the Artifact Pane must be able to preview and open it without requiring a
+    // child-workspace writeback. Other tool results remain internal to avoid
+    // flooding the Generated Files tab with command output and diffs.
+    if (record.source === 'tool_result' && record.kind === 'html')
+        return true;
     return ARTIFACT_SOURCE_POLICIES[record.source].userVisible;
 }
 /** Visibility does not grant permission to destroy evidence owned by a runtime workflow. */

package/node_modules/@maka/core/dist/attachments.js

@@ -251,6 +251,11 @@ export function attachmentKindFromMimeType(mimeType, fileName) {
     }
     return 'other';
 }
-export function attachmentIngestBlocked(code) {
-    return new Error(`attachment_ingest:${code}`);
+export class AttachmentIngestBlockedError extends Error {
+    code;
+    constructor(code) {
+        super('Attachment ingest was blocked');
+        this.code = code;
+        this.name = 'AttachmentIngestBlockedError';
+    }
 }

package/node_modules/@maka/core/dist/durable-tool-result-projection.js

@@ -21,7 +21,9 @@ import { isCanonicalArtifactEntityId, normalizeArtifactImagePreviewMime } from '
 import { hasExactShape, isRecord } from './record-schema.js';
 import { serializedByteLength } from './serialized-byte-length.js';
 export const DURABLE_TOOL_RESULT_PROJECTION_VERSION = 1;
-export const DURABLE_TOOL_RESULT_PROJECTION_MAX_BYTES = 256 * 1024;
+// Storage capacity, not a provider context budget. Two executor-retained Bash
+// streams can require 12 MiB after JSON escaping; Read bounds their presentation.
+export const DURABLE_TOOL_RESULT_PROJECTION_MAX_BYTES = 16 * 1024 * 1024;
 export const DURABLE_TOOL_RESULT_PROJECTION_MAX_PARTS = 64;
 export const DURABLE_TOOL_RESULT_PROJECTION_MAX_JSON_DEPTH = 32;
 export const DURABLE_TOOL_RESULT_PROJECTION_MAX_JSON_NODES = 20_000;

package/node_modules/@maka/core/dist/events.js

@@ -57,6 +57,27 @@ export function isDirectoryReference(value) {
         isCanonicalAbsolutePath(value.path));
 }
 const MESSAGE_CONTENT_SHAPE = defineObjectShape()(['text'], ['displayText', 'attachments', 'directoryReferences', 'quotes', 'inlineReferences']);
+/**
+ * A Turn message is meaningful when at least one of its four content carriers
+ * is present: inline text, an inline excerpt, an attachment reference, or a
+ * directory reference. Admission, compaction estimates, replay visibility,
+ * and recap projection must share this one predicate (#4804) — restating it
+ * per layer is how a quote-only message ends up admitted by one boundary and
+ * silently dropped by the next.
+ *
+ * The inline text is deliberately NOT trimmed. Admission asks "is this frame
+ * legal"; replay visibility asks "will the model see this already-persisted
+ * event", and that answer must stay compatible with everything admission has
+ * ever accepted — trimming here retroactively re-reads stored history as
+ * invisible and blocks replay on it (#4815 review). Surfaces that want the
+ * trimmed judgement (the desktop guard) trim at their own boundary.
+ */
+export function hasMeaningfulMessageContent(content) {
+    return (content.text.length > 0 ||
+        (content.quotes?.length ?? 0) > 0 ||
+        (content.attachments?.length ?? 0) > 0 ||
+        (content.directoryReferences?.length ?? 0) > 0);
+}
 const ATTACHMENT_REF_SHAPE = defineObjectShape()(['kind', 'name', 'mimeType', 'bytes', 'ref'], []);
 const QUOTE_REF_SHAPE = defineObjectShape()(['text'], ['label', 'sourceTurnId']);
 const INLINE_REFERENCE_SHAPE = defineObjectShape()(['kind', 'value', 'label', 'start'], []);

package/node_modules/@maka/core/dist/goal.js

@@ -68,10 +68,14 @@ const GOAL_CONTROL_LEASE_SHAPE = defineObjectShape()(['goalId', 'generation'], [
 const GOAL_EXECUTION_REF_SHAPE = defineObjectShape()(['sessionId', 'turnId', 'runId'], []);
 const GOAL_CHECKPOINT_SHAPE = defineObjectShape()(['goalId', 'revision'], []);
 const GOAL_CURRENT_EXECUTION_SHAPE = defineObjectShape()(['execution', 'checkpoint', 'controlLease'], []);
-const GOAL_AUTHORITY_RECORD_SHAPE = defineObjectShape()(['schemaVersion', 'goal', 'controlLease', 'currentExecution'], []);
+const GOAL_PENDING_CONTINUATION_SHAPE = defineObjectShape()(['checkpoint', 'controlLease', 'prompt'], ['triggeringTurnId']);
+const GOAL_AUTHORITY_RECORD_SHAPE = defineObjectShape()(['schemaVersion', 'goal', 'controlLease', 'currentExecution', 'pendingContinuation'], []);
+const GOAL_AUTHORITY_RECORD_V1_SHAPE = defineObjectShape()(['schemaVersion', 'goal', 'controlLease', 'currentExecution'], []);
 const GOAL_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 export function decodeGoalAuthorityRecord(value) {
-    if (!isRecord(value) || !hasExactShape(value, GOAL_AUTHORITY_RECORD_SHAPE)) {
+    if (!isRecord(value) ||
+        (!hasExactShape(value, GOAL_AUTHORITY_RECORD_SHAPE) &&
+            !hasExactShape(value, GOAL_AUTHORITY_RECORD_V1_SHAPE))) {
         throw new TypeError('Invalid Goal authority record');
     }
     if (value.schemaVersion !== 1)
@@ -81,6 +85,12 @@ export function decodeGoalAuthorityRecord(value) {
     const currentExecution = value.currentExecution === null
         ? null
         : decodeGoalCurrentExecution(value.currentExecution, goal, controlLease);
+    const pendingContinuation = value.pendingContinuation === undefined || value.pendingContinuation === null
+        ? null
+        : decodeGoalPendingContinuation(value.pendingContinuation, goal, controlLease);
+    if (currentExecution && pendingContinuation) {
+        throw new TypeError('Goal authority cannot have current and pending execution together');
+    }
     if (controlLease.goalId !== goal.id) {
         throw new TypeError('Goal control lease does not match Goal identity');
     }
@@ -89,6 +99,30 @@ export function decodeGoalAuthorityRecord(value) {
         goal,
         controlLease,
         currentExecution,
+        pendingContinuation,
+    });
+}
+function decodeGoalPendingContinuation(value, goal, authorityLease) {
+    if (!isRecord(value) || !hasExactShape(value, GOAL_PENDING_CONTINUATION_SHAPE)) {
+        throw new TypeError('Invalid Goal pending continuation');
+    }
+    const checkpoint = decodeGoalCheckpoint(value.checkpoint);
+    const controlLease = decodeGoalControlLease(value.controlLease);
+    if (checkpoint.goalId !== goal.id ||
+        checkpoint.revision !== goal.revision ||
+        controlLease.goalId !== authorityLease.goalId ||
+        controlLease.generation !== authorityLease.generation ||
+        typeof value.prompt !== 'string' ||
+        !value.prompt.trim() ||
+        !isGoalTextWithinLimit(value.prompt, GOAL_PENDING_PROMPT_TEXT_LIMIT) ||
+        !isOptionalGoalId(value.triggeringTurnId)) {
+        throw new TypeError('Goal pending continuation does not match Goal authority');
+    }
+    return Object.freeze({
+        checkpoint,
+        controlLease,
+        prompt: value.prompt,
+        ...(value.triggeringTurnId !== undefined ? { triggeringTurnId: value.triggeringTurnId } : {}),
     });
 }
 function decodeGoalState(value) {
@@ -166,6 +200,9 @@ function decodeGoalExecutionRef(value) {
 function isGoalId(value) {
     return typeof value === 'string' && GOAL_ID_PATTERN.test(value);
 }
+function isOptionalGoalId(value) {
+    return value === undefined || isGoalId(value);
+}
 function isNonnegativeInteger(value) {
     return Number.isSafeInteger(value) && value >= 0;
 }
@@ -206,3 +243,8 @@ export const GOAL_REASON_TEXT_LIMIT = Object.freeze({
     codeUnits: 500,
     utf8Bytes: 1_500,
 });
+/** Durable continuation prompts include bounded evaluator and Goal context. */
+export const GOAL_PENDING_PROMPT_TEXT_LIMIT = Object.freeze({
+    codeUnits: 4_000,
+    utf8Bytes: 12_000,
+});

package/node_modules/@maka/core/dist/permission.js

@@ -77,7 +77,6 @@ export function isToolCategory(value) {
 export const BUILTIN_TOOL_CATEGORY = {
     // read
     Read: 'read',
-    ArchiveRead: 'read',
     search_files: 'read',
     Grep: 'read',
     Glob: 'read',

package/node_modules/@maka/core/dist/runtime-boundary.js

@@ -22,30 +22,30 @@ import { isRecord } from './record-schema.js';
 import { decodeRuntimeInvocationOpened, TOOL_BOUNDARY_PROTOCOL_V1 } from './runtime-event.js';
 import { stableJsonStringify } from './tool-args-identity.js';
 export function buildImmutableRuntimePrefix(identity, rows) {
-    const canonicalRows = canonicalizePrefixRows(identity, rows);
-    const last = canonicalRows.at(-1);
-    if (!last)
-        throw new Error('immutable RuntimeEvent prefix is empty');
+    const events = [];
+    const proof = foldImmutableRuntimePrefix(identity, rows, (event) => events.push(event));
     return {
         protocol: 'immutable_runtime_prefix_v1',
-        identity: { ...identity },
-        position: {
-            lastEventSeq: last.eventSeq,
-            eventCount: canonicalRows.length,
-            lastEventId: last.event.id,
-        },
-        prefixDigest: digestCanonicalRuntimePrefix(identity, canonicalRows),
-        events: canonicalRows.map((row) => row.event),
+        identity: proof.identity,
+        position: proof.position,
+        prefixDigest: proof.prefixDigest,
+        events,
     };
 }
+export function buildImmutableRuntimePrefixProof(identity, rows) {
+    return foldImmutableRuntimePrefix(identity, rows);
+}
 export function digestRuntimePrefix(identity, rows) {
-    return digestCanonicalRuntimePrefix(identity, canonicalizePrefixRows(identity, rows));
+    return foldImmutableRuntimePrefix(identity, rows).prefixDigest;
 }
 export function runtimePrefixSegment(prefix) {
-    if (prefix.protocol !== 'immutable_runtime_prefix_v1') {
+    if (prefix.protocol !== 'immutable_runtime_prefix_v1' &&
+        prefix.protocol !== 'immutable_runtime_prefix_proof_v1') {
         throw new Error('Invalid immutable RuntimeEvent prefix protocol');
     }
-    const rebuilt = buildImmutableRuntimePrefix(prefix.identity, prefix.events.map((event, index) => ({ eventSeq: index + 1, event })));
+    const rebuilt = prefix.protocol === 'immutable_runtime_prefix_v1'
+        ? buildImmutableRuntimePrefix(prefix.identity, prefix.events.map((event, index) => ({ eventSeq: index + 1, event })))
+        : validateImmutableRuntimePrefixProof(prefix);
     if (stableJsonStringify(rebuilt.position) !== stableJsonStringify(prefix.position)) {
         throw new Error('Immutable RuntimeEvent prefix position mismatch');
     }
@@ -290,11 +290,16 @@ startKind) {
                 prefixDigest: source.prefixDigest,
             }));
 }
-function canonicalizePrefixRows(identity, rows) {
+function foldImmutableRuntimePrefix(identity, rows, visit) {
     const canonicalIdentity = decodePrefixIdentity(identity);
-    const canonicalRows = [];
-    for (const [index, row] of rows.entries()) {
-        const expectedEventSeq = index + 1;
+    const hash = nodeCrypto.createHash('sha256');
+    updateLengthPrefixed(hash, Buffer.from('maka.runtime-prefix.v1', 'utf8'));
+    updateLengthPrefixed(hash, Buffer.from(stableJsonStringify(canonicalIdentity), 'utf8'));
+    let eventCount = 0;
+    let firstEvent;
+    let lastEvent;
+    for (const row of rows) {
+        const expectedEventSeq = eventCount + 1;
         if (!Number.isSafeInteger(row.eventSeq) ||
             row.eventSeq <= 0 ||
             row.eventSeq !== expectedEventSeq) {
@@ -310,19 +315,58 @@ function canonicalizePrefixRows(identity, rows) {
             event.turnId !== canonicalIdentity.turnId) {
             throw new Error(`immutable RuntimeEvent identity mismatch for ${event.id}`);
         }
-        canonicalRows.push({ eventSeq: row.eventSeq, event });
+        hash.update(uint64be(row.eventSeq));
+        updateLengthPrefixed(hash, Buffer.from(encodeRuntimePrefixV1Event(event), 'utf8'));
+        firstEvent ??= event;
+        lastEvent = event;
+        eventCount += 1;
+        visit?.(event);
     }
-    return canonicalRows;
+    if (!firstEvent || !lastEvent)
+        throw new Error('immutable RuntimeEvent prefix is empty');
+    return {
+        protocol: 'immutable_runtime_prefix_proof_v1',
+        identity: canonicalIdentity,
+        position: {
+            lastEventSeq: eventCount,
+            eventCount,
+            lastEventId: lastEvent.id,
+        },
+        prefixDigest: `sha256:${hash.digest('hex')}`,
+        firstEvent,
+        lastEvent,
+    };
 }
-function digestCanonicalRuntimePrefix(identity, rows) {
-    const hash = nodeCrypto.createHash('sha256');
-    updateLengthPrefixed(hash, Buffer.from('maka.runtime-prefix.v1', 'utf8'));
-    updateLengthPrefixed(hash, Buffer.from(stableJsonStringify(identity), 'utf8'));
-    for (const row of rows) {
-        hash.update(uint64be(row.eventSeq));
-        updateLengthPrefixed(hash, Buffer.from(encodeRuntimePrefixV1Event(row.event), 'utf8'));
+function validateImmutableRuntimePrefixProof(proof) {
+    const identity = decodePrefixIdentity(proof.identity);
+    const position = decodePrefixPosition(proof.position);
+    const prefixDigest = decodeBoundaryDigest(proof.prefixDigest);
+    const firstEvent = encodeCanonicalRuntimeEvent(proof.firstEvent).event;
+    const lastEvent = encodeCanonicalRuntimeEvent(proof.lastEvent).event;
+    for (const event of [firstEvent, lastEvent]) {
+        if (event.partial === true)
+            throw new Error('Immutable RuntimeEvent proof contains a partial endpoint');
+        if (event.sessionId !== identity.sessionId ||
+            event.invocationId !== identity.invocationId ||
+            event.runId !== identity.runId ||
+            event.turnId !== identity.turnId) {
+            throw new Error(`Immutable RuntimeEvent proof identity mismatch for ${event.id}`);
+        }
     }
-    return `sha256:${hash.digest('hex')}`;
+    if (position.lastEventId !== lastEvent.id) {
+        throw new Error('Immutable RuntimeEvent prefix position mismatch');
+    }
+    if (position.eventCount === 1 && firstEvent.id !== lastEvent.id) {
+        throw new Error('Immutable RuntimeEvent proof endpoints mismatch');
+    }
+    return {
+        protocol: 'immutable_runtime_prefix_proof_v1',
+        identity,
+        position,
+        prefixDigest,
+        firstEvent,
+        lastEvent,
+    };
 }
 function encodeRuntimePrefixV1Event(event) {
     const canonical = encodeCanonicalRuntimeEvent(event);

package/node_modules/@maka/core/dist/runtime-event.js

@@ -34,7 +34,7 @@
 import { isWorkHubActionReceipt } from './workhub-action-result.js';
 import { isModelRetryDecision } from './model-failure.js';
 import { isRuntimeHandoffPause, runtimeHandoffPause, } from './runtime-handoff.js';
-import { isMessageContent, normalizeMessageContent, } from './events.js';
+import { hasMeaningfulMessageContent, isMessageContent, normalizeMessageContent, } from './events.js';
 import { INTERACTION_ID_MAX_BYTES, INTERACTION_TOOL_NAME_MAX_BYTES, decodeInteractionRequest, } from './interaction.js';
 import { isPermissionMode, } from './permission.js';
 import { isCollaborationMode } from './collaboration.js';
@@ -818,7 +818,10 @@ export function isPartialRuntimeEvent(event) {
 /**
  * True if the event carries content whose kind is eligible for model
  * history projection: text, thinking, function_call, or function_response.
- * Error-only content and pure action/refs events are NOT model-visible.
+ * A user-authored text event with structured context (quotes or attachments)
+ * is model-visible even when the inline text is empty — the structured part
+ * is what carries the turn (#4804). Error-only content and pure action/refs
+ * events are NOT model-visible.
  *
  * This is a content-kind check only. Callers still apply `partial`
  * filtering (partial chunks are never replayed into the next model call).
@@ -831,7 +834,7 @@ export function runtimeEventHasModelVisibleContent(event) {
         return false;
     switch (content.kind) {
         case 'text':
-            return content.text.length > 0;
+            return hasMeaningfulMessageContent(content);
         case 'thinking':
         case 'function_call':
         case 'function_response':

package/node_modules/@maka/core/dist/runtime-handoff.js

@@ -69,15 +69,23 @@ export function runtimeHandoffPause(event) {
 }
 /** Verify against source facts, not the proposed claim's description of them. */
 export function assertHandoffClaimSource(claim, prefix) {
-    const last = prefix.events.at(-1);
+    const first = prefix.protocol === 'immutable_runtime_prefix_v1' ? prefix.events[0] : prefix.firstEvent;
+    const last = prefix.protocol === 'immutable_runtime_prefix_v1' ? prefix.events.at(-1) : prefix.lastEvent;
     const pause = last && runtimeHandoffPause(last);
     const source = claim.targetOpening.source;
+    const claimedPrefix = claim.boundary.segments.at(-1);
+    if (!claimedPrefix ||
+        claimedPrefix.prefixDigest !== prefix.prefixDigest ||
+        stableJsonStringify(claimedPrefix.identity) !== stableJsonStringify(prefix.identity) ||
+        stableJsonStringify(claimedPrefix.position) !== stableJsonStringify(prefix.position)) {
+        throw new Error('Handoff claim does not preserve the sealed source prefix');
+    }
     if (source.kind !== 'handoff') {
         if (pause)
             throw new Error('A handoff pause is reserved for its authorized successor');
         return;
     }
-    const opening = prefix.events[0]?.content;
+    const opening = first?.content;
     if (!pause ||
         opening?.kind !== 'invocation_opened' ||
         prefix.identity.sessionId !== claim.target.sessionId ||