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

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

@@ -269,10 +269,9 @@ function registerPluginEffect(ctx, label, register) {
 }
 export function registerPluginContribution(ctx, label, register) {
     if (ctx.makaTransaction) {
-        ctx.makaTransaction.stage(label, register, ctx);
-        return;
+        return ctx.makaTransaction.stage(label, register, ctx);
     }
-    registerPluginEffect(ctx, label, register);
+    return registerPluginEffect(ctx, label, register);
 }
 export class MakaPluginTransactionBuffer {
     context;
@@ -283,13 +282,22 @@ export class MakaPluginTransactionBuffer {
     }
     stage(label, register, owner = this.context) {
         if (this.#state === 'committed') {
-            registerPluginEffect(owner, label, register);
-            return;
+            return registerPluginEffect(owner, label, register);
         }
         if (this.#state === 'rolled_back') {
             throw new MakaPluginRuntimeError('activation_failed', `Cannot stage contribution after transaction is ${this.#state}`);
         }
-        this.#registrations.push({ label, register, owner });
+        const item = {
+            label,
+            register,
+            owner,
+            cancelled: false,
+        };
+        this.#registrations.push(item);
+        return async () => {
+            item.cancelled = true;
+            await item.release?.();
+        };
     }
     async commit() {
         if (this.#state === 'committed')
@@ -300,7 +308,10 @@ export class MakaPluginTransactionBuffer {
         const registered = [];
         try {
             for (const item of this.#registrations) {
-                registered.push(registerPluginEffect(item.owner, item.label, item.register));
+                if (item.cancelled)
+                    continue;
+                item.release = registerPluginEffect(item.owner, item.label, item.register);
+                registered.push(item.release);
             }
             this.#state = 'committed';
             this.#registrations.length = 0;
@@ -333,10 +344,9 @@ export class MakaPluginTransactionBuffer {
 export function fiberStateName(state) {
     return ['pending', 'loading', 'active', 'failed', 'disposed', 'unloading'][state];
 }
-export function isCanonicalPluginId(value) {
+export function isCanonicalExtensionId(value) {
     return typeof value === 'string' && value.length <= 128 && ID_PATTERN.test(value);
 }
-export const isCanonicalExtensionId = isCanonicalPluginId;
 function cloneCompositionEntry(entry) {
     return {
         ...entry,
@@ -384,7 +394,7 @@ export function isCanonicalExtensionScopeId(value) {
     return (typeof value === 'string' && value.length <= 128 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(value));
 }
 function validatePluginId(value, label) {
-    if (!isCanonicalPluginId(value)) {
+    if (!isCanonicalExtensionId(value)) {
         throw new MakaPluginRuntimeError('invalid_entry', `Invalid ${label}`);
     }
 }

package/node_modules/@maka/runtime/dist/plugin-tool-service.js

@@ -0,0 +1,205 @@
+/*
+ * 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 { REQUEST_COMPOSITION_MAX_TOOL_DESCRIPTION_LENGTH } from '@maka/core/run-composition';
+import { Service } from './plugin-kernel.js';
+import { MakaPluginRuntimeError, pluginIdentity, registerPluginContribution, } from './plugin-runtime.js';
+import { bindToolActivationIdentity } from './tool-activation-identity.js';
+import { TOOL_SEARCH_NAME, TOOL_SEARCH_PROVIDER_NAME } from './tool-availability.js';
+/**
+ * Context-scoped Tool contribution registry for trusted Host plugins.
+ *
+ * Registration is staged by the Plugin Platform transaction and owned by the
+ * registering Fiber. Profile registrations are inherited by Session roots;
+ * an exact Session registration shadows the Profile registration. Core tools
+ * remain Host-owned and cannot be shadowed.
+ */
+export class PluginToolService extends Service {
+    layers = new Map();
+    onChanged;
+    constructor(ctx, options = {}) {
+        super(ctx, 'tools');
+        this.onChanged = options.onChanged;
+    }
+    register(definition) {
+        const identity = pluginIdentity(this.ctx);
+        if (identity.scopeId === 'desktop-ui') {
+            throw new MakaPluginRuntimeError('activation_failed', 'desktop-ui plugins cannot register Host tools');
+        }
+        validateTool(definition);
+        return registerPluginContribution(this.ctx, `tools.register(${JSON.stringify(definition.name)})`, () => this.publish(identity, definition));
+    }
+    resolve(sessionId, coreTools) {
+        const contributions = this.resolveContributions(sessionId, coreTools);
+        return Object.freeze({
+            tools: Object.freeze([...coreTools, ...contributions.tools]),
+        });
+    }
+    /** Resolve only Plugin-owned additions after validating them against the Host binding. */
+    resolveContributions(sessionId, coreTools) {
+        if (!sessionId || /[\r\n\0]/u.test(sessionId))
+            throw new Error('Invalid Tool Session scope');
+        const visible = new Map();
+        for (const entry of this.layers.get('profile')?.values() ?? []) {
+            visible.set(entry.definition.name, entry);
+        }
+        const sessionRoot = `session:${sessionId}`;
+        for (const entry of this.layers.get(sessionRoot)?.values() ?? []) {
+            visible.set(entry.definition.name, entry);
+        }
+        const coreNames = new Set(coreTools.map(({ name }) => name));
+        for (const name of visible.keys()) {
+            if (coreNames.has(name)) {
+                throw new MakaPluginRuntimeError('activation_failed', `Plugin Tool ${JSON.stringify(name)} conflicts with a Host-owned Tool`);
+            }
+        }
+        const entries = [...visible.values()].sort(compareRegistration);
+        return Object.freeze({
+            tools: Object.freeze(entries.map(({ exposed }) => exposed)),
+        });
+    }
+    inspect(rootId) {
+        const layers = rootId
+            ? [[rootId, this.layers.get(rootId)]]
+            : [...this.layers.entries()];
+        return Object.freeze(layers
+            .flatMap(([, layer]) => [...(layer?.values() ?? [])])
+            .sort(compareRegistration)
+            .map((entry) => Object.freeze({
+            entryId: entry.entryId,
+            scopeId: entry.scopeId,
+            extensionId: entry.extensionId,
+            generation: entry.generation,
+            toolName: entry.definition.name,
+            activeCalls: entry.activeCalls,
+            retired: entry.retired,
+        })));
+    }
+    publish(identity, definition) {
+        const rootId = identity.scopeId;
+        let layer = this.layers.get(rootId);
+        if (!layer) {
+            layer = new Map();
+            this.layers.set(rootId, layer);
+        }
+        const existing = layer.get(definition.name);
+        if (existing && existing.entryId !== identity.entryId) {
+            throw new MakaPluginRuntimeError('activation_failed', `Plugin Tool ${JSON.stringify(definition.name)} is already registered by ${existing.entryId}`);
+        }
+        let entry;
+        const exposed = bindToolActivationIdentity({
+            ...definition,
+            impl: async (args, context) => {
+                if (entry.retired) {
+                    throw new Error(`Plugin Tool ${JSON.stringify(definition.name)} is no longer active`);
+                }
+                entry.activeCalls += 1;
+                try {
+                    return await definition.impl(args, context);
+                }
+                finally {
+                    entry.activeCalls -= 1;
+                    if (entry.activeCalls === 0) {
+                        for (const resolve of entry.drainWaiters)
+                            resolve();
+                        entry.drainWaiters.clear();
+                    }
+                }
+            },
+        }, {
+            kind: 'plugin',
+            scopeId: identity.scopeId,
+            entryId: identity.entryId,
+            extensionId: identity.extensionId,
+            generation: identity.generation,
+            toolName: definition.name,
+        });
+        entry = {
+            ...identity,
+            definition,
+            exposed,
+            token: Symbol(definition.name),
+            activeCalls: 0,
+            retired: false,
+            drainWaiters: new Set(),
+        };
+        layer.set(definition.name, entry);
+        try {
+            this.notifyChanged(rootId);
+        }
+        catch (error) {
+            if (existing)
+                layer.set(definition.name, existing);
+            else
+                layer.delete(definition.name);
+            if (layer.size === 0)
+                this.layers.delete(rootId);
+            throw error;
+        }
+        return async () => {
+            entry.retired = true;
+            const currentLayer = this.layers.get(rootId);
+            if (currentLayer?.get(definition.name)?.token === entry.token) {
+                if (existing && !existing.retired)
+                    currentLayer.set(definition.name, existing);
+                else
+                    currentLayer.delete(definition.name);
+                if (currentLayer.size === 0)
+                    this.layers.delete(rootId);
+                this.notifyChanged(rootId);
+            }
+            if (entry.activeCalls > 0) {
+                await new Promise((resolve) => entry.drainWaiters.add(resolve));
+            }
+        };
+    }
+    notifyChanged(rootId) {
+        this.ctx.emit('tools/change');
+        this.onChanged?.(rootId);
+    }
+}
+function validateTool(tool) {
+    if (!tool || typeof tool !== 'object')
+        throw new TypeError('Tool definition is required');
+    if (typeof tool.name !== 'string' ||
+        tool.name.length === 0 ||
+        tool.name.length > 128 ||
+        /[\r\n\0]/u.test(tool.name)) {
+        throw new TypeError('Tool requires a valid name');
+    }
+    if (typeof tool.description !== 'string' ||
+        tool.description.length === 0 ||
+        tool.description.length > REQUEST_COMPOSITION_MAX_TOOL_DESCRIPTION_LENGTH ||
+        typeof tool.impl !== 'function') {
+        throw new TypeError(`Tool ${JSON.stringify(tool.name)} requires a description of at most ${REQUEST_COMPOSITION_MAX_TOOL_DESCRIPTION_LENGTH} characters and an implementation`);
+    }
+    if (tool.parameters === undefined) {
+        throw new TypeError(`Tool ${JSON.stringify(tool.name)} requires an input schema`);
+    }
+    if (tool.providerTool) {
+        throw new TypeError(`Plugin Tool ${JSON.stringify(tool.name)} cannot claim a provider protocol`);
+    }
+    if (tool.name === TOOL_SEARCH_NAME || tool.name === TOOL_SEARCH_PROVIDER_NAME) {
+        throw new TypeError(`Plugin Tool name ${JSON.stringify(tool.name)} is reserved by Runtime`);
+    }
+}
+function compareRegistration(left, right) {
+    return (left.definition.name.localeCompare(right.definition.name) ||
+        left.scopeId.localeCompare(right.scopeId) ||
+        left.entryId.localeCompare(right.entryId));
+}

package/node_modules/@maka/runtime/dist/provider-request-telemetry.js

@@ -199,14 +199,18 @@ export class ProviderRequestTracker {
      * that call, not new calls, so they share this id.
      */
     logicalCallIdByStep = new Map();
+    requestCompositionIdByStep = new Map();
     constructor(input) {
         this.input = input;
     }
     get traceId() {
         return this.input.traceId;
     }
-    setStep(step) {
+    setStep(step, requestCompositionId) {
         this.step = step;
+        if (requestCompositionId !== undefined) {
+            this.requestCompositionIdByStep.set(step, requestCompositionId);
+        }
     }
     async trackStream(input) {
         throwIfAbortedBeforeDispatch(input.abortSignal);
@@ -356,6 +360,9 @@ export class ProviderRequestTracker {
                         ? { connectionSlug: accounting.connectionSlug }
                         : {}),
                     step: Math.max(0, step),
+                    ...(this.requestCompositionIdByStep.get(step)
+                        ? { requestCompositionId: this.requestCompositionIdByStep.get(step) }
+                        : {}),
                     attempt: Math.max(0, attempt - 1),
                     callKind: accounting.callKind,
                     ...((input.historyCompactRoute ?? accounting.historyCompactRoute) !== undefined

package/node_modules/@maka/runtime/dist/request-shape.js

@@ -152,6 +152,29 @@ export function toolCatalogHash(tools) {
         .sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0))
         .map(toolShapeForDiagnostics));
 }
+/** Canonical, JSON-safe schemas for the exact provider-visible tool subset. */
+export function requestCompositionToolSchemas(tools, activeToolNames) {
+    const active = new Set(activeToolNames);
+    return tools
+        .filter((tool) => active.has(tool.name))
+        .map((tool) => {
+        const inputSchema = JSON.parse(stableStringify(schemaShapeForHash(tool.parameters)));
+        if (!isPlainObject(inputSchema)) {
+            throw new Error(`Tool ${JSON.stringify(tool.name)} produced a non-object input schema`);
+        }
+        return {
+            name: tool.name,
+            description: tool.description,
+            inputSchema,
+            ...(tool.providerTool
+                ? {
+                    providerTool: JSON.parse(stableStringify(tool.providerTool)),
+                }
+                : {}),
+        };
+    })
+        .sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+}
 export function stableStringify(value) {
     return JSON.stringify(canonicalize(value));
 }

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

@@ -357,6 +357,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 +659,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

@@ -1694,6 +1694,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/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.';