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

package/node_modules/@maka/runtime/dist/ai-sdk-backend.js

@@ -71,7 +71,8 @@ export class AiSdkBackend {
     messageProjection;
     providerTelemetry;
     resolvedProviderOptions;
-    toolAvailabilityRuntime;
+    memoryTools;
+    applyPatchProfile;
     /** Bounds outstanding Code Mode cells on this backend. */
     codeCellAdmission = new AdmissionLimiter(MAX_ACTIVE_CODE_MODE_CELLS);
     /**
@@ -147,6 +148,7 @@ export class AiSdkBackend {
             beforeRunProviderDispatch: input.beforeRunProviderDispatch,
         });
         const applyPatchProfile = runtime.applyPatchProfile;
+        this.applyPatchProfile = applyPatchProfile;
         this.messageProjection = new AiSdkMessageProjection({
             modelAdapter: this.modelAdapter,
             applyPatchProfile,
@@ -168,7 +170,7 @@ export class AiSdkBackend {
         if (input.tools.some((tool) => tool.name === MEMORY_REMEMBER_TOOL_NAME || tool.name === MEMORY_EXTRACT_TOOL_NAME)) {
             throw new Error('Long-term Memory trigger tool names are reserved by Runtime');
         }
-        const memoryTools = input.memoryExtraction
+        this.memoryTools = input.memoryExtraction
             ? buildMemoryExtractionTriggerTools({
                 capabilities: input.memoryExtraction,
                 snapshot: (trigger, context) => this.memorySourceSnapshot(trigger, context),
@@ -182,11 +184,17 @@ export class AiSdkBackend {
                     : {}),
             })
             : [];
-        const modelTools = routeApplyPatchTools(input.tools, applyPatchProfile);
-        this.toolAvailabilityRuntime = new ToolAvailabilityRuntime(
-        // The archive decoder is a runtime protocol tool, not a host binding:
-        // this session's placeholders name it, so this session advertises it.
-        bindToolResultArchiveDecoder([...modelTools, ...memoryTools], input.toolResultArchive), input.toolAvailability, buildInvalidMakaTool());
+    }
+    snapshotToolAvailability() {
+        const hostTools = Object.freeze([...(this.input.resolveTools?.() ?? this.input.tools)]);
+        if (hostTools.some((tool) => tool.name === MEMORY_REMEMBER_TOOL_NAME || tool.name === MEMORY_EXTRACT_TOOL_NAME)) {
+            throw new Error('Long-term Memory trigger tool names are reserved by Runtime');
+        }
+        const modelTools = routeApplyPatchTools(hostTools, this.applyPatchProfile);
+        return {
+            hostTools,
+            runtime: new ToolAvailabilityRuntime(bindToolResultArchiveDecoder([...modelTools, ...this.memoryTools], this.input.toolResultArchive), this.input.toolAvailability, buildInvalidMakaTool()),
+        };
     }
     memorySourceSnapshot(trigger, context) {
         if (trigger !== 'remember')
@@ -255,7 +263,7 @@ export class AiSdkBackend {
             messageProjection: this.messageProjection,
             providerTelemetry: this.providerTelemetry,
             compaction: this.compaction,
-            toolAvailabilityRuntime: this.toolAvailabilityRuntime,
+            snapshotToolAvailability: () => this.snapshotToolAvailability(),
             codeCellAdmission: this.codeCellAdmission,
             resolvedProviderOptions: this.resolvedProviderOptions,
             session: this.turnSessionState,

package/node_modules/@maka/runtime/dist/ai-sdk-turn.js

@@ -37,7 +37,8 @@ import { hasActiveToolResultPruneDiagnosticPatch, hasBlockingReplayDiagnostics,
 import { RunTrace } from './run-trace.js';
 import { REQUEST_SANDBOX_BOUNDARY_TOOL_NAME, SANDBOX_BOUNDARY_DENIED_FOR_TURN, SANDBOX_BOUNDARY_FINALIZATION_PROMPT, } from './sandbox-boundary-tool.js';
 import { buildRuntimeEventModelReplayPlan, buildSteeringEnvelope, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, formatTextWithInlineRefs, steeringMessagesMissingFromBase, steeringModelMessage, } from './model-history.js';
-import { toolSchemaCharsForDiagnostics } from './request-shape.js';
+import { toolSchemaCharsForDiagnostics, requestCompositionToolSchemas, stableHash, toolCatalogHash, } from './request-shape.js';
+import { toolAvailabilityHash } from './tool-availability.js';
 import { renderSwarmModePrompt } from './swarm-mode.js';
 import { renderGraphModePrompt } from './graph-mode.js';
 import { modelUsesNativeOpenAiResponses } from './model-runtime.js';
@@ -800,8 +801,8 @@ export class AiSdkTurn {
             return;
         }
         // --- Build the provider-visible schema set. Tool execution stays in Runtime. ---
-        // One immutable runtime owns the bound search catalog and cached index.
-        // Mutable activation belongs to this turn.
+        // Each logical step freezes its own scoped catalog and search projection.
+        // Mutable activation belongs to this turn and follows contribution identity.
         const requiredOrchestrationTools = this.orchestration.mode === 'swarm'
             ? new Set([
                 'agent_list',
@@ -825,11 +826,22 @@ export class AiSdkTurn {
             throw new Error(`Invalid tool mode: ${String(requestedToolMode)}`);
         }
         const toolMode = requestedToolMode;
-        if (toolMode === 'code_mode' && this.deps.backend.tools.some((tool) => tool.name === 'exec')) {
-            throw new Error('Tool name "exec" is reserved for Code Mode.');
-        }
-        const plan = projectToolModePlan(this.deps.toolAvailabilityRuntime.prepare(this.activeTools, requiredOrchestrationTools), toolMode, codeModeExecTool);
-        const providerTools = plan.providerTools;
+        const snapshotStepTools = () => {
+            const snapshot = this.deps.snapshotToolAvailability();
+            if (toolMode === 'code_mode' && snapshot.hostTools.some((tool) => tool.name === 'exec')) {
+                throw new Error('Tool name "exec" is reserved for Code Mode.');
+            }
+            const plan = projectToolModePlan(snapshot.runtime.prepare(this.activeTools, requiredOrchestrationTools), toolMode, codeModeExecTool);
+            const modelTools = {};
+            for (const tool of plan.providerTools) {
+                modelTools[tool.name] = tool.providerTool
+                    ? { kind: 'provider', providerTool: tool.providerTool }
+                    : { kind: 'function', description: tool.description, inputSchema: tool.parameters };
+            }
+            toolRuntime.setGating(plan.gating);
+            return { plan, providerTools: plan.providerTools, modelTools };
+        };
+        let { plan, providerTools, modelTools } = snapshotStepTools();
         let activeToolResultPruneDiagnosticPatch = {};
         let midTurnCompactDiagnosticPatch;
         // Tool names the repair path matches a mis-cased call against — follows the
@@ -843,44 +855,8 @@ export class AiSdkTurn {
                 : [...names];
         };
         const currentRepairToolNames = () => boundaryAwareToolNames(plan.currentRepairToolNames());
-        if (plan.gating) {
-            toolRuntime.setGating(plan.gating);
-        }
-        const modelTools = {};
-        for (const t of providerTools) {
-            modelTools[t.name] = t.providerTool
-                ? { kind: 'provider', providerTool: t.providerTool }
-                : {
-                    kind: 'function',
-                    description: t.description,
-                    inputSchema: t.parameters,
-                };
-        }
-        // Resolve the stable Provider envelope before automatic Compaction freezes
-        // its source. The same value is reused by the primary request; Memory does
-        // not resolve or mutate Agent configuration after the checkpoint commits.
+        let resolvedSystemPrompt = { sourceRevisions: [] };
         let systemPrompt;
-        try {
-            systemPrompt = joinPromptFragments([
-                await this.resolveSystemPrompt(),
-                this.orchestration?.mode === 'swarm' ? renderSwarmModePrompt() : undefined,
-                this.orchestration?.mode === 'graph' ? renderGraphModePrompt() : undefined,
-            ]);
-        }
-        catch (err) {
-            trace.modelStreamFailed(this.deps.modelAdapter.classifyError(err), err);
-            queue.push(this.makeErrorEvent(turnId, err));
-            queue.push({
-                type: 'complete',
-                id: this.deps.newId(),
-                turnId,
-                ts: this.deps.now(),
-                stopReason: 'error',
-            });
-            queue.close();
-            yield* this.drain(queue);
-            return;
-        }
         // --- Build messages from RuntimeEvent history and its compatibility projection. ---
         const priorReplayResult = await this.buildPriorMessages(input);
         if (this.aborted) {
@@ -1083,7 +1059,8 @@ export class AiSdkTurn {
                 const onMidTurnDiagnosticPatch = (patch) => {
                     midTurnCompactDiagnosticPatch = mergeContextBudgetDiagnosticPatches(midTurnCompactDiagnosticPatch, patch);
                 };
-                const midTurnCapacityHook = this.deps.compaction.buildMidTurnCapacityCompactProjection(turnId, midTurnState, queue, providerTools, onMidTurnDiagnosticPatch, this, this.automaticMemoryCompactionSupported()
+                const capacityProviderTools = [...providerTools];
+                const midTurnCapacityHook = this.deps.compaction.buildMidTurnCapacityCompactProjection(turnId, midTurnState, queue, capacityProviderTools, onMidTurnDiagnosticPatch, this, this.automaticMemoryCompactionSupported()
                     ? () => this.automaticMemoryCompactionDecision()
                     : undefined, this.automaticMemoryCompactionSupported()
                     ? (dispatch) => this.dispatchAutomaticMemoryCompaction(dispatch)
@@ -1095,7 +1072,8 @@ export class AiSdkTurn {
                     pruneAppliedAtStep = runtimeSteps;
                     activeToolResultPruneDiagnosticPatch = mergeActiveToolResultPruneDiagnosticPatches(activeToolResultPruneDiagnosticPatch, patch);
                 });
-                const shapedProjection = composeRequestProjection(plan.projectActiveTools, midTurnCapacityHook, activeToolResultPruneHook);
+                const projectCurrentToolAvailability = (options) => plan.projectActiveTools?.(options);
+                const shapedProjection = composeRequestProjection(projectCurrentToolAvailability, midTurnCapacityHook, activeToolResultPruneHook);
                 // Hooks shape; nothing measures the final payload. Whether it fits is
                 // the provider's answer (#4559).
                 const requestProjection = shapedProjection;
@@ -1111,6 +1089,14 @@ export class AiSdkTurn {
                 let finishReason = 'stop';
                 let terminalProviderError;
                 agentLoop: for (;;) {
+                    ({ plan, providerTools, modelTools } = snapshotStepTools());
+                    resolvedSystemPrompt = await this.resolveSystemPrompt();
+                    systemPrompt = joinPromptFragments([
+                        resolvedSystemPrompt.text,
+                        this.orchestration.mode === 'swarm' ? renderSwarmModePrompt() : undefined,
+                        this.orchestration.mode === 'graph' ? renderGraphModePrompt() : undefined,
+                    ]);
+                    capacityProviderTools.splice(0, capacityProviderTools.length, ...providerTools);
                     await this.drainSteeringInto(input, queue);
                     if (this.deps.backend.loadTurnRuntimeEvents) {
                         requestMessages = await loadDurableTurnProjection();
@@ -1159,7 +1145,20 @@ export class AiSdkTurn {
                         : undefined;
                     const projectedMessages = shaped?.messages ?? requestMessages;
                     const activeToolsForRequest = resolveDispatch(shaped?.activeTools).activeTools;
-                    providerRequestTracker?.setStep(runtimeSteps);
+                    const requestCompositionId = this.runId && this.deps.backend.recordRequestComposition
+                        ? await this.deps.backend.recordRequestComposition(this.runId, {
+                            compositionId: this.deps.newId(),
+                            step: runtimeSteps,
+                            sourceRevisions: resolvedSystemPrompt.sourceRevisions,
+                            systemPromptHash: stableHash(requestSystemPrompt ?? ''),
+                            toolCatalogHash: toolCatalogHash(providerTools),
+                            toolAvailabilityHash: toolAvailabilityHash(this.deps.backend.toolAvailability),
+                            providerOptionsHash: stableHash(this.deps.resolvedProviderOptions),
+                            toolNames: activeToolsForRequest,
+                            toolSchemas: requestCompositionToolSchemas(providerTools, activeToolsForRequest),
+                        })
+                        : undefined;
+                    providerRequestTracker?.setStep(runtimeSteps, requestCompositionId);
                     let attemptMessages = projectedMessages;
                     let providerAttempt = 1;
                     let idleWatchdogRetryCount = 0;
@@ -2488,14 +2487,22 @@ export class AiSdkTurn {
     async resolveSystemPrompt() {
         const turnId = this.turnId;
         if (typeof this.deps.backend.systemPrompt === 'function') {
-            return await this.deps.backend.systemPrompt({
+            const resolved = await this.deps.backend.systemPrompt({
                 sessionId: this.deps.backend.sessionId,
                 turnId,
                 cwd: this.deps.backend.header.cwd,
                 emitSkillCatalogTrace: (message, data) => this.runTrace?.emit('skill', 'skill_catalog_built', message, data),
             });
+            return typeof resolved === 'string' || resolved === undefined
+                ? { ...(resolved === undefined ? {} : { text: resolved }), sourceRevisions: [] }
+                : resolved;
         }
-        return this.deps.backend.systemPrompt;
+        return {
+            ...(this.deps.backend.systemPrompt === undefined
+                ? {}
+                : { text: this.deps.backend.systemPrompt }),
+            sourceRevisions: [],
+        };
     }
     async *drain(queue) {
         try {

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

@@ -25,7 +25,7 @@ export function buildArchiveReadTool(reader) {
         .object({
         ref: z
             .string()
-            .describe('A maka://archive/... ref returned in an archived tool-result placeholder'),
+            .describe('The exact resourceRef returned in an archived tool-result placeholder (ledger or legacy archive)'),
         operation: z
             .enum(['inspect', 'read', 'query', 'search'])
             .default('inspect')
@@ -82,7 +82,7 @@ export function buildArchiveReadTool(reader) {
         name: ARCHIVE_READ_TOOL_NAME,
         displayName: 'Read archived result',
         activityKind: 'read',
-        description: 'Inspect, search, or page through a tool-result archive returned as a maka://archive/... ref. Start with inspect for a preview and the char/line coordinate space. Use operation "search" with a pattern to locate text, operation "read" with unit "line" for line-oriented terminal output, or operation "query" with an itemId for one agent_swarm item. Results are strictly bounded so reading an archive cannot immediately trigger another archive.',
+        description: 'Inspect, search, or page through a tool-result archive using its exact resourceRef. Both ledger and legacy archive references are supported. Start with inspect for a preview and the char/line coordinate space. Use operation "search" with a pattern to locate text, operation "read" with unit "line" for line-oriented terminal output, or operation "query" with an itemId for one agent_swarm item. Results are strictly bounded so reading an archive cannot immediately trigger another archive.',
         parameters: jsonSchema(async () => await providerSchema.jsonSchema, {
             validate: async (value) => {
                 const result = await parameters.safeParseAsync(value);

package/node_modules/@maka/runtime/dist/context-budget-helpers.js

@@ -46,22 +46,9 @@ export function stableJsonLength(value) {
 export function turnKey(event) {
     return event.turnId || '<unknown-turn>';
 }
-export function uniqueSorted(values) {
-    return [...new Set(values.filter((value) => value.length > 0))].sort();
-}
 export function sha256(text) {
     return createHash('sha256').update(text).digest('hex');
 }
-export function stableStringify(value) {
-    if (value === undefined)
-        return '';
-    try {
-        return JSON.stringify(value) ?? '';
-    }
-    catch {
-        return String(value);
-    }
-}
 export function finitePositive(value) {
     return typeof value === 'number' && Number.isFinite(value) && value > 0
         ? Math.floor(value)
@@ -70,6 +57,3 @@ export function finitePositive(value) {
 export function utf8ByteLength(text) {
     return Buffer.byteLength(text, 'utf8');
 }
-export function optionalNonNegativeFiniteNumber(value) {
-    return value === undefined || (typeof value === 'number' && Number.isFinite(value) && value >= 0);
-}

package/node_modules/@maka/runtime/dist/conversation-copy.js

@@ -31,11 +31,13 @@ import { buildToolOperationId } from './runtime-commit-sink.js';
 import { isContinuationStartRuntimeEvent } from './runtime-event-read-model.js';
 import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
 import { buildToolResultArchiveResourceRef, parseToolResultArchiveResourceRef, } from './tool-result-archive-resource.js';
-import { deserializeToolResultArchive, isArchivedToolResultPlaceholder, } from './tool-result-archive.js';
+import { deserializeToolResultArchive, isArchivedToolResultPlaceholder, buildLedgerArchivedToolResultPlaceholder, } from './tool-result-archive.js';
 import { rewriteDurableToolResultProjectionArtifactRefs } from './durable-tool-result-projection.js';
-import { buildModelProjectionTransition, decodeModelProjectionTransition, MODEL_PROJECTION_TRANSITION_EVENT_TYPE, } from '@maka/core/model-projection-transition';
+import { buildModelProjectionTransition, durableToolResultProjectionDigest, decodeModelProjectionTransition, MODEL_PROJECTION_TRANSITION_EVENT_TYPE, } from '@maka/core/model-projection-transition';
 import { baseToolResultProjection, decodeLedgerTransition, reduceEffectiveModelProjections, } from './model-projection-transition-ledger.js';
 import { archivedToolResultProjection } from './tool-result-archive-transition.js';
+import { serializeToolResultProjectionV1 } from './tool-result-archive-encoding.js';
+import { createHash } from 'node:crypto';
 /** Walks every typed StorageRef site reached by conversation-copy rewriting. */
 function collectConversationCopyStorageRefs(input) {
     const refs = [];
@@ -308,6 +310,7 @@ export async function cloneConversationRuntimeLedger(input) {
         runtimeEventIds,
         providerTraceIds,
         agentRunEventIds: operationalEventIds,
+        ledgerArchives: new Map(),
     };
     const clonedEventBySourceId = new Map();
     for (const plan of flattenedPlans) {
@@ -328,6 +331,64 @@ export async function cloneConversationRuntimeLedger(input) {
     // successor is rebuilt against the projection it actually replaces.
     const transitionIds = new Map();
     const transitionState = new Map();
+    const clonedTransitions = new Map();
+    const visiting = new Set();
+    const finished = new Set();
+    const transitionsByTarget = new Map();
+    for (const plan of flattenedPlans) {
+        for (const record of plan.operationalEvents) {
+            if (record.type !== MODEL_PROJECTION_TRANSITION_EVENT_TYPE)
+                continue;
+            const transition = decodeModelProjectionTransition(record.data?.transition, record.sessionId);
+            const group = transitionsByTarget.get(transition.target.runtimeEventId) ?? [];
+            group.push(record);
+            transitionsByTarget.set(transition.target.runtimeEventId, group);
+        }
+    }
+    // ArchiveRead can itself be archived. Resolve its referenced target first,
+    // then rebuild this result's transitions against its final copied projection.
+    const finishTarget = (sourceId) => {
+        if (finished.has(sourceId))
+            return;
+        if (visiting.has(sourceId))
+            throw new Error('Cyclic copied archive reference');
+        visiting.add(sourceId);
+        const target = clonedEventBySourceId.get(sourceId);
+        if (target?.content?.kind === 'function_response' && target.content.name === 'ArchiveRead') {
+            const resolveResult = (value) => rewriteArchiveReadResult(value, references, (ref) => {
+                const identity = parseToolResultArchiveResourceRef(ref);
+                if (identity?.storage === 'ledger' && clonedEventBySourceId.has(identity.runtimeEventId))
+                    finishTarget(identity.runtimeEventId);
+            });
+            target.content.result = resolveResult(target.content.result);
+            const projection = target.content.modelProjection;
+            if (projection?.kind === 'json')
+                target.content.modelProjection = {
+                    ...projection,
+                    value: resolveResult(projection.value),
+                };
+        }
+        for (const record of transitionsByTarget.get(sourceId) ?? []) {
+            clonedTransitions.set(record, cloneModelProjectionTransition(record, references, clonedEventBySourceId, transitionIds, transitionState));
+        }
+        visiting.delete(sourceId);
+        finished.add(sourceId);
+    };
+    for (const sourceId of clonedEventBySourceId.keys())
+        finishTarget(sourceId);
+    for (const event of clonedEventBySourceId.values()) {
+        if (event.content?.kind === 'text')
+            event.content.text = rewriteLedgerArchiveText(event.content.text, references);
+        if (event.content?.kind === 'function_call' && event.content.name === 'ArchiveRead') {
+            const args = event.content.args;
+            if (args && typeof args === 'object' && 'ref' in args && typeof args.ref === 'string') {
+                event.content = {
+                    ...event.content,
+                    args: { ...args, ref: rewriteLedgerArchiveText(args.ref, references) },
+                };
+            }
+        }
+    }
     const preparedPlans = flattenedPlans.map((plan) => {
         const runId = runIds.get(plan.run.runId);
         const clonedOperationalEvents = plan.operationalEvents.flatMap((event) => {
@@ -335,7 +396,7 @@ export async function cloneConversationRuntimeLedger(input) {
                 sessionId: input.referenceMap.targetSessionId,
                 runId,
                 eventId: operationalEventIds.get(event.id),
-            }, references, sourceCompactableEvents.get(plan.run.runId) ?? [], clonedEventBySourceId, checkpointIds, transitionIds, transitionState, providerTraceIds, logicalCallIds);
+            }, references, sourceCompactableEvents.get(plan.run.runId) ?? [], clonedEventBySourceId, checkpointIds, providerTraceIds, logicalCallIds, clonedTransitions);
             return clonedEvent ? [clonedEvent] : [];
         });
         const terminalEvent = plan.terminal.kind === 'fact'
@@ -351,7 +412,22 @@ export async function cloneConversationRuntimeLedger(input) {
             terminalEvent,
         };
     });
-    const copiedMessages = input.copiedMessages.map((message) => rewriteConversationCopyMessage(message, references));
+    const archiveReadCalls = new Set(flattenedPlans.flatMap((plan) => plan.events.flatMap((event) => event.content?.kind === 'function_response' && event.content.name === 'ArchiveRead'
+        ? [`${event.turnId}:${event.content.id}`]
+        : [])));
+    const copiedMessages = input.copiedMessages.map((message) => {
+        const copied = rewriteConversationCopyMessage(message, references);
+        if (copied.type === 'user' || copied.type === 'assistant')
+            return { ...copied, text: rewriteLedgerArchiveText(copied.text, references) };
+        if (copied.type === 'tool_result' &&
+            archiveReadCalls.has(`${copied.turnId}:${copied.toolUseId}`)) {
+            return {
+                ...copied,
+                content: rewriteArchiveReadResult(copied.content, references),
+            };
+        }
+        return copied;
+    });
     const importedSourceEventIds = new Set();
     const orderedBatches = input.plan.inlineRuntimeEvents.flatMap((event) => {
         const cloned = clonedEventBySourceId.get(event.id);
@@ -400,6 +476,33 @@ export async function cloneConversationRuntimeLedger(input) {
         })),
     };
 }
+function rewriteLedgerArchiveText(text, references) {
+    for (const [source, target] of references.ledgerArchives ?? [])
+        text = text.split(source).join(target.resourceRef);
+    return text;
+}
+/** Only ArchiveRead's defined envelope is rewritten, never its opaque content/items. */
+function rewriteArchiveReadResult(value, references, before) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const record = value;
+    if (record.kind === 'json')
+        return { ...record, value: rewriteArchiveReadResult(record.value, references, before) };
+    if (record.kind !== 'tool_result_archive' || typeof record.ref !== 'string')
+        return value;
+    before?.(record.ref);
+    const mapped = references.ledgerArchives?.get(record.ref);
+    if (!mapped)
+        return value;
+    return {
+        ...record,
+        ref: mapped.resourceRef,
+        ...(record.storage === 'ledger' && typeof record.runtimeEventId === 'string'
+            ? { runtimeEventId: mapped.runtimeEventId }
+            : {}),
+        ...(typeof record.originalBytes === 'number' ? { originalBytes: mapped.originalBytes } : {}),
+    };
+}
 async function loadConversationCopyRunEvents(sourceRuns, sourceEvents, copyTurnIds, runtimeEventStore) {
     const copiedTurnIds = new Set(copyTurnIds);
     return Promise.all(sourceRuns.flatMap((run) => {
@@ -546,7 +649,7 @@ export function collectConversationCopySessionFileRefs(input) {
     }
     return refs;
 }
-function cloneAgentRunEvent(event, ids, references, sourceCompactableEvents, clonedRuntimeEvents, checkpointIds, transitionIds, transitionState, providerTraceIds, logicalCallIds) {
+function cloneAgentRunEvent(event, ids, references, sourceCompactableEvents, clonedRuntimeEvents, checkpointIds, providerTraceIds, logicalCallIds, clonedTransitions) {
     if (event.type === 'event_corrupt') {
         throw new Error(`Cannot copy corrupt AgentRun event ${event.id}`);
     }
@@ -601,7 +704,7 @@ function cloneAgentRunEvent(event, ids, references, sourceCompactableEvents, clo
         const checkpoint = buildHistoryCompactCheckpoint({
             sessionId: references.targetSessionId,
             coveredRuntimeEvents,
-            summary: sourceCheckpoint.summary,
+            summary: rewriteLedgerArchiveText(sourceCheckpoint.summary, references),
             highWaterName: sourceCheckpoint.highWaterName,
             highWaterSeq: sourceCheckpoint.highWaterSeq,
             now: sourceCheckpoint.createdAt,
@@ -622,7 +725,7 @@ function cloneAgentRunEvent(event, ids, references, sourceCompactableEvents, clo
         };
     }
     else if (event.type === MODEL_PROJECTION_TRANSITION_EVENT_TYPE) {
-        const cloned = cloneModelProjectionTransition(event, references, clonedRuntimeEvents, transitionIds, transitionState);
+        const cloned = clonedTransitions.get(event);
         // Every transition whose target is in the copied slice was gathered into
         // this run's ledger, wherever it was recorded. So a transition that finds no
         // cloned target has genuinely lost its target as well, and dropping it
@@ -660,16 +763,37 @@ function cloneModelProjectionTransition(event, references, clonedRuntimeEvents,
     const clonedTarget = clonedRuntimeEvents.get(source.target.runtimeEventId);
     if (!clonedTarget)
         return null;
-    const placeholder = source.replacement.kind === 'json' ? source.replacement.value : undefined;
-    if (!isArchivedToolResultPlaceholder(placeholder)) {
+    const rawPlaceholder = source.replacement.kind === 'json' ? source.replacement.value : undefined;
+    if (!isArchivedToolResultPlaceholder(rawPlaceholder)) {
         throw new Error(`Cannot copy unsupported model projection transition ${event.id}`);
     }
+    const placeholder = rawPlaceholder;
     const existing = transitionState.get(clonedTarget.id);
     const sourceProjection = existing?.projection ?? baseToolResultProjection(clonedTarget);
     if (!sourceProjection) {
         throw new Error(`Cannot copy model projection transition ${event.id} onto its target`);
     }
-    const rewritten = rewriteArchivedToolResult(placeholder, references);
+    let rewritten;
+    if (placeholder.rewriteVersion === 2) {
+        const { previousTransitionId: _previous, ...rest } = placeholder;
+        const serialized = serializeToolResultProjectionV1(sourceProjection);
+        rewritten = buildLedgerArchivedToolResultPlaceholder({
+            ...rest,
+            runtimeEventId: clonedTarget.id,
+            sourceProjectionDigest: durableToolResultProjectionDigest(sourceProjection),
+            bodySha256: createHash('sha256').update(serialized).digest('hex'),
+            originalBytes: Buffer.byteLength(serialized),
+            ...(source.previousTransitionId
+                ? {
+                    previousTransitionId: requiredMappedId(transitionIds, source.previousTransitionId, 'model projection transition'),
+                }
+                : {}),
+        });
+        references.ledgerArchives?.set(buildToolResultArchiveResourceRef(placeholder), rewritten);
+    }
+    else {
+        rewritten = rewriteArchivedToolResult(placeholder, references);
+    }
     const transition = buildModelProjectionTransition({
         sessionId: references.targetSessionId,
         target: {
@@ -1030,6 +1154,18 @@ function rewriteToolResultContent(content, references) {
         return { ...content, ref: rewriteStorageRef(content.ref, references) };
     }
     if (content.kind === 'archived_tool_result') {
+        if (content.rewriteVersion === 2 && content.resourceRef) {
+            const rewritten = references.ledgerArchives?.get(content.resourceRef);
+            if (!rewritten)
+                throw new Error('Cannot copy ledger archive without its committed transition');
+            return {
+                ...content,
+                runtimeEventId: rewritten.runtimeEventId,
+                resourceRef: rewritten.resourceRef,
+                bodySha256: rewritten.bodySha256,
+                originalBytes: rewritten.originalBytes,
+            };
+        }
         const snapshot = rewriteArchivedSnapshot(content, references);
         if (snapshot)
             return snapshot;
@@ -1257,6 +1393,12 @@ function rewriteProjectionArtifactRef(ref, references) {
     return rewritten;
 }
 function rewriteArchivedToolResult(value, references) {
+    if (value.rewriteVersion === 2) {
+        const rewritten = references.ledgerArchives?.get(buildToolResultArchiveResourceRef(value));
+        if (!rewritten)
+            throw new Error('Cannot copy ledger archive without its committed transition');
+        return rewritten;
+    }
     const artifactId = rewriteOwnedArtifactId(value.artifactId, references);
     const resource = value.resourceRef
         ? parseToolResultArchiveResourceRef(value.resourceRef)
@@ -1265,7 +1407,7 @@ function rewriteArchivedToolResult(value, references) {
         ...value,
         runtimeEventId: rewriteOwnedId(value.runtimeEventId, references.runtimeEventIds, 'RuntimeEvent'),
         artifactId,
-        ...(resource && artifactId !== value.artifactId
+        ...(resource && resource.storage !== 'ledger' && artifactId !== value.artifactId
             ? {
                 resourceRef: buildToolResultArchiveResourceRef({
                     ...resource,

package/node_modules/@maka/runtime/dist/github-copilot-oauth-enrollment.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { createGitHubCopilotAccountTokens, GITHUB_COPILOT_DEFAULT_API_ENDPOINT, isSupportedGitHubCopilotAccountToken, } from './subscription-credentials.js';
-import { fetchGitHubCopilotModels } from './model-fetcher.js';
+import { fetchGitHubCopilotModels, GitHubCopilotModelPolicyError } from './model-fetcher.js';
 import { ConnectionEffectHttpError } from './connection-effect-outcome.js';
 import { OAUTH_LOGIN_MAX_TOKEN_CHARS, OAuthTokenEndpointError, requestOAuthEndpointJson, } from './oauth-login.js';
 import { OAUTH_PROVIDER_CONTRACTS, OAuthDeviceAuthorizationExpiredError, oauthExpiresAt, requireOAuthBoundedString, requireOAuthDataRecord, requireOAuthPositiveInteger, } from './oauth-provider-contracts.js';
@@ -185,8 +185,8 @@ export async function verifyGitHubCopilotModelEntitlement(input) {
         // body tell us nothing about the subscription, and reporting them as
         // ineligibility would send a paying user back through a device login that
         // was never the problem.
-        if (error instanceof ConnectionEffectHttpError &&
-            (error.status === 401 || error.status === 403)) {
+        if (error instanceof GitHubCopilotModelPolicyError ||
+            (error instanceof ConnectionEffectHttpError && (error.status === 401 || error.status === 403))) {
             throw new GitHubCopilotEntitlementError({ cause: error });
         }
         throw new GitHubCopilotEntitlementUnavailableError(error instanceof ConnectionEffectHttpError ? error.status : undefined, { cause: error });

package/node_modules/@maka/runtime/dist/goal-continuation.js

@@ -418,13 +418,17 @@ export class GoalContinuationCoordinator {
             return;
         if (this.handoffHeld && lane.queue.length === 0)
             return;
+        const activity = this.deps.acquireActivity?.();
         const task = this.drainLane(lane).catch((error) => {
             if (!this.isCurrent(lane))
                 return;
             this.pauseCurrentGoal(lane, `Goal continuation coordinator failed: ${errorMessage(error)}`);
         });
         this.activeDrains.add(task);
-        void task.finally(() => this.activeDrains.delete(task));
+        void task.finally(() => {
+            this.activeDrains.delete(task);
+            activity?.release();
+        });
     }
     async drainLane(lane) {
         if (!this.isCurrent(lane) || lane.draining)