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

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

@@ -18,7 +18,7 @@
  */
 import { isRuntimeSystemNoteKind } from '@maka/core/session';
 import { createRuntimeEventId } from '@maka/core/runtime-event';
-export const RUNTIME_EVENT_BACKFILL_STATE_KEY = 'makaRuntimeRecovery';
+const RUNTIME_EVENT_BACKFILL_STATE_KEY = 'makaRuntimeRecovery';
 export function backfillRuntimeEventsFromStoredMessages(input) {
     const newId = input.newId ?? (() => createRuntimeEventId('rt-backfill'));
     const now = input.now ?? (() => Date.now());

package/node_modules/@maka/runtime/dist/runtime-event-read-model.js

@@ -53,13 +53,27 @@ export function isContinuationStartRuntimeEvent(event) {
     return (event.actions?.stateDelta?.continuationStart === true ||
         event.actions?.continuationStart !== undefined);
 }
+export function projectRuntimeEventCoordinationReceipt(event) {
+    if (!event.actions?.coordination)
+        return undefined;
+    return {
+        type: 'workhub_coordination',
+        kind: 'action_receipt',
+        schemaVersion: 1,
+        id: event.id,
+        turnId: event.turnId,
+        ts: event.ts,
+        receipt: event.actions.coordination,
+    };
+}
 /**
  * Whether the event can affect the StoredMessage projection or the state needed
  * to construct one. Pure control-plane facts are intentionally absent so a
  * transcript reader can stream past them without retaining the whole ledger.
  */
 export function affectsRuntimeEventStoredMessageProjection(event) {
-    return (event.content !== undefined ||
+    return (event.actions?.coordination !== undefined ||
+        event.content !== undefined ||
         isTerminalRuntimeEvent(event) ||
         event.actions?.permissionRequest !== undefined ||
         event.actions?.permissionDecision !== undefined ||
@@ -143,6 +157,11 @@ export function projectRuntimeEventsToStoredMessages(events, options) {
                     break;
             }
         }
+        const coordinationReceipt = projectRuntimeEventCoordinationReceipt(event);
+        if (coordinationReceipt) {
+            messages.push(coordinationReceipt);
+            projected = true;
+        }
         if (event.actions?.permissionRequest) {
             const request = event.actions.permissionRequest;
             state.permissionRequestById.set(request.requestId, {
@@ -357,6 +376,7 @@ export function applyArchivedToolResultReadModelStatuses(events, archiveStatuses
                     toolCallId: placeholder.toolCallId,
                     toolName: placeholder.toolName,
                     artifactId: placeholder.artifactId,
+                    ...(placeholder.rewriteVersion === 2 ? { resourceRef: placeholder.resourceRef } : {}),
                     bodySha256: placeholder.bodySha256,
                     originalEstimatedTokens: placeholder.originalEstimatedTokens,
                     originalBytes: placeholder.originalBytes,
@@ -658,6 +678,9 @@ function projectFunctionResponse(event, state, messages) {
             toolName: archivedPlaceholder.toolName,
             artifactId: archivedPlaceholder.artifactId,
             bodySha256: archivedPlaceholder.bodySha256,
+            ...(archivedPlaceholder.rewriteVersion === 2
+                ? { resourceRef: archivedPlaceholder.resourceRef }
+                : {}),
             originalEstimatedTokens: archivedPlaceholder.originalEstimatedTokens,
             originalBytes: archivedPlaceholder.originalBytes,
             rewriteVersion: archivedPlaceholder.rewriteVersion,

package/node_modules/@maka/runtime/dist/runtime-kernel.js

@@ -530,6 +530,111 @@ export class RuntimeKernel {
             runId: continuation.runId,
         }, options, () => this.revalidateContinuationSafety(continuation), inheritedSandboxBoundaryDenied);
     }
+    /** Host coordination uses the same Run owner and terminal authority without a provider send. */
+    async *runCoordinationOperation(sessionId, input, options, execute) {
+        const execution = this.takeExecutionClaim(sessionId);
+        execution.hostOperation = true;
+        try {
+            await this.enterExecutionClaim(execution);
+            const header = await this.deps.store.readHeader(sessionId);
+            const run = new AgentRun({
+                sessionId,
+                header,
+                userInput: input,
+                runId: options.runId,
+                userMessageId: options.userMessageId,
+                durability: 'required',
+                runStore: this.deps.runStore,
+                runtimeEventStore: this.deps.runtimeEventStore,
+                newId: this.deps.newId,
+                now: this.deps.now,
+                effectiveOrchestration: resolveEffectiveOrchestration('default', undefined),
+                hooks: {
+                    reserveRun: async (id, nextHeader, activeRun) => {
+                        const active = await this.reserveParentRun(id, nextHeader, activeRun, execution);
+                        this.reserveExecutionClaim(execution, active, activeRun);
+                        return active;
+                    },
+                    unregisterRun: (active, activeRun) => this.unregisterParentRun(active, activeRun),
+                    updateHeader: (id, patch) => this.updateHeader(id, patch),
+                    updateStatus: (id, status, reason, ts) => this.updateStatus(id, status, reason, ts),
+                    ...this.messageProjectionHook(),
+                },
+            });
+            this.attachExecutionClaim(execution, run);
+            const owners = this.createRunOwnerScope(run, execution);
+            try {
+                owners.bindMessage(this.deps.messageAuthority, {
+                    sessionId,
+                    turnId: input.turnId,
+                    runId: run.runId,
+                });
+                // Keep the execution claim attached until finalization. Stop/drain can
+                // therefore cancel and await this Run without a provider generation.
+                await run.beginCoordination();
+                await options.onRunStarted?.(run.runId, header);
+            }
+            catch (error) {
+                await this.finalizeFailedRunStart(owners, run, execution, error);
+                return;
+            }
+            try {
+                if (run.isStopped())
+                    return;
+                const executed = await execute();
+                const receipt = {
+                    ...executed,
+                    result: executed.result.disposition === 'clarify'
+                        ? { ...executed.result, coordinationTurnId: input.turnId }
+                        : executed.result,
+                };
+                const receiptEvent = {
+                    id: this.deps.newId(),
+                    sessionId,
+                    turnId: input.turnId,
+                    runId: run.runId,
+                    invocationId: run.runId,
+                    ts: this.deps.now(),
+                    partial: false,
+                    role: 'system',
+                    author: 'host',
+                    modelVisibility: 'hidden',
+                    actions: { coordination: receipt },
+                };
+                await run.recordRuntimeEvents([receiptEvent], { requireDurableWrite: true });
+                if (run.isStopped())
+                    return;
+                const complete = {
+                    type: 'complete',
+                    id: this.deps.newId(),
+                    turnId: input.turnId,
+                    ts: this.deps.now(),
+                    stopReason: 'end_turn',
+                };
+                await run.acceptMappedEvent(complete, mapSessionEventToRuntimeEvent(complete, this.runtimeEventMapContext({
+                    sessionId,
+                    invocationId: run.runId,
+                    runId: run.runId,
+                    turnId: input.turnId,
+                })), { requireTerminalWrite: true });
+                yield complete;
+            }
+            catch (error) {
+                await run.recordFailure(error);
+                throw error;
+            }
+            finally {
+                const failures = new FailureCollector();
+                await failures.capture(() => owners.finalize());
+                await failures.capture(() => owners.releaseMessage());
+                failures.throwIfAny(`Coordination cleanup failed for ${run.runId}`);
+            }
+        }
+        finally {
+            this.releaseExecutionClaim(execution);
+            await this.flushBackendInvalidation(sessionId);
+        }
+    }
     async *compactSession(sessionId, input = {}) {
         const execution = this.takeExecutionClaim(sessionId);
         try {
@@ -1455,24 +1560,26 @@ export class RuntimeKernel {
         const generations = this.backendGenerationsFor(sessionId);
         await Promise.all(generations.map((active) => active.backend.respondToUserQuestion?.(response)));
     }
+    activeRunsFor(sessionId) {
+        const runs = new Set();
+        for (const active of this.backendGenerationsFor(sessionId)) {
+            for (const run of active.activeRuns.values())
+                runs.add(run);
+        }
+        for (const claim of this.executionClaims.get(sessionId) ?? []) {
+            if (claim.hostOperation && claim.run)
+                runs.add(claim.run);
+        }
+        return [...runs];
+    }
     hasActiveRuns(sessionId) {
-        return this.backendGenerationsFor(sessionId).some((active) => active.activeRuns.size > 0);
+        return this.activeRunsFor(sessionId).length > 0;
     }
     runningTurnIds(sessionId) {
-        const turnIds = [];
-        for (const active of this.backendGenerationsFor(sessionId)) {
-            for (const run of active.activeRuns.values()) {
-                if (!turnIds.includes(run.turnId))
-                    turnIds.push(run.turnId);
-            }
-        }
-        return turnIds;
+        return [...new Set(this.activeRunsFor(sessionId).map((run) => run.turnId))];
     }
     hasActiveRun(sessionId, runId, turnId) {
-        return this.backendGenerationsFor(sessionId).some((active) => {
-            const run = active.activeRuns.get(runId);
-            return run !== undefined && (turnId === undefined || run.turnId === turnId);
-        });
+        return this.activeRunsFor(sessionId).some((run) => run.runId === runId && (turnId === undefined || run.turnId === turnId));
     }
     requestRunHandoff(sessionId, runId, pause, signal) {
         if (!this.deps.inspectContinuationSafety)
@@ -1694,6 +1801,13 @@ export class RuntimeKernel {
                         }
                         return run.recordRunComposition(snapshot);
                     },
+                    recordRequestComposition: (runId, snapshot) => {
+                        const run = this.active.get(sessionId)?.activeRuns.get(runId);
+                        if (!run) {
+                            return Promise.reject(new Error('No active AgentRun for Request Composition'));
+                        }
+                        return run.recordRequestComposition(snapshot);
+                    },
                     loadHistoryCompactCheckpoint: () => this.historyCompactCoordinator.load(sessionId),
                     recordHistoryCompactCheckpoint: (checkpoint, turnId) => this.historyCompactCoordinator.record(sessionId, checkpoint, runFor(turnId)),
                     loadModelProjectionTransitions: async () => loadModelProjectionTransitionsFromRunLedger(this.deps.runStore, sessionId, await this.sessionRunIds(sessionId)),

package/node_modules/@maka/runtime/dist/session-manager.js

@@ -16,17 +16,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-/**
- * SessionManager — the public Runtime API.
- *
- * Ties together:
- *   SessionStore (storage)           — SQLite persistence
- *   AgentBackend (AiSdkBackend etc) — SDK adapter
- *   ExecutionBoundary                — session sandbox authority
- *
- * `SessionStore` comes from `@maka/storage`; its public interface owns
- * persistence and same-session serialization semantics.
- */
 import { createHash } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { setTimeout as delay } from 'node:timers/promises';
@@ -1280,6 +1269,9 @@ export class SessionManager {
             // Operational telemetry must never alter resume correctness.
         }
     }
+    runCoordinationOperation(sessionId, input, options, execute) {
+        return this.runtimeKernel.runCoordinationOperation(sessionId, input, options, execute);
+    }
     async *compactSession(sessionId, input = {}) {
         yield* this.runtimeKernel.compactSession(sessionId, input);
     }
@@ -2314,43 +2306,30 @@ export class SessionManager {
         const hostedAuthority = isRuntimeHostedRootAuthority(this.deps.messageAuthority)
             ? this.deps.messageAuthority
             : undefined;
-        const ownStop = hostedAuthority
+        await this.#stopSessionTree(sessionId, hostedAuthority
             ? hostedAuthority.stopSession(sessionId, input)
-            : this.runtimeKernel.stopSession(sessionId, input);
-        let childStops = [];
-        let childLookupError;
-        try {
-            const children = await this.listChildSessions(sessionId);
-            childStops = await Promise.allSettled(children
-                .filter((child) => child.subagentParent?.lifecycle === 'foreground')
-                .map((child) => hostedAuthority
-                ? hostedAuthority.stopSession(child.id, input)
-                : this.runtimeKernel.stopSession(child.id, input)));
-        }
-        catch (error) {
-            childLookupError = error;
-        }
-        await ownStop;
-        const childStopError = childStops.find((result) => result.status === 'rejected')?.reason;
-        if (childLookupError !== undefined)
-            throw childLookupError;
-        if (childStopError !== undefined)
-            throw childStopError;
+            : this.runtimeKernel.stopSession(sessionId, input), (childSessionId) => hostedAuthority
+            ? hostedAuthority.stopSession(childSessionId, input)
+            : this.runtimeKernel.stopSession(childSessionId, input));
     }
     async deliverHostedRootStop(sessionId, input = {}) {
-        const ownStop = this.runtimeKernel.stopSession(sessionId, input);
         const authority = isRuntimeHostedRootAuthority(this.deps.messageAuthority)
             ? this.deps.messageAuthority
             : undefined;
+        await this.#stopSessionTree(sessionId, this.runtimeKernel.stopSession(sessionId, input), (childSessionId) => authority
+            ? authority.stopSession(childSessionId, input)
+            : this.runtimeKernel.stopSession(childSessionId, input));
+    }
+    async #stopSessionTree(sessionId, ownStop, stopChild) {
+        // Observe immediately while child lookup runs; await below still propagates the original error.
+        void ownStop.catch(() => undefined);
         let childStops = [];
         let childLookupError;
         try {
             const children = await this.listChildSessions(sessionId);
             childStops = await Promise.allSettled(children
                 .filter((child) => child.subagentParent?.lifecycle === 'foreground')
-                .map((child) => authority
-                ? authority.stopSession(child.id, input)
-                : this.runtimeKernel.stopSession(child.id, input)));
+                .map((child) => stopChild(child.id)));
         }
         catch (error) {
             childLookupError = error;
@@ -2385,6 +2364,11 @@ export class SessionManager {
                 goalId: input.execution.goalId,
             };
         }
+        else if (input.execution.kind === 'workhub_coordination' &&
+            input.execution.operation === 'action') {
+            recoveryReason = 'coordination_action_admission_without_run';
+            diagnostic = { executionKind: input.execution.kind, operation: input.execution.operation };
+        }
         else if (input.execution.kind === 'legacy_automation') {
             root = { kind: 'legacy_automation', legacyAutomationId: input.execution.automationId };
             recoveryReason = 'legacy_automation_authority_removed';

package/node_modules/@maka/runtime/dist/stream-graph-coordinator.js

@@ -184,6 +184,27 @@ export class AgentGraphCoordinator {
     async hasLiveSessionState(rootSessionId) {
         return (await this.readSessionState(rootSessionId)) === 'live';
     }
+    /**
+     * Classify durable graph state for Session retirement without changing the
+     * broader live-state semantics used by recovery and graph epoch selection.
+     */
+    async readRetirementDisposition(rootSessionId) {
+        const snapshot = buildAgentGraphClientSnapshot(await this.#readClientModelInputForGraph(rootSessionId, await this.currentGraphId(rootSessionId)));
+        if (snapshot.scheduleRevision === 0)
+            return { kind: 'clear' };
+        switch (snapshot.status) {
+            case 'empty':
+            case 'completed':
+                return { kind: 'clear' };
+            case 'stopped':
+            case 'failed':
+                return { kind: 'quiescent_open' };
+            case 'active':
+            case 'waiting':
+            case 'closing':
+                return { kind: 'busy', status: snapshot.status };
+        }
+    }
     /**
      * Reconstruct one stable, reference-only control/data-plane timeline page.
      *

package/node_modules/@maka/runtime/dist/stream-graph-supervisor-tools.js

@@ -22,11 +22,6 @@ import { stableHash } from './request-shape.js';
 export const VIEW_AGENT_GRAPH_TOOL_NAME = 'view_agent_graph';
 export const UPDATE_AGENT_GRAPH_TOOL_NAME = 'update_agent_graph';
 export const YIELD_AGENT_GRAPH_TOOL_NAME = 'yield_agent_graph';
-export const AGENT_GRAPH_SUPERVISOR_TOOL_NAMES = [
-    VIEW_AGENT_GRAPH_TOOL_NAME,
-    UPDATE_AGENT_GRAPH_TOOL_NAME,
-    YIELD_AGENT_GRAPH_TOOL_NAME,
-];
 const TOOL_VIEW_MAX_TERMINAL_WORK = 64;
 const TOOL_VIEW_MAX_STOPPED_TARGETS = 64;
 const TOOL_VIEW_MAX_INSTRUCTION_CHARS = 2_000;

package/node_modules/@maka/runtime/dist/test-connection.js

@@ -337,7 +337,6 @@ async function httpFailure(r, t0) {
         await r.cancel();
         return {
             ok: false,
-            errorMessage: 'OAuth 已登录，但当前账号或 provider 正在 rate limit。请稍后重试，或先切换到其它可用模型。',
             statusCode,
             errorClass: 'provider_unavailable',
             latencyMs: Date.now() - t0,

package/node_modules/@maka/runtime/dist/tool-activation-identity.js

@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { stableHash, toolCatalogHash } from './request-shape.js';
+const TOOL_ACTIVATION_IDENTITY = Symbol('maka.toolActivationIdentity');
+/** Bind a Runtime-owned contribution identity to a Tool without exposing it to providers. */
+export function bindToolActivationIdentity(tool, identity) {
+    return Object.freeze({
+        ...tool,
+        [TOOL_ACTIVATION_IDENTITY]: stableHash({
+            identity,
+            schemaHash: toolCatalogHash([tool]),
+        }),
+    });
+}
+/**
+ * Stable logical identity used by deferred-tool activation.
+ *
+ * Host wrappers without explicit contribution metadata fall back to their
+ * canonical provider-visible shape, so rebuilding an equivalent wrapper does
+ * not revoke activation. Dynamic contributors bind generation-aware metadata.
+ */
+export function toolActivationKey(tool) {
+    const explicit = tool[TOOL_ACTIVATION_IDENTITY];
+    return explicit ?? stableHash({ kind: 'host', schemaHash: toolCatalogHash([tool]) });
+}

package/node_modules/@maka/runtime/dist/tool-availability.js

@@ -20,6 +20,7 @@ import MiniSearch from 'minisearch';
 import { z } from 'zod';
 import { estimateTokens } from './context-budget-helpers.js';
 import { canonicalizeToolSet, stableHash, toolSchemaCharsForDiagnostics } from './request-shape.js';
+import { toolActivationKey } from './tool-activation-identity.js';
 /** Canonical name of Maka's provider-independent deferred-tool search connector. */
 export const TOOL_SEARCH_NAME = 'tool_search';
 /** Provider-safe alias used because OpenAI Responses reserves `tool_search`. */
@@ -101,6 +102,7 @@ export class ToolAvailabilityRuntime {
     invalidTool;
     tools;
     toolsByName;
+    activationKeysByName;
     groups;
     searchableNames;
     directNames;
@@ -115,6 +117,7 @@ export class ToolAvailabilityRuntime {
         }
         this.tools = [...tools];
         this.toolsByName = new Map(tools.map((tool) => [tool.name, tool]));
+        this.activationKeysByName = new Map(tools.map((tool) => [tool.name, toolActivationKey(tool)]));
         const known = new Set(this.toolsByName.keys());
         const searchable = config === undefined
             ? new Set()
@@ -240,6 +243,13 @@ export class ToolAvailabilityRuntime {
         const allTools = [...this.tools, connector];
         const canonical = canonicalizeToolSet(allTools, this.invalidTool);
         const knownNames = new Set(canonical.providerTools.map((tool) => tool.name));
+        // Activation belongs to a stable logical contribution, not a temporary
+        // wrapper object or merely its name. Equivalent Host wrappers survive
+        // per-step rebuilding; a replaced Plugin generation does not.
+        for (const [name, activatedKey] of activeTools) {
+            if (this.activationKeysByName.get(name) !== activatedKey)
+                activeTools.delete(name);
+        }
         const requiredNames = [...requiredToolNames].filter((name) => knownNames.has(name));
         const step = { active: new Set() };
         const computeActive = () => {
@@ -308,7 +318,7 @@ export class ToolAvailabilityRuntime {
                     schemaChars += chars;
                 }
                 for (const name of activated)
-                    activeTools.set(name, this.toolsByName.get(name));
+                    activeTools.set(name, this.activationKeysByName.get(name));
                 const result = {
                     activated,
                     ...(blocked ? { blocked } : {}),

package/node_modules/@maka/runtime/dist/tool-result-archive-resource.js

@@ -35,12 +35,72 @@ const MAX_SEARCH_SNIPPET_CHARS = 240;
 const MAX_SEARCH_PATTERN_CHARS = 256;
 /** Preview length surfaced by inspect for text/object payloads. */
 const INSPECT_PREVIEW_CHARS = 600;
+export function isLedgerArchiveIdentity(value) {
+    if (!isRecord(value))
+        return false;
+    return (value.storage === 'ledger' &&
+        value.artifactId === undefined &&
+        ['runtimeEventId', 'toolCallId', 'toolName'].every((key) => typeof value[key] === 'string' &&
+            value[key].length > 0 &&
+            value[key].length <= 512) &&
+        typeof value.sourceProjectionDigest === 'string' &&
+        /^sha256:[a-f0-9]{64}$/.test(value.sourceProjectionDigest) &&
+        (value.previousTransitionId === undefined ||
+            (typeof value.previousTransitionId === 'string' &&
+                /^mptransition-[a-f0-9]{32}$/.test(value.previousTransitionId))) &&
+        typeof value.bodySha256 === 'string' &&
+        /^[a-f0-9]{64}$/.test(value.bodySha256) &&
+        Number.isSafeInteger(value.originalBytes) &&
+        Number(value.originalBytes) > 0);
+}
 export function buildToolResultArchiveResourceRef(input) {
+    if (input.storage === 'ledger') {
+        if (!isLedgerArchiveIdentity(input))
+            throw new Error('Invalid ledger archive identity');
+        const value = [
+            input.runtimeEventId,
+            input.toolCallId,
+            input.toolName,
+            input.sourceProjectionDigest,
+            input.previousTransitionId ?? null,
+            input.bodySha256,
+            input.originalBytes,
+        ];
+        return `maka://archive-ledger/v1/${encodeURIComponent(JSON.stringify(value))}`;
+    }
     const artifactId = encodeURIComponent(input.artifactId);
     const sha256 = encodeURIComponent(input.bodySha256);
     return `maka://archive/${artifactId}/${sha256}/${input.originalBytes}`;
 }
 export function parseToolResultArchiveResourceRef(ref) {
+    if (ref.startsWith('maka://archive-ledger/')) {
+        try {
+            const prefix = 'maka://archive-ledger/v1/';
+            if (!ref.startsWith(prefix) || ref.length > 16384)
+                return null;
+            const values = JSON.parse(decodeURIComponent(ref.slice(prefix.length)));
+            if (!Array.isArray(values) || values.length !== 7)
+                return null;
+            const [runtimeEventId, toolCallId, toolName, sourceProjectionDigest, previous, bodySha256, originalBytes,] = values;
+            const identity = {
+                storage: 'ledger',
+                runtimeEventId,
+                toolCallId,
+                toolName,
+                sourceProjectionDigest,
+                ...(previous === null ? {} : { previousTransitionId: previous }),
+                bodySha256,
+                originalBytes,
+            };
+            return isLedgerArchiveIdentity(identity) &&
+                buildToolResultArchiveResourceRef(identity) === ref
+                ? identity
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
     let url;
     try {
         url = new URL(ref);
@@ -162,7 +222,9 @@ function inspectArchive(ref, identity, value, serializedResult) {
         kind: 'tool_result_archive',
         operation: 'inspect',
         ref,
-        artifactId: identity.artifactId,
+        ...(identity.storage === 'ledger'
+            ? { storage: 'ledger', runtimeEventId: identity.runtimeEventId }
+            : { artifactId: identity.artifactId }),
         originalBytes: identity.originalBytes,
     };
     const readHint = 'Call ArchiveRead with operation "read" (unit "char" or "line"), offset, and limit for bounded pages, or operation "search" with a pattern to locate text.';

package/node_modules/@maka/runtime/dist/tool-result-archive-transition.js

@@ -40,11 +40,12 @@
  */
 import { MATERIALIZED_IMAGE_TOKENS } from '@maka/core/attachments';
 import { DURABLE_TOOL_RESULT_PROJECTION_VERSION } from '@maka/core/durable-tool-result-projection';
-import { buildModelProjectionTransition, } from '@maka/core/model-projection-transition';
+import { buildModelProjectionTransition, durableToolResultProjectionDigest, } from '@maka/core/model-projection-transition';
 import { estimateTokens, finitePositive, sha256, turnKey, utf8ByteLength, } from './context-budget-helpers.js';
-import { durableProjectionToToolResultOutput, projectionArtifactMedia, } from './durable-tool-result-projection.js';
+import { projectionArtifactMedia } from './durable-tool-result-projection.js';
 import { baseToolResultProjection, nextInChain } from './model-projection-transition-ledger.js';
-import { ARCHIVED_TOOL_RESULT_REWRITE_VERSION, buildArchivedToolResultPlaceholder, isArchivedToolResultPlaceholder, serializeToolResultForArchive, } from './tool-result-archive.js';
+import { ARCHIVED_TOOL_RESULT_REWRITE_VERSION, buildArchivedToolResultPlaceholder, buildLedgerArchivedToolResultPlaceholder, isArchivedToolResultPlaceholder, } from './tool-result-archive.js';
+import { serializeToolResultProjectionV1 } from './tool-result-archive-encoding.js';
 const DEFAULT_MAX_TOOL_RESULT_ESTIMATED_TOKENS = 2048;
 /**
  * What the model actually reads for one Tool Result, as bytes.
@@ -55,8 +56,7 @@ const DEFAULT_MAX_TOOL_RESULT_ESTIMATED_TOKENS = 2048;
  * body that is not the one removed from the model's view.
  */
 export function serializedToolResultProjection(projection) {
-    const output = durableProjectionToToolResultOutput(projection);
-    return serializeToolResultForArchive(output.type === 'execution-denied' ? { kind: 'text', text: output.reason ?? '' } : output.value);
+    return serializeToolResultProjectionV1(projection);
 }
 /** The replacement a pruned Tool Result projects to. */
 export function archivedToolResultProjection(placeholder) {
@@ -90,16 +90,21 @@ export async function archiveToolResultAsTransition(services, request) {
             originalEstimatedTokens: request.originalEstimatedTokens,
             rewriteVersion: ARCHIVED_TOOL_RESULT_REWRITE_VERSION,
             reason: request.reason,
+            sourceProjectionDigest: durableToolResultProjectionDigest(request.sourceProjection),
+            ...(request.previousTransitionId
+                ? { previousTransitionId: request.previousTransitionId }
+                : {}),
         }));
     }
     catch {
         return undefined;
     }
-    const artifactId = archived?.artifactId;
-    if (typeof artifactId !== 'string' || artifactId.trim().length === 0)
+    if (!archived)
+        return undefined;
+    if (!archived.ledger &&
+        (typeof archived.artifactId !== 'string' || archived.artifactId.trim().length === 0))
         return undefined;
-    const placeholder = buildArchivedToolResultPlaceholder({
-        artifactId,
+    const common = {
         runtimeEventId: request.runtimeEventId,
         toolCallId: request.toolCallId,
         toolName: request.toolName,
@@ -108,7 +113,23 @@ export async function archiveToolResultAsTransition(services, request) {
         originalBytes: request.originalBytes,
         reason: request.reason,
         ...(request.supersession ? { supersession: request.supersession } : {}),
-    });
+    };
+    let placeholder;
+    try {
+        placeholder = archived.ledger
+            ? buildLedgerArchivedToolResultPlaceholder({
+                ...common,
+                storage: 'ledger',
+                sourceProjectionDigest: durableToolResultProjectionDigest(request.sourceProjection),
+                ...(request.previousTransitionId
+                    ? { previousTransitionId: request.previousTransitionId }
+                    : {}),
+            })
+            : buildArchivedToolResultPlaceholder({ ...common, artifactId: archived.artifactId });
+    }
+    catch {
+        return undefined;
+    }
     let transition;
     try {
         transition = buildModelProjectionTransition({
@@ -129,7 +150,16 @@ export async function archiveToolResultAsTransition(services, request) {
                 : {}),
             now: services.now(),
         });
-        await services.recordTransition(transition);
+        if (placeholder.rewriteVersion === 2 &&
+            Buffer.byteLength(JSON.stringify(transition)) > 32 * 1024)
+            return undefined;
+        if (archived.ledger && archived.commitTransition) {
+            if (!(await archived.commitTransition(transition, services.recordTransition)))
+                return undefined;
+        }
+        else {
+            await services.recordTransition(transition);
+        }
         const winner = await winningTransition(services, transition);
         if (winner && winner.transitionId !== transition.transitionId) {
             // The rival won. Show what the ledger says, not what this writer wrote;
@@ -236,7 +266,7 @@ export function collectReachableArchiveArtifactIds(events) {
         const content = event.content;
         if (content?.kind !== 'function_response')
             continue;
-        if (isArchivedToolResultPlaceholder(content.result)) {
+        if (isArchivedToolResultPlaceholder(content.result) && content.result.rewriteVersion === 1) {
             reachable.add(content.result.artifactId);
         }
     }