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

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

@@ -25,8 +25,7 @@ import { encodeToolStepProgress, ToolOutcomeUnknownError } from '@maka/core/even
 import { isInteractionAnswerValidForRequest, projectInteractionFormRequest, } from '@maka/core/interaction';
 import { computerUseModelCallArgs } from '@maka/core/computer-use';
 import { redactSecrets } from '@maka/core/redaction';
-import { decodeRuntimeEvent, MANAGED_MUTATION_EXECUTION_PROFILE_V1_DIGEST, MANAGED_MUTATION_EXECUTION_PROFILE_V1_SPEC, TOOL_BOUNDARY_PROTOCOL_V1, } from '@maka/core/runtime-event';
-import { isDeepStrictEqual } from 'node:util';
+import { TOOL_BOUNDARY_PROTOCOL_V1 } from '@maka/core/runtime-event';
 import { recordToolArtifactsSafely } from './tool-artifacts.js';
 import { computerActionFields, describeComputerUseArgsViolation } from './computer-use-codec.js';
 import { createToolOutputDeltaEmitter } from './tool-output-delta.js';
@@ -74,12 +73,6 @@ class RuntimeCommitBoundaryError extends Error {
         this.name = 'RuntimeCommitBoundaryError';
     }
 }
-class RuntimeManagedMutationUnsettledError extends Error {
-    constructor(cause) {
-        super(`Managed workspace mutation remains unsettled: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
-        this.name = 'RuntimeManagedMutationUnsettledError';
-    }
-}
 class ToolResultLimitError extends Error {
     constructor() {
         super('Tool result byte limit exceeded');
@@ -514,18 +507,31 @@ export class ToolRuntime {
             result: content,
             isError: true,
         }, this.input.sessionId) ?? DURABLE_TOOL_RESULT_PROJECTION_FAILURE;
-        const durableOutcome = await durableAttempt?.commitOutcome(content, true, modelProjection);
-        queue.push({
-            type: 'tool_result',
-            id: durableOutcome?.id ?? this.input.newId(),
+        await this.commitAndPublishToolResult({
+            queue,
             turnId,
-            ts: durableOutcome?.ts ?? this.input.now(),
             toolUseId,
-            ...(durableOutcome ? { operationId: durableOutcome.operationId } : {}),
             isError: true,
             content,
             modelProjection,
-            ...activityIdentity,
+            activityIdentity,
+            durableAttempt,
+        });
+    }
+    async commitAndPublishToolResult(input) {
+        const durableOutcome = await input.durableAttempt?.commitOutcome(input.content, input.isError, input.modelProjection, input.durationMs);
+        input.queue.push({
+            type: 'tool_result',
+            id: durableOutcome?.id ?? this.input.newId(),
+            turnId: input.turnId,
+            ts: durableOutcome?.ts ?? this.input.now(),
+            toolUseId: input.toolUseId,
+            ...(durableOutcome ? { operationId: durableOutcome.operationId } : {}),
+            isError: input.isError,
+            content: input.content,
+            modelProjection: input.modelProjection,
+            ...(input.durationMs !== undefined ? { durationMs: input.durationMs } : {}),
+            ...input.activityIdentity,
         });
     }
     async executeTool(tool, turnId, queue, args, ctx, stepId) {
@@ -903,38 +909,9 @@ export class ToolRuntime {
                 pauseTarget?.resume();
             }
         }
-        let managedMutationAdmission;
-        if (tool.durableExecutionProfile === 'managed_mutation_v1') {
-            if ((tool.name !== 'Write' && tool.name !== 'Edit') ||
-                tool.recoveryMode !== 'reconcile' ||
-                !tool.managedMutationTransform ||
-                !dispatchOperationId ||
-                !this.input.runtimeCommitSink ||
-                !this.input.admitManagedMutation) {
-                const reason = 'Managed workspace mutation admission is unavailable before T1';
-                await refuseBeforeDispatch(reason);
-                this.recordLoopGateOutcome(callSignature, true);
-                return this.errorReturn(reason);
-            }
-            try {
-                managedMutationAdmission = await this.input.admitManagedMutation({
-                    operationId: dispatchOperationId,
-                    toolName: tool.name,
-                    persistedArgs: structuredClone(persistedArgs),
-                    abortSignal: ctx.abortSignal,
-                });
-            }
-            catch (error) {
-                const reason = `Managed workspace mutation admission failed: ${formatSyntheticToolErrorText(error)}`;
-                await refuseBeforeDispatch(reason);
-                this.recordLoopGateOutcome(callSignature, true);
-                return this.errorReturn(reason);
-            }
-        }
         const reservedSubagentSlot = this.reserveSubagentSlot(tool);
         if (!reservedSubagentSlot) {
             await preparedExecution?.cancel();
-            await disposeManagedMutationAdmission(managedMutationAdmission);
             trace?.emit('tool', 'tool_failed', 'Tool execution rejected by runtime limit', {
                 toolUseId,
                 toolName: tool.name,
@@ -953,9 +930,6 @@ export class ToolRuntime {
                 persistedArgs,
                 modelFacingArgs,
                 abortSignal: ctx.abortSignal,
-                ...(managedMutationAdmission
-                    ? { managedMutation: managedMutationAdmission.durableDispatch }
-                    : {}),
                 ...(invocationId ? { invocationId } : {}),
                 ...(runId ? { runId } : {}),
             });
@@ -964,7 +938,6 @@ export class ToolRuntime {
             await preparedExecution?.cancel();
             if (reservedSubagentSlot)
                 this.releaseSubagentSlot(tool);
-            await disposeManagedMutationAdmission(managedMutationAdmission);
             throw error;
         }
         publishCallEvent(buildCallEvent('dispatch'));
@@ -1063,145 +1036,41 @@ export class ToolRuntime {
                 const invokeTool = () => preparedExecution
                     ? preparedExecution.execute(toolContext)
                     : tool.impl(structuredClone(executionArgs), toolContext);
-                const invokeManagedTransform = () => tool.managedMutationTransform(structuredClone(executionArgs));
-                const prepareOperationValue = async (immutableSnapshot = false) => {
-                    const rawResult = await (immutableSnapshot ? invokeManagedTransform() : invokeTool());
-                    const result = immutableSnapshot
-                        ? snapshotManagedToolResult(rawResult, ctx.maxResultBytes)
-                        : rawResult;
-                    if (!immutableSnapshot &&
-                        ctx.maxResultBytes !== undefined &&
+                const prepareOperationValue = async () => {
+                    const result = await invokeTool();
+                    if (ctx.maxResultBytes !== undefined &&
                         serializedByteLength(result, ctx.maxResultBytes) > ctx.maxResultBytes) {
                         throw new ToolResultLimitError();
                     }
-                    const content = immutableSnapshot
-                        ? Object.freeze(coerceResultContent(result))
-                        : coerceResultContent(result);
+                    const content = coerceResultContent(result);
                     const projected = this.projectToolResult(tool, turnId, toolUseId, executionArgs, result);
                     const modelProjection = isPromiseLike(projected) ? await projected : projected;
-                    const outcome = {
+                    return {
+                        result,
                         content,
                         isError: deriveToolResultStatus(content, result) !== 'success',
                         durationMs: this.input.now() - startedAt,
                         modelProjection,
                     };
-                    const value = {
-                        result,
-                        outcome: immutableSnapshot ? Object.freeze(outcome) : outcome,
-                    };
-                    return immutableSnapshot ? Object.freeze(value) : value;
                 };
-                let settledExecution;
-                if (managedMutationAdmission) {
-                    const operationLifecycle = { state: 'open' };
-                    let operationPromise;
-                    let runtimeOwnedValue;
-                    const executeManagedOperation = () => {
-                        if (operationLifecycle.state !== 'open') {
-                            if (operationLifecycle.state === 'closed') {
-                                return Promise.reject(new Error('Managed mutation operation capability is closed'));
-                            }
-                            return Promise.reject(new Error('Managed mutation owner invoked the operation more than once'));
-                        }
-                        operationLifecycle.state = 'running';
-                        operationPromise = (async () => {
-                            try {
-                                const value = await prepareOperationValue(true);
-                                runtimeOwnedValue = value;
-                                return {
-                                    // The canonical content is already recursively immutable, so
-                                    // the owner can read it without receiving a mutable alias.
-                                    content: value.outcome.content,
-                                    isError: value.outcome.isError,
-                                    durationMs: value.outcome.durationMs,
-                                    modelProjection: value.outcome.modelProjection,
-                                };
-                            }
-                            finally {
-                                if (operationLifecycle.state === 'running') {
-                                    operationLifecycle.state = 'settled';
-                                }
-                            }
-                        })();
-                        // Runtime also observes the promise so a careless owner cannot
-                        // turn an un-awaited operation rejection into an unhandled one.
-                        void operationPromise.catch(() => undefined);
-                        return operationPromise;
-                    };
-                    let settlement;
-                    let ownerFailed = false;
-                    let ownerError;
-                    try {
-                        settlement = await managedMutationAdmission.execute(executeManagedOperation);
-                    }
-                    catch (error) {
-                        ownerFailed = true;
-                        ownerError = error;
-                    }
-                    const ownerSettledWhileOperationRunning = operationLifecycle.state === 'running';
-                    if (ownerSettledWhileOperationRunning) {
-                        try {
-                            await operationPromise;
-                        }
-                        catch {
-                            // The terminal state is invalid regardless of how the detached
-                            // operation settles. Join it so no side effect can occur later.
-                        }
-                        finally {
-                            operationLifecycle.state = 'closed';
-                        }
-                        throw new RuntimeManagedMutationUnsettledError(new Error('Managed mutation owner settled before the operation completed', {
-                            ...(ownerFailed ? { cause: ownerError } : {}),
-                        }));
-                    }
-                    operationLifecycle.state = 'closed';
-                    if (ownerFailed) {
-                        // Once managed T1 is durable, an admission/owner failure may never
-                        // fall through to the generic synthetic T2 path. Only the owner can
-                        // prove that a successor was accepted or the candidate was safely
-                        // discarded; every other failure remains unsettled for recovery.
-                        throw new RuntimeManagedMutationUnsettledError(ownerError);
-                    }
-                    const normalized = normalizeManagedMutationSettlement(settlement, ctx.maxResultBytes);
-                    if (normalized.kind === 'workspace_successor_committed') {
-                        if (!runtimeOwnedValue) {
-                            throw new RuntimeManagedMutationUnsettledError(new Error('Managed mutation owner committed success without executing the operation'));
-                        }
-                        settledExecution = {
-                            kind: 'managed',
-                            value: runtimeOwnedValue,
-                            durableOutcome: normalized.durableOutcome,
-                        };
-                    }
-                    else {
-                        settledExecution = {
-                            kind: 'managed',
-                            value: normalized.value,
-                            durableOutcome: normalized.durableOutcome,
-                        };
-                    }
-                }
-                else {
-                    settledExecution = { kind: 'generic', value: await prepareOperationValue() };
-                }
-                const { result, outcome } = settledExecution.value;
+                const { result, content, isError, durationMs, modelProjection } = await prepareOperationValue();
                 output.flush();
-                const { content, durationMs, modelProjection } = outcome;
                 // Keep the full provider-facing terminal classification. `isError` is
                 // sufficient for the durable response envelope, but it intentionally
                 // collapses `aborted` into an error bit and therefore cannot drive live
                 // tool status, telemetry, or subagent lifecycle projection.
                 const toolResultStatus = deriveToolResultStatus(content, result);
-                let durableOutcome;
-                if (settledExecution.kind === 'managed') {
-                    if (!durableAttempt) {
-                        throw new RuntimeManagedMutationUnsettledError(new Error('Managed mutation settlement has no durable T1 attempt'));
-                    }
-                    durableOutcome = durableAttempt.adoptCommittedOutcome(settledExecution.durableOutcome, content, outcome.isError, modelProjection, durationMs);
-                }
-                else {
-                    durableOutcome = await durableAttempt?.commitOutcome(content, outcome.isError, modelProjection, durationMs);
-                }
+                await this.commitAndPublishToolResult({
+                    queue,
+                    turnId,
+                    toolUseId,
+                    isError,
+                    content,
+                    modelProjection,
+                    durationMs,
+                    activityIdentity,
+                    durableAttempt,
+                });
                 if (hasSandboxDenial(content)) {
                     const denialKey = sandboxDenialKey(tool.name, this.input.header.cwd, executionArgs);
                     this.recentSandboxDenials.add(denialKey);
@@ -1216,19 +1085,6 @@ export class ToolRuntime {
                         commandHash: denialKey,
                     });
                 }
-                queue.push({
-                    type: 'tool_result',
-                    id: durableOutcome?.id ?? this.input.newId(),
-                    turnId,
-                    ts: durableOutcome?.ts ?? this.input.now(),
-                    toolUseId,
-                    ...(durableOutcome ? { operationId: durableOutcome.operationId } : {}),
-                    isError: toolResultStatus !== 'success',
-                    content,
-                    modelProjection,
-                    durationMs,
-                    ...activityIdentity,
-                });
                 this.input.recordToolInvocation?.({
                     sessionId: this.input.sessionId,
                     turnId,
@@ -1286,17 +1142,8 @@ export class ToolRuntime {
             }
         }
         catch (err) {
-            if (err instanceof RuntimeCommitBoundaryError ||
-                err instanceof RuntimeManagedMutationUnsettledError) {
+            if (err instanceof RuntimeCommitBoundaryError)
                 throw err;
-            }
-            // Admission exists only after the owner has selected managed mode and
-            // Runtime has committed its T1 dispatch. From that point onward every
-            // normalization, size check, adoption, publication, and telemetry error
-            // is recovery-owned. It may never fall through to generic synthetic T2.
-            if (managedMutationAdmission) {
-                throw new RuntimeManagedMutationUnsettledError(err);
-            }
             if (isInteractionControlError(err))
                 throw err;
             output.flush();
@@ -1323,19 +1170,16 @@ export class ToolRuntime {
                 const terminalResult = this.errorReturn(terminalFailure.message);
                 const projected = this.projectToolResult(tool, turnId, toolUseId, executionArgs, terminalFailure.content);
                 const modelProjection = isPromiseLike(projected) ? await projected : projected;
-                const durableOutcome = await durableAttempt?.commitOutcome(terminalFailure.content, true, modelProjection, durationMs);
-                queue.push({
-                    type: 'tool_result',
-                    id: durableOutcome?.id ?? this.input.newId(),
+                await this.commitAndPublishToolResult({
+                    queue,
                     turnId,
-                    ts: durableOutcome?.ts ?? this.input.now(),
                     toolUseId,
-                    ...(durableOutcome ? { operationId: durableOutcome.operationId } : {}),
                     isError: true,
                     content: terminalFailure.content,
                     modelProjection,
                     durationMs,
-                    ...activityIdentity,
+                    activityIdentity,
+                    durableAttempt,
                 });
                 this.input.recordToolInvocation?.({
                     sessionId: this.input.sessionId,
@@ -1404,7 +1248,6 @@ export class ToolRuntime {
             this.recordLoopGateOutcome(callSignature, attemptFailed, attemptBoundaryKind, attemptBoundaryDetails);
             if (reservedSubagentSlot)
                 this.releaseSubagentSlot(tool);
-            await disposeManagedMutationAdmission(managedMutationAdmission);
         }
     }
     async prepareDurableToolAttempt(input) {
@@ -1486,7 +1329,6 @@ export class ToolRuntime {
                     toolName: input.tool.name,
                     canonicalArgsHash,
                     recoveryMode,
-                    ...(input.managedMutation ? { managedMutation: input.managedMutation } : {}),
                 },
             },
             refs: {
@@ -1501,22 +1343,6 @@ export class ToolRuntime {
             },
         };
         try {
-            if (input.managedMutation) {
-                decodeRuntimeEvent(dispatchEvent);
-                const persistedPath = input.persistedArgs &&
-                    typeof input.persistedArgs === 'object' &&
-                    !Array.isArray(input.persistedArgs)
-                    ? input.persistedArgs.path
-                    : undefined;
-                if ((input.tool.name !== 'Write' && input.tool.name !== 'Edit') ||
-                    typeof persistedPath !== 'string' ||
-                    input.managedMutation.expectedPath !== persistedPath ||
-                    input.managedMutation.pathPolicyVersion !== 3 ||
-                    input.managedMutation.executionProfileDigest !==
-                        MANAGED_MUTATION_EXECUTION_PROFILE_V1_DIGEST) {
-                    throw new Error('Managed mutation admission does not match the durable tool call');
-                }
-            }
             this.assertDurableDispatchNotAborted(input.tool.name, input.abortSignal);
             const prepared = await sink.commitToolPrepared({
                 operationId,
@@ -1571,7 +1397,6 @@ export class ToolRuntime {
         let committedOutcome;
         return {
             operationId,
-            responseEventId: `${operationId}_response`,
             commitOutcome: async (result, isError, modelProjection, durationMs) => {
                 if (committedOutcome)
                     return committedOutcome;
@@ -1607,17 +1432,6 @@ export class ToolRuntime {
                 this.durableToolAttempts.delete(durableAttemptKey(input.startEvent.turnId, input.startEvent.toolUseId));
                 return committedOutcome;
             },
-            adoptCommittedOutcome: (event, result, isError, modelProjection, durationMs) => {
-                if (committedOutcome)
-                    return committedOutcome;
-                const expected = buildResponseEvent(result, isError, modelProjection, durationMs, event.ts);
-                if (!Number.isFinite(event.ts) || !isDeepStrictEqual(event, expected)) {
-                    throw new RuntimeCommitBoundaryError('T2', new Error('Managed mutation settlement returned a mismatched durable outcome'));
-                }
-                committedOutcome = { id: event.id, operationId, ts: event.ts };
-                this.durableToolAttempts.delete(durableAttemptKey(input.startEvent.turnId, input.startEvent.toolUseId));
-                return committedOutcome;
-            },
         };
     }
     admitToolForStep(tool, stepId) {
@@ -1755,6 +1569,7 @@ export class ToolRuntime {
                             toolCallId: input.toolUseId,
                             agentProfile: spawnInput.agentProfile,
                             ...(spawnInput.subagentId ? { subagentId: spawnInput.subagentId } : {}),
+                            ...(spawnInput.executorId ? { executorId: spawnInput.executorId } : {}),
                             prompt: spawnInput.prompt,
                             ...(spawnInput.swarm ? { swarm: spawnInput.swarm } : {}),
                             abortSignal,
@@ -2577,64 +2392,6 @@ function uncertainOutcomeSignalFromError(error) {
         retrySafe: false,
     };
 }
-function normalizeManagedMutationSettlement(settlement, maxResultBytes) {
-    if (!settlement || typeof settlement !== 'object' || Array.isArray(settlement)) {
-        throw new Error('Managed mutation owner returned an invalid settlement');
-    }
-    const record = settlement;
-    const kind = record.kind;
-    if (kind === 'unsettled') {
-        throw new RuntimeManagedMutationUnsettledError(record.error);
-    }
-    if (kind !== 'workspace_successor_committed' &&
-        kind !== 'no_workspace_change_committed' &&
-        kind !== 'operation_failed_no_effect_committed') {
-        throw new Error('Managed mutation owner returned an unknown settlement kind');
-    }
-    const durableOutcomeValue = Object.hasOwn(record, 'durableOutcome')
-        ? record.durableOutcome
-        : undefined;
-    if (!durableOutcomeValue ||
-        typeof durableOutcomeValue !== 'object' ||
-        Array.isArray(durableOutcomeValue)) {
-        throw new Error('Managed mutation settlement has no durable outcome');
-    }
-    const durableOutcome = durableOutcomeValue;
-    if (kind === 'workspace_successor_committed') {
-        return {
-            kind,
-            durableOutcome,
-        };
-    }
-    if (!Object.hasOwn(record, 'providerResult')) {
-        throw new Error('Managed no-effect settlement has no provider result');
-    }
-    const providerResult = snapshotManagedToolResult(record.providerResult, maxResultBytes);
-    const response = durableOutcome.content;
-    const expectedError = kind === 'operation_failed_no_effect_committed';
-    if (response?.kind !== 'function_response' ||
-        response.modelProjection === undefined ||
-        (expectedError ? response.isError !== true : response.isError === true)) {
-        throw new Error('Managed no-effect settlement has the wrong durable outcome state');
-    }
-    const content = Object.freeze(coerceResultContent(providerResult));
-    const outcome = Object.freeze({
-        content,
-        isError: expectedError,
-        modelProjection: response.modelProjection,
-        durationMs: typeof durableOutcome.actions?.stateDelta?.durationMs === 'number'
-            ? durableOutcome.actions.stateDelta.durationMs
-            : 0,
-    });
-    return {
-        kind,
-        value: Object.freeze({
-            result: providerResult,
-            outcome,
-        }),
-        durableOutcome,
-    };
-}
 function coerceResultContent(raw) {
     if (typeof raw === 'string')
         return { kind: 'text', text: raw };
@@ -2654,175 +2411,6 @@ function coerceResultContent(raw) {
     }
     return { kind: 'text', text: String(raw ?? '') };
 }
-/**
- * Builds the one durable JSON representation while enforcing its byte budget.
- * The walk stops at the first over-budget token and never retains a mutable
- * tool/owner-owned object alias.
- */
-const MANAGED_RESULT_MAX_BYTES = MANAGED_MUTATION_EXECUTION_PROFILE_V1_SPEC.resultSnapshot.maxBytes;
-const MANAGED_RESULT_MAX_DEPTH = MANAGED_MUTATION_EXECUTION_PROFILE_V1_SPEC.resultSnapshot.maxDepth;
-const MANAGED_RESULT_MAX_NODES = MANAGED_MUTATION_EXECUTION_PROFILE_V1_SPEC.resultSnapshot.maxNodes;
-const MANAGED_RESULT_MAX_PROPERTIES = MANAGED_MUTATION_EXECUTION_PROFILE_V1_SPEC.resultSnapshot.maxProperties;
-const MANAGED_RESULT_MAX_ARRAY_LENGTH = MANAGED_MUTATION_EXECUTION_PROFILE_V1_SPEC.resultSnapshot.maxArrayLength;
-function snapshotManagedToolResult(value, maxBytes) {
-    const budget = {
-        bytes: 0,
-        limit: maxBytes === undefined
-            ? MANAGED_RESULT_MAX_BYTES
-            : Number.isFinite(maxBytes) && maxBytes >= 0
-                ? Math.min(Math.floor(maxBytes), MANAGED_RESULT_MAX_BYTES)
-                : 0,
-        nodes: 0,
-        properties: 0,
-        active: new WeakSet(),
-    };
-    return snapshotStrictJsonValue(value, budget, '$', 0);
-}
-function snapshotStrictJsonValue(value, budget, path, depth) {
-    budget.nodes += 1;
-    if (budget.nodes > MANAGED_RESULT_MAX_NODES || depth > MANAGED_RESULT_MAX_DEPTH) {
-        throw new ToolResultLimitError();
-    }
-    if (value === null) {
-        consumeManagedResultBytes(budget, 4);
-        return null;
-    }
-    if (typeof value === 'string') {
-        consumeManagedJsonStringBytes(budget, value);
-        return value;
-    }
-    if (typeof value === 'boolean') {
-        consumeManagedResultBytes(budget, value ? 4 : 5);
-        return value;
-    }
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value)) {
-            throw new Error(`Managed tool result must be strict JSON: ${path} is not finite`);
-        }
-        const canonical = Object.is(value, -0) ? 0 : value;
-        consumeManagedResultBytes(budget, JSON.stringify(canonical).length);
-        return canonical;
-    }
-    if (value === undefined) {
-        throw new Error(`Managed tool result must be strict JSON: ${path} is undefined`);
-    }
-    if (typeof value !== 'object') {
-        throw new Error(`Managed tool result must be strict JSON: ${path} has an unsupported type`);
-    }
-    if (budget.active.has(value)) {
-        throw new Error(`Managed tool result must be strict JSON: ${path} is cyclic`);
-    }
-    if (!Array.isArray(value)) {
-        const prototype = Object.getPrototypeOf(value);
-        if (prototype !== Object.prototype && prototype !== null) {
-            throw new Error(`Managed tool result must be strict JSON: ${path} is not a plain object`);
-        }
-    }
-    if ('toJSON' in value) {
-        throw new Error(`Managed tool result must be strict JSON: ${path} defines toJSON`);
-    }
-    budget.active.add(value);
-    try {
-        if (Array.isArray(value)) {
-            if (value.length > MANAGED_RESULT_MAX_ARRAY_LENGTH)
-                throw new ToolResultLimitError();
-            consumeManagedResultBytes(budget, 1);
-            const output = [];
-            for (let index = 0; index < value.length; index += 1) {
-                if (index > 0)
-                    consumeManagedResultBytes(budget, 1);
-                const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
-                if (!descriptor) {
-                    throw new Error(`Managed tool result must be strict JSON: ${path} is a sparse array`);
-                }
-                if (!('value' in descriptor)) {
-                    throw new Error(`Managed tool result must be strict JSON: ${path}[${index}] is an accessor`);
-                }
-                output.push(snapshotStrictJsonValue(descriptor.value, budget, `${path}[${index}]`, depth + 1));
-            }
-            consumeManagedResultBytes(budget, 1);
-            return Object.freeze(output);
-        }
-        consumeManagedResultBytes(budget, 1);
-        const output = {};
-        let emitted = 0;
-        for (const key in value) {
-            if (!Object.hasOwn(value, key))
-                continue;
-            budget.properties += 1;
-            if (budget.properties > MANAGED_RESULT_MAX_PROPERTIES)
-                throw new ToolResultLimitError();
-            if (emitted > 0)
-                consumeManagedResultBytes(budget, 1);
-            consumeManagedJsonStringBytes(budget, key);
-            consumeManagedResultBytes(budget, 1);
-            const descriptor = Object.getOwnPropertyDescriptor(value, key);
-            if (!descriptor || !('value' in descriptor)) {
-                throw new Error(`Managed tool result must be strict JSON: ${path}.${key} is an accessor`);
-            }
-            Object.defineProperty(output, key, {
-                configurable: true,
-                enumerable: true,
-                value: snapshotStrictJsonValue(descriptor.value, budget, `${path}.${key}`, depth + 1),
-                writable: true,
-            });
-            emitted += 1;
-        }
-        consumeManagedResultBytes(budget, 1);
-        return Object.freeze(output);
-    }
-    finally {
-        budget.active.delete(value);
-    }
-}
-function consumeManagedJsonStringBytes(budget, value) {
-    consumeManagedResultBytes(budget, 1);
-    for (let index = 0; index < value.length; index += 1) {
-        const code = value.charCodeAt(index);
-        let bytes;
-        if (code === 0x22 ||
-            code === 0x5c ||
-            code === 0x08 ||
-            code === 0x09 ||
-            code === 0x0a ||
-            code === 0x0c ||
-            code === 0x0d) {
-            bytes = 2;
-        }
-        else if (code <= 0x1f) {
-            bytes = 6;
-        }
-        else if (code >= 0xd800 && code <= 0xdbff) {
-            const next = value.charCodeAt(index + 1);
-            if (next >= 0xdc00 && next <= 0xdfff) {
-                bytes = 4;
-                index += 1;
-            }
-            else {
-                bytes = 6;
-            }
-        }
-        else if (code >= 0xdc00 && code <= 0xdfff) {
-            bytes = 6;
-        }
-        else if (code <= 0x7f) {
-            bytes = 1;
-        }
-        else if (code <= 0x7ff) {
-            bytes = 2;
-        }
-        else {
-            bytes = 3;
-        }
-        consumeManagedResultBytes(budget, bytes);
-    }
-    consumeManagedResultBytes(budget, 1);
-}
-function consumeManagedResultBytes(budget, bytes) {
-    if (budget.bytes > budget.limit - bytes)
-        throw new ToolResultLimitError();
-    budget.bytes += bytes;
-}
 function coerceTerminalFailure(tool, cwd, args, err) {
     if (tool.name !== 'Bash' || !err || typeof err !== 'object')
         return null;
@@ -2995,15 +2583,6 @@ function isAmbiguousComputerFailure(raw) {
 function durableAttemptKey(turnId, toolUseId) {
     return JSON.stringify([turnId, toolUseId]);
 }
-async function disposeManagedMutationAdmission(admission) {
-    try {
-        await admission?.dispose();
-    }
-    catch {
-        // Cleanup is best-effort. It must never rewrite a durable terminal outcome,
-        // nor obscure the primary pre-T1 or execution failure.
-    }
-}
 function providerToolErrorMessage(output) {
     if (!output || typeof output !== 'object' || Array.isArray(output))
         return undefined;