@ouro.bot/cli 0.1.0-alpha.793 → 0.1.0-alpha.794

package/dist/heart/core.js

@@ -1127,6 +1127,11 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let providerIterations = 0;
     const requiredToolCallNames = [...new Set(options?.requiredToolCalls?.names ?? [])];
     const dispatchedRequiredToolCalls = new Set();
+    const requiredCorrectionMarker = Symbol("requiredCorrection");
+    const messagesWithoutRequiredCorrections = () => messages.filter((message) => message[requiredCorrectionMarker] !== true);
+    const removeRequiredCorrections = () => {
+        messages.splice(0, messages.length, ...messagesWithoutRequiredCorrections());
+    };
     const pendingRequiredToolCalls = () => {
         const missing = requiredToolCallNames.filter((name) => !dispatchedRequiredToolCalls.has(name));
         return missing.length > 0
@@ -1136,7 +1141,12 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     const queueRequiredCorrection = (message, limitContext) => {
         if (providerIterations >= exports.MAX_PROVIDER_ITERATIONS)
             throw new Error(`provider iteration limit exhausted at response ${exports.MAX_PROVIDER_ITERATIONS} ${limitContext}`);
-        messages.push({ role: "user", content: message });
+        const correction = {
+            role: "user",
+            content: message,
+            [requiredCorrectionMarker]: true,
+        };
+        messages.push(correction);
         providerRuntime.resetTurnState(messages);
     };
     const toolLoopState = (0, tool_loop_1.createToolLoopState)();
@@ -1211,307 +1221,398 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     // Rebase provider-owned turn state from canonical messages at user-turn start.
     // This prevents stale provider caches from replaying prior-turn context.
     providerRuntime.resetTurnState(messages);
-    while (!done) {
-        // Channel-based tool filtering:
-        // - Private runtime: exclude send_message (delivery via surface), observe (no one to observe)
-        // - All outward channels (1:1, group, reaction): observe available
-        //
-        // ponder, settle/rest, surface, and observe are always assembled based on channel context.
-        // ponder is available in ALL channels (outer: think privately, inner: keep turning).
-        // Private runtime gets restTool instead of settleTool (rest = end turn, gated by attention queue).
-        // toolChoiceRequired only controls whether tool_choice: "required" is set in the API call.
-        const isPrivateRuntimeChannel = channel === "inner";
-        const privateRuntimeHabitCanSendMessage = isPrivateRuntimeChannel
-            && habitSession?.toolPolicy.outwardMessagingAllowed === true
-            && habitSession.toolPolicy.grantedTools.includes("send_message");
-        const privateRuntimeHabitCanSurface = isPrivateRuntimeChannel
-            && (!habitSession || (habitSession.toolPolicy.outwardMessagingAllowed === true
-                && habitSession.toolPolicy.grantedTools.includes("surface")));
-        const filteredBaseTools = isPrivateRuntimeChannel
-            ? baseTools.filter((t) => privateRuntimeHabitCanSendMessage || t.function.name !== "send_message")
-            : baseTools;
-        const unscopedOrdinaryActiveTools = [
-            ...filteredBaseTools,
-            ...(augmentedToolContext?.noSend === true ? [] : [tools_1.ponderTool]),
-            ...(isPrivateRuntimeChannel && privateRuntimeHabitCanSurface ? [tools_2.surfaceToolDef] : []),
-            ...(isPrivateRuntimeChannel ? [tools_1.restTool] : []),
-            ...(!isPrivateRuntimeChannel ? [tools_1.observeTool] : []),
-            ...(!isPrivateRuntimeChannel ? [tools_1.settleTool] : []),
-            ...(isChatStyleChannel(channel ?? "") ? [tools_1.speakTool] : []),
-        ];
-        const ordinaryActiveTools = relationshipToolNames
-            ? unscopedOrdinaryActiveTools.filter((tool) => relationshipToolNames.includes(tool.function.name))
-            : unscopedOrdinaryActiveTools;
-        const candidateActiveTools = options?.toolProfile === "sanctuary-health-private"
-            ? (() => {
-                const sendTools = baseTools.filter((tool) => tool.function.name === "send_message");
-                if (channel !== "inner" || sendTools.length !== 1 || baseTools.length !== 1) {
-                    throw new Error("sanctuary-health-private requires inner channel with exactly one canonical send_message definition");
-                }
-                return [sendTools[0], tools_1.restTool];
-            })()
-            : ordinaryActiveTools;
-        const candidateToolNames = new Set(candidateActiveTools.map((tool) => tool.function.name));
-        const unadvertisedRequiredTool = requiredToolCallNames.find((name) => !candidateToolNames.has(name));
-        if (unadvertisedRequiredTool) {
-            (0, runtime_1.emitNervesEvent)({ level: "error", component: "engine", event: "engine.required_tool_unadvertised", message: "required tool is not advertised for the active channel", meta: { toolName: unadvertisedRequiredTool, channel: String(channel) } });
-            throw new Error(`required tool is not advertised for this channel: ${unadvertisedRequiredTool}`);
-        }
-        const forcedHistoricalToolNames = new Set(unresolvedHistoricalEffects
-            .map((effect) => effect.name)
-            .filter((name) => candidateToolNames.has(name)));
-        const forcingHistoricalEffect = forcedHistoricalToolNames.size > 0;
-        const activeTools = forcingHistoricalEffect
-            ? candidateActiveTools.filter((tool) => forcedHistoricalToolNames.has(tool.function.name))
-            : candidateActiveTools;
-        const activeToolNames = new Set(activeTools.map((tool) => tool.function.name));
-        const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
-        if (steeringFollowUps.length > 0) {
-            const hasSupersedingFollowUp = steeringFollowUps.some((followUp) => followUp.effect === "clear_and_supersede");
-            if (hasSupersedingFollowUp) {
-                mustResolveBeforeHandoffActive = false;
-                options?.setMustResolveBeforeHandoff?.(false);
-                outcome = "superseded";
-                break;
+    try {
+        while (!done) {
+            // Channel-based tool filtering:
+            // - Private runtime: exclude send_message (delivery via surface), observe (no one to observe)
+            // - All outward channels (1:1, group, reaction): observe available
+            //
+            // ponder, settle/rest, surface, and observe are always assembled based on channel context.
+            // ponder is available in ALL channels (outer: think privately, inner: keep turning).
+            // Private runtime gets restTool instead of settleTool (rest = end turn, gated by attention queue).
+            // toolChoiceRequired only controls whether tool_choice: "required" is set in the API call.
+            const isPrivateRuntimeChannel = channel === "inner";
+            const privateRuntimeHabitCanSendMessage = isPrivateRuntimeChannel
+                && habitSession?.toolPolicy.outwardMessagingAllowed === true
+                && habitSession.toolPolicy.grantedTools.includes("send_message");
+            const privateRuntimeHabitCanSurface = isPrivateRuntimeChannel
+                && (!habitSession || (habitSession.toolPolicy.outwardMessagingAllowed === true
+                    && habitSession.toolPolicy.grantedTools.includes("surface")));
+            const filteredBaseTools = isPrivateRuntimeChannel
+                ? baseTools.filter((t) => privateRuntimeHabitCanSendMessage || t.function.name !== "send_message")
+                : baseTools;
+            const unscopedOrdinaryActiveTools = [
+                ...filteredBaseTools,
+                ...(augmentedToolContext?.noSend === true ? [] : [tools_1.ponderTool]),
+                ...(isPrivateRuntimeChannel && privateRuntimeHabitCanSurface ? [tools_2.surfaceToolDef] : []),
+                ...(isPrivateRuntimeChannel ? [tools_1.restTool] : []),
+                ...(!isPrivateRuntimeChannel ? [tools_1.observeTool] : []),
+                ...(!isPrivateRuntimeChannel ? [tools_1.settleTool] : []),
+                ...(isChatStyleChannel(channel ?? "") ? [tools_1.speakTool] : []),
+            ];
+            const ordinaryActiveTools = relationshipToolNames
+                ? unscopedOrdinaryActiveTools.filter((tool) => relationshipToolNames.includes(tool.function.name))
+                : unscopedOrdinaryActiveTools;
+            const candidateActiveTools = options?.toolProfile === "sanctuary-health-private"
+                ? (() => {
+                    const sendTools = baseTools.filter((tool) => tool.function.name === "send_message");
+                    if (channel !== "inner" || sendTools.length !== 1 || baseTools.length !== 1) {
+                        throw new Error("sanctuary-health-private requires inner channel with exactly one canonical send_message definition");
+                    }
+                    return [sendTools[0], tools_1.restTool];
+                })()
+                : ordinaryActiveTools;
+            const candidateToolNames = new Set(candidateActiveTools.map((tool) => tool.function.name));
+            const unadvertisedRequiredTool = requiredToolCallNames.find((name) => !candidateToolNames.has(name));
+            if (unadvertisedRequiredTool) {
+                (0, runtime_1.emitNervesEvent)({ level: "error", component: "engine", event: "engine.required_tool_unadvertised", message: "required tool is not advertised for the active channel", meta: { toolName: unadvertisedRequiredTool, channel: String(channel) } });
+                throw new Error(`required tool is not advertised for this channel: ${unadvertisedRequiredTool}`);
             }
-            if (steeringFollowUps.some((followUp) => followUp.effect === "set_no_handoff")) {
-                mustResolveBeforeHandoffActive = true;
-                options?.setMustResolveBeforeHandoff?.(true);
+            const forcedHistoricalToolNames = new Set(unresolvedHistoricalEffects
+                .map((effect) => effect.name)
+                .filter((name) => candidateToolNames.has(name)));
+            const forcingHistoricalEffect = forcedHistoricalToolNames.size > 0;
+            const activeTools = forcingHistoricalEffect
+                ? candidateActiveTools.filter((tool) => forcedHistoricalToolNames.has(tool.function.name))
+                : candidateActiveTools;
+            const activeToolNames = new Set(activeTools.map((tool) => tool.function.name));
+            const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
+            if (steeringFollowUps.length > 0) {
+                const hasSupersedingFollowUp = steeringFollowUps.some((followUp) => followUp.effect === "clear_and_supersede");
+                if (hasSupersedingFollowUp) {
+                    mustResolveBeforeHandoffActive = false;
+                    options?.setMustResolveBeforeHandoff?.(false);
+                    outcome = "superseded";
+                    break;
+                }
+                if (steeringFollowUps.some((followUp) => followUp.effect === "set_no_handoff")) {
+                    mustResolveBeforeHandoffActive = true;
+                    options?.setMustResolveBeforeHandoff?.(true);
+                }
+                sawSteeringFollowUp = true;
+                for (const followUp of steeringFollowUps) {
+                    messages.push({ role: "user", content: followUp.text });
+                }
+                providerRuntime.resetTurnState(messages);
             }
-            sawSteeringFollowUp = true;
-            for (const followUp of steeringFollowUps) {
-                messages.push({ role: "user", content: followUp.text });
+            // Yield so pending I/O (stdin Ctrl-C) can be processed between iterations
+            await new Promise((r) => setImmediate(r));
+            if (signal?.aborted) {
+                outcome = "aborted";
+                break;
             }
-            providerRuntime.resetTurnState(messages);
-        }
-        // Yield so pending I/O (stdin Ctrl-C) can be processed between iterations
-        await new Promise((r) => setImmediate(r));
-        if (signal?.aborted) {
-            outcome = "aborted";
-            break;
-        }
-        try {
-            const turnCallbackBufferRef = { current: null };
-            const callProviderTurn = async () => {
-                callbacks.onModelStart();
-                turnCallbackBufferRef.current = habitSession
-                    ? createHabitCallbackBuffer(callbacks)
-                    : callbacks.settleOutputMode === "final_only"
-                        ? createFinalOnlyTextBuffer(callbacks)
-                        : null;
-                try {
-                    const promptBudget = (0, prompt_budget_1.applyPromptBudget)({
-                        messages,
-                        requiredPromptEvidence: options?.requiredPromptEvidence,
-                        provider: providerRuntime.id,
-                        model: providerRuntime.model,
-                        contextWindowTokens: (0, config_1.getContextConfig)().maxTokens,
-                    });
-                    if (promptBudget.status !== "within_budget") {
-                        messages.splice(0, messages.length, ...promptBudget.messages);
-                        providerRuntime.resetTurnState(messages);
+            try {
+                const turnCallbackBufferRef = { current: null };
+                const callProviderTurn = async () => {
+                    callbacks.onModelStart();
+                    turnCallbackBufferRef.current = habitSession
+                        ? createHabitCallbackBuffer(callbacks)
+                        : callbacks.settleOutputMode === "final_only"
+                            ? createFinalOnlyTextBuffer(callbacks)
+                            : null;
+                    try {
+                        const promptBudget = (0, prompt_budget_1.applyPromptBudget)({
+                            messages,
+                            requiredPromptEvidence: options?.requiredPromptEvidence,
+                            provider: providerRuntime.id,
+                            model: providerRuntime.model,
+                            contextWindowTokens: (0, config_1.getContextConfig)().maxTokens,
+                        });
+                        if (promptBudget.status !== "within_budget") {
+                            messages.splice(0, messages.length, ...promptBudget.messages);
+                            providerRuntime.resetTurnState(messages);
+                        }
+                        return await providerRuntime.streamTurn({
+                            messages,
+                            activeTools,
+                            callbacks: turnCallbackBufferRef.current?.callbacks ?? callbacks,
+                            signal,
+                            traceId,
+                            toolChoiceRequired: forcingHistoricalEffect || toolChoiceRequired,
+                            reasoningEffort: currentReasoningEffort,
+                            eagerSettleStreaming: true,
+                            systemPrompt: structuredSystemPrompt,
+                        });
+                    }
+                    catch (error) {
+                        turnCallbackBufferRef.current?.discard();
+                        turnCallbackBufferRef.current = null;
+                        if (signal?.aborted)
+                            throw new provider_attempt_1.ProviderAttemptAbortError();
+                        throw error;
                     }
-                    return await providerRuntime.streamTurn({
-                        messages,
-                        activeTools,
-                        callbacks: turnCallbackBufferRef.current?.callbacks ?? callbacks,
-                        signal,
-                        traceId,
-                        toolChoiceRequired: forcingHistoricalEffect || toolChoiceRequired,
-                        reasoningEffort: currentReasoningEffort,
-                        eagerSettleStreaming: true,
-                        systemPrompt: structuredSystemPrompt,
-                    });
+                };
+                const callProviderTurnWithOverflowRecovery = async () => {
+                    try {
+                        return await callProviderTurn();
+                    }
+                    catch (error) {
+                        if (error instanceof provider_attempt_1.ProviderAttemptAbortError)
+                            throw error;
+                        if (isContextOverflow(error) && !overflowRetried) {
+                            overflowRetried = true;
+                            stripLastToolCalls(messages);
+                            stripLastToolCalls(generatedMessages);
+                            const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
+                            const trimmed = (0, context_1.trimMessages)(messages, maxTokens, contextMargin, maxTokens * 2);
+                            const requiredEvidence = options?.requiredPromptEvidence;
+                            const requiredMessages = new Set([
+                                ...(requiredEvidence?.verifiedPredecessorMessage ? [requiredEvidence.verifiedPredecessorMessage] : []),
+                                ...(requiredEvidence?.currentUserMessage ? [requiredEvidence.currentUserMessage] : []),
+                            ]);
+                            const trimmedMessages = new Set(trimmed);
+                            const overflowRetryMessages = requiredMessages.size === 0
+                                ? trimmed
+                                : messages.filter((message) => trimmedMessages.has(message) || requiredMessages.has(message));
+                            messages.splice(0, messages.length, ...overflowRetryMessages);
+                            providerRuntime.resetTurnState(messages);
+                            callbacks.onError(new Error("context trimmed, retrying..."), "transient");
+                            return callProviderTurn();
+                        }
+                        throw error;
+                    }
+                };
+                const attempt = await (0, provider_attempt_1.runProviderAttempt)({
+                    operation: "turn",
+                    provider: providerRuntime.id,
+                    model: providerRuntime.model,
+                    run: callProviderTurnWithOverflowRecovery,
+                    classifyError: (error) => providerRuntime.classifyError(error),
+                    onRetry: async (record, maxAttempts) => {
+                        const delayMs = record.delayMs;
+                        const seconds = delayMs / 1000;
+                        const cause = RETRY_LABELS[record.classification];
+                        try {
+                            if (record.provider === "openai-codex" && record.classification === "auth-failure") {
+                                await (0, openai_codex_token_1.refreshOpenAICodexProviderCredentials)((0, identity_2.getAgentName)(), {
+                                    force: true,
+                                    reason: "turn-auth-failure",
+                                });
+                            }
+                            await (0, provider_credentials_1.refreshProviderCredentialPool)((0, identity_2.getAgentName)(), {
+                                preserveCachedOnFailure: true,
+                                providers: [record.provider],
+                            });
+                            _providerRuntimeFactories[facing] = null;
+                            providerRuntime = await getProviderRuntime(facing);
+                            providerRuntime.resetTurnState(messages);
+                        }
+                        catch (refreshError) {
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "engine",
+                                event: "engine.provider_retry_refresh_failed",
+                                message: "provider credential refresh failed during retry",
+                                meta: { provider: record.provider, model: record.model, reason: refreshError instanceof Error ? refreshError.message : String(refreshError) },
+                            });
+                        }
+                        callbacks.onError(new Error(`${cause}, retrying in ${seconds}s (${record.attempt}/${maxAttempts})...`), "transient");
+                    },
+                    sleep: async (delayMs) => {
+                        await waitForProviderRetry(delayMs, signal);
+                        providerRuntime.resetTurnState(messages);
+                    },
+                });
+                if (!attempt.ok) {
+                    finishTerminalProviderError(attempt.error, attempt.classification);
+                    continue;
                 }
-                catch (error) {
-                    turnCallbackBufferRef.current?.discard();
-                    turnCallbackBufferRef.current = null;
-                    if (signal?.aborted)
-                        throw new provider_attempt_1.ProviderAttemptAbortError();
-                    throw error;
+                const result = attempt.value;
+                providerIterations += 1;
+                if (providerIterations === exports.MAX_PROVIDER_ITERATIONS && result.toolCalls.length > 0) {
+                    throw new Error(`provider iteration limit exhausted at response ${exports.MAX_PROVIDER_ITERATIONS} before tool execution`);
                 }
-            };
-            const callProviderTurnWithOverflowRecovery = async () => {
-                try {
-                    return await callProviderTurn();
+                const streamCallbackBuffer = turnCallbackBufferRef.current;
+                turnCallbackBufferRef.current = null;
+                if (result.settleFinalization && !result.settleFinalization.ok) {
+                    // A completed settle payload is terminal provider output, not a prompt
+                    // for another model turn. Retractable callbacks have already cleared;
+                    // core-owned callback buffers must be discarded before surfacing the exact
+                    // parser failure through the ordinary terminal-error path.
+                    streamCallbackBuffer?.discard();
+                    finishTerminalProviderError(new Error(result.settleFinalization.errorCode), "unknown");
+                    continue;
                 }
-                catch (error) {
-                    if (error instanceof provider_attempt_1.ProviderAttemptAbortError)
-                        throw error;
-                    if (isContextOverflow(error) && !overflowRetried) {
-                        overflowRetried = true;
-                        stripLastToolCalls(messages);
-                        stripLastToolCalls(generatedMessages);
-                        const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
-                        const trimmed = (0, context_1.trimMessages)(messages, maxTokens, contextMargin, maxTokens * 2);
-                        const requiredEvidence = options?.requiredPromptEvidence;
-                        const requiredMessages = new Set([
-                            ...(requiredEvidence?.verifiedPredecessorMessage ? [requiredEvidence.verifiedPredecessorMessage] : []),
-                            ...(requiredEvidence?.currentUserMessage ? [requiredEvidence.currentUserMessage] : []),
-                        ]);
-                        const trimmedMessages = new Set(trimmed);
-                        const overflowRetryMessages = requiredMessages.size === 0
-                            ? trimmed
-                            : messages.filter((message) => trimmedMessages.has(message) || requiredMessages.has(message));
-                        messages.splice(0, messages.length, ...overflowRetryMessages);
-                        providerRuntime.resetTurnState(messages);
-                        callbacks.onError(new Error("context trimmed, retrying..."), "transient");
-                        return callProviderTurn();
+                // Track usage from the latest API call
+                if (result.usage)
+                    lastUsage = result.usage;
+                // SHARED: build CC-format assistant message from TurnResult
+                const msg = {
+                    role: "assistant",
+                };
+                // Persist assistant content WITHOUT inline <think>...</think> blocks.
+                // Reasoning content already routed through onReasoningChunk for live
+                // surfacing and persisted separately as `_reasoning_items` for
+                // providers that support a reasoning channel; saving it inline AND
+                // alongside tool_calls causes MiniMax to reject the replayed turn
+                // with "tool result's tool id not found" (error code 2013) because
+                // it can't reconcile reasoning-with-tools in the same assistant
+                // message. Strip aggressively at persist so the next replay is
+                // clean; preserve the original reasoning trace on the message via
+                // `_inline_reasoning` so debug/audit paths can still see it.
+                if (result.content) {
+                    const stripped = stripThinkBlocksForViolationCheck(result.content);
+                    if (stripped.length > 0)
+                        msg.content = stripped;
+                    if (stripped.length !== result.content.length) {
+                        msg._inline_reasoning = result.content;
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "info",
+                            component: "engine",
+                            event: "engine.inline_reasoning_stripped",
+                            message: "stripped inline <think> blocks from persisted assistant message; preserved on _inline_reasoning",
+                            meta: {
+                                provider: providerRuntime.id,
+                                model: providerRuntime.model,
+                                originalLength: result.content.length,
+                                strippedLength: stripped.length,
+                            },
+                        });
                     }
-                    throw error;
                 }
-            };
-            const attempt = await (0, provider_attempt_1.runProviderAttempt)({
-                operation: "turn",
-                provider: providerRuntime.id,
-                model: providerRuntime.model,
-                run: callProviderTurnWithOverflowRecovery,
-                classifyError: (error) => providerRuntime.classifyError(error),
-                onRetry: async (record, maxAttempts) => {
-                    const delayMs = record.delayMs;
-                    const seconds = delayMs / 1000;
-                    const cause = RETRY_LABELS[record.classification];
-                    try {
-                        if (record.provider === "openai-codex" && record.classification === "auth-failure") {
-                            await (0, openai_codex_token_1.refreshOpenAICodexProviderCredentials)((0, identity_2.getAgentName)(), {
-                                force: true,
-                                reason: "turn-auth-failure",
+                if (result.toolCalls.length)
+                    msg.tool_calls = result.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    }));
+                // Store reasoning items from the API response on the assistant message
+                // so they persist through session save/load and can be restored in toResponsesInput
+                const reasoningItems = result.outputItems.filter((item) => "type" in item && item.type === "reasoning");
+                if (reasoningItems.length > 0) {
+                    msg._reasoning_items = reasoningItems;
+                }
+                // Store thinking blocks (Anthropic) on the assistant message for round-tripping
+                const thinkingItems = result.outputItems.filter((item) => "type" in item && (item.type === "thinking" || item.type === "redacted_thinking"));
+                if (thinkingItems.length > 0) {
+                    msg._thinking_blocks = thinkingItems;
+                }
+                // Phase annotation for Codex provider
+                const hasPhaseAnnotation = providerRuntime.capabilities.has("phase-annotation");
+                const isSoleSettle = result.toolCalls.length === 1 && result.toolCalls[0].name === "settle";
+                if (hasPhaseAnnotation) {
+                    msg.phase = isSoleSettle ? "settle" : "commentary";
+                }
+                // Detect the MiniMax "only-thinking, no tool call" violation: no tool
+                // calls returned, and the content is empty after stripping
+                // <think>...</think> blocks. This is a narrow check — legitimate
+                // content-only responses (text without think tags, or text outside
+                // think tags) still flow through the original "no tool calls →
+                // accept as-is" path so existing channels and tests are unaffected.
+                const onlyThinkContent = !result.toolCalls.length
+                    && typeof result.content === "string"
+                    && stripThinkBlocksForViolationCheck(result.content).length === 0
+                    && result.content.length > 0;
+                const privateReturnTextAckRetryError = !result.toolCalls.length
+                    ? privateReturnMissingPonderError({
+                        latestUserRequest: latestUserMessageText(messages),
+                        answer: stripThinkBlocksForViolationCheck(result.content),
+                        sawPonder,
+                    })
+                    : null;
+                if (!result.toolCalls.length) {
+                    if (forcingHistoricalEffect) {
+                        streamCallbackBuffer?.discard();
+                        callbacks.onClearText?.();
+                        const retryableHistoricalTools = [...forcedHistoricalToolNames];
+                        if (historicalToolFailureRetries >= NO_TOOL_CALL_MAX_RETRIES) {
+                            const blockedAnswer = `I could not complete the unresolved ${retryableHistoricalTools.join(", ")} effect because the provider repeatedly returned no tool call. I did not treat the requested change as complete.`;
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "engine",
+                                event: "engine.historical_tool_failure_retry",
+                                message: "unresolved historical effect exhausted deterministic tool-call retries; failing closed",
+                                meta: { provider: providerRuntime.id, model: providerRuntime.model, toolNames: retryableHistoricalTools, cap: NO_TOOL_CALL_MAX_RETRIES },
                             });
+                            msg.content = blockedAnswer;
+                            pushGenerated(msg);
+                            callbacks.onTextChunk(blockedAnswer);
+                            completion = { answer: blockedAnswer, intent: "blocked" };
+                            outcome = "blocked";
+                            done = true;
+                            continue;
                         }
-                        await (0, provider_credentials_1.refreshProviderCredentialPool)((0, identity_2.getAgentName)(), {
-                            preserveCachedOnFailure: true,
-                            providers: [record.provider],
+                        historicalToolFailureRetries += 1;
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "engine",
+                            event: "engine.historical_tool_failure_retry",
+                            message: "unresolved historical effect returned no tool call; forcing another exact-effect attempt",
+                            meta: {
+                                provider: providerRuntime.id,
+                                model: providerRuntime.model,
+                                toolNames: retryableHistoricalTools,
+                                attempt: historicalToolFailureRetries,
+                                cap: NO_TOOL_CALL_MAX_RETRIES,
+                            },
                         });
-                        _providerRuntimeFactories[facing] = null;
-                        providerRuntime = await getProviderRuntime(facing);
-                        providerRuntime.resetTurnState(messages);
+                        pushGenerated(msg);
+                        messages.push({
+                            role: "user",
+                            content: `this exact request previously reached a tool that is advertised again now. Its unresolved historical effect is through ${retryableHistoricalTools.join(", ")}. Only that tool is available now. Read current state if needed, then retry the exact failed effect. Do not report completion until the effect succeeds.`,
+                        });
+                        continue;
                     }
-                    catch (refreshError) {
+                    const requiredToolCallsGate = pendingRequiredToolCalls();
+                    if (requiredToolCallsGate) {
+                        streamCallbackBuffer?.discard();
+                        callbacks.onClearText?.();
+                        queueRequiredCorrection(requiredToolCallsGate.message, "before required tool calls completed");
                         (0, runtime_1.emitNervesEvent)({
                             level: "warn",
                             component: "engine",
-                            event: "engine.provider_retry_refresh_failed",
-                            message: "provider credential refresh failed during retry",
-                            meta: { provider: record.provider, model: record.model, reason: refreshError instanceof Error ? refreshError.message : String(refreshError) },
+                            event: "engine.required_tool_calls_pending",
+                            message: "terminal response rejected until required tool handlers dispatch",
+                            meta: { missingToolNames: requiredToolCallsGate.missing },
                         });
+                        continue;
                     }
-                    callbacks.onError(new Error(`${cause}, retrying in ${seconds}s (${record.attempt}/${maxAttempts})...`), "transient");
-                },
-                sleep: async (delayMs) => {
-                    await waitForProviderRetry(delayMs, signal);
-                    providerRuntime.resetTurnState(messages);
-                },
-            });
-            if (!attempt.ok) {
-                finishTerminalProviderError(attempt.error, attempt.classification);
-                continue;
-            }
-            const result = attempt.value;
-            providerIterations += 1;
-            if (providerIterations === exports.MAX_PROVIDER_ITERATIONS && result.toolCalls.length > 0) {
-                throw new Error(`provider iteration limit exhausted at response ${exports.MAX_PROVIDER_ITERATIONS} before tool execution`);
-            }
-            const streamCallbackBuffer = turnCallbackBufferRef.current;
-            turnCallbackBufferRef.current = null;
-            if (result.settleFinalization && !result.settleFinalization.ok) {
-                // A completed settle payload is terminal provider output, not a prompt
-                // for another model turn. Retractable callbacks have already cleared;
-                // core-owned callback buffers must be discarded before surfacing the exact
-                // parser failure through the ordinary terminal-error path.
-                streamCallbackBuffer?.discard();
-                finishTerminalProviderError(new Error(result.settleFinalization.errorCode), "unknown");
-                continue;
-            }
-            // Track usage from the latest API call
-            if (result.usage)
-                lastUsage = result.usage;
-            // SHARED: build CC-format assistant message from TurnResult
-            const msg = {
-                role: "assistant",
-            };
-            // Persist assistant content WITHOUT inline <think>...</think> blocks.
-            // Reasoning content already routed through onReasoningChunk for live
-            // surfacing and persisted separately as `_reasoning_items` for
-            // providers that support a reasoning channel; saving it inline AND
-            // alongside tool_calls causes MiniMax to reject the replayed turn
-            // with "tool result's tool id not found" (error code 2013) because
-            // it can't reconcile reasoning-with-tools in the same assistant
-            // message. Strip aggressively at persist so the next replay is
-            // clean; preserve the original reasoning trace on the message via
-            // `_inline_reasoning` so debug/audit paths can still see it.
-            if (result.content) {
-                const stripped = stripThinkBlocksForViolationCheck(result.content);
-                if (stripped.length > 0)
-                    msg.content = stripped;
-                if (stripped.length !== result.content.length) {
-                    msg._inline_reasoning = result.content;
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "info",
-                        component: "engine",
-                        event: "engine.inline_reasoning_stripped",
-                        message: "stripped inline <think> blocks from persisted assistant message; preserved on _inline_reasoning",
-                        meta: {
-                            provider: providerRuntime.id,
-                            model: providerRuntime.model,
-                            originalLength: result.content.length,
-                            strippedLength: stripped.length,
-                        },
-                    });
-                }
-            }
-            if (result.toolCalls.length)
-                msg.tool_calls = result.toolCalls.map((tc) => ({
-                    id: tc.id,
-                    type: "function",
-                    function: { name: tc.name, arguments: tc.arguments },
-                }));
-            // Store reasoning items from the API response on the assistant message
-            // so they persist through session save/load and can be restored in toResponsesInput
-            const reasoningItems = result.outputItems.filter((item) => "type" in item && item.type === "reasoning");
-            if (reasoningItems.length > 0) {
-                msg._reasoning_items = reasoningItems;
-            }
-            // Store thinking blocks (Anthropic) on the assistant message for round-tripping
-            const thinkingItems = result.outputItems.filter((item) => "type" in item && (item.type === "thinking" || item.type === "redacted_thinking"));
-            if (thinkingItems.length > 0) {
-                msg._thinking_blocks = thinkingItems;
-            }
-            // Phase annotation for Codex provider
-            const hasPhaseAnnotation = providerRuntime.capabilities.has("phase-annotation");
-            const isSoleSettle = result.toolCalls.length === 1 && result.toolCalls[0].name === "settle";
-            if (hasPhaseAnnotation) {
-                msg.phase = isSoleSettle ? "settle" : "commentary";
-            }
-            // Detect the MiniMax "only-thinking, no tool call" violation: no tool
-            // calls returned, and the content is empty after stripping
-            // <think>...</think> blocks. This is a narrow check — legitimate
-            // content-only responses (text without think tags, or text outside
-            // think tags) still flow through the original "no tool calls →
-            // accept as-is" path so existing channels and tests are unaffected.
-            const onlyThinkContent = !result.toolCalls.length
-                && typeof result.content === "string"
-                && stripThinkBlocksForViolationCheck(result.content).length === 0
-                && result.content.length > 0;
-            const privateReturnTextAckRetryError = !result.toolCalls.length
-                ? privateReturnMissingPonderError({
-                    latestUserRequest: latestUserMessageText(messages),
-                    answer: stripThinkBlocksForViolationCheck(result.content),
-                    sawPonder,
-                })
-                : null;
-            if (!result.toolCalls.length) {
-                if (forcingHistoricalEffect) {
-                    streamCallbackBuffer?.discard();
-                    callbacks.onClearText?.();
-                    const retryableHistoricalTools = [...forcedHistoricalToolNames];
-                    if (historicalToolFailureRetries >= NO_TOOL_CALL_MAX_RETRIES) {
-                        const blockedAnswer = `I could not complete the unresolved ${retryableHistoricalTools.join(", ")} effect because the provider repeatedly returned no tool call. I did not treat the requested change as complete.`;
+                    const requiredAnswerRejection = options?.requiredToolCalls?.validateTerminalAnswer?.(String(msg.content ?? ""));
+                    if (requiredAnswerRejection) {
+                        streamCallbackBuffer?.discard();
+                        callbacks.onClearText?.();
+                        queueRequiredCorrection(requiredAnswerRejection, "before required terminal answer validation completed");
+                        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.required_tool_answer_rejected", message: "unsupported terminal answer rejected after required reads", meta: { answerLength: String(msg.content ?? "").length } });
+                        continue;
+                    }
+                    if (privateReturnTextAckRetryError) {
+                        streamCallbackBuffer?.discard();
+                        callbacks.onClearText?.();
+                        if (noToolCallRetries < NO_TOOL_CALL_MAX_RETRIES) {
+                            noToolCallRetries++;
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "engine",
+                                event: "engine.no_tool_call_retry",
+                                message: "model returned a text-only private-return acknowledgement without ponder; retrying with corrective nudge",
+                                meta: {
+                                    attempt: noToolCallRetries,
+                                    cap: NO_TOOL_CALL_MAX_RETRIES,
+                                    provider: providerRuntime.id,
+                                    model: providerRuntime.model,
+                                    reason: "private_return_missing_ponder",
+                                    contentLength: result.content.length,
+                                },
+                            });
+                            pushGenerated(msg);
+                            messages.push({
+                                role: "user",
+                                content: `${privateReturnTextAckRetryError} Emit the ponder(action=create, ...) tool call now, or ask a blocking clarification without saying the private work is queued.`,
+                            });
+                            continue;
+                        }
+                        const blockedAnswer = "I could not start the private pass. No private-attention packet was created, so no return work was queued.";
                         (0, runtime_1.emitNervesEvent)({
-                            level: "warn",
+                            level: "error",
                             component: "engine",
-                            event: "engine.historical_tool_failure_retry",
-                            message: "unresolved historical effect exhausted deterministic tool-call retries; failing closed",
-                            meta: { provider: providerRuntime.id, model: providerRuntime.model, toolNames: retryableHistoricalTools, cap: NO_TOOL_CALL_MAX_RETRIES },
+                            event: "engine.private_return_missing_ponder_blocked",
+                            message: "private-return text acknowledgement skipped ponder through the retry cap; failing closed",
+                            meta: {
+                                cap: NO_TOOL_CALL_MAX_RETRIES,
+                                provider: providerRuntime.id,
+                                model: providerRuntime.model,
+                                contentLength: result.content.length,
+                            },
                         });
                         msg.content = blockedAnswer;
                         pushGenerated(msg);
@@ -1521,895 +1622,809 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         done = true;
                         continue;
                     }
-                    historicalToolFailureRetries += 1;
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "engine",
-                        event: "engine.historical_tool_failure_retry",
-                        message: "unresolved historical effect returned no tool call; forcing another exact-effect attempt",
-                        meta: {
-                            provider: providerRuntime.id,
-                            model: providerRuntime.model,
-                            toolNames: retryableHistoricalTools,
-                            attempt: historicalToolFailureRetries,
-                            cap: NO_TOOL_CALL_MAX_RETRIES,
-                        },
-                    });
-                    pushGenerated(msg);
-                    messages.push({
-                        role: "user",
-                        content: `this exact request previously reached a tool that is advertised again now. Its unresolved historical effect is through ${retryableHistoricalTools.join(", ")}. Only that tool is available now. Read current state if needed, then retry the exact failed effect. Do not report completion until the effect succeeds.`,
-                    });
-                    continue;
-                }
-                const requiredToolCallsGate = pendingRequiredToolCalls();
-                if (requiredToolCallsGate) {
-                    streamCallbackBuffer?.discard();
-                    callbacks.onClearText?.();
-                    queueRequiredCorrection(requiredToolCallsGate.message, "before required tool calls completed");
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "engine",
-                        event: "engine.required_tool_calls_pending",
-                        message: "terminal response rejected until required tool handlers dispatch",
-                        meta: { missingToolNames: requiredToolCallsGate.missing },
-                    });
-                    continue;
-                }
-                const requiredAnswerRejection = options?.requiredToolCalls?.validateTerminalAnswer?.(String(msg.content ?? ""));
-                if (requiredAnswerRejection) {
-                    streamCallbackBuffer?.discard();
-                    callbacks.onClearText?.();
-                    queueRequiredCorrection(requiredAnswerRejection, "before required terminal answer validation completed");
-                    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.required_tool_answer_rejected", message: "unsupported terminal answer rejected after required reads", meta: { answerLength: String(msg.content ?? "").length } });
-                    continue;
-                }
-                if (privateReturnTextAckRetryError) {
-                    streamCallbackBuffer?.discard();
-                    callbacks.onClearText?.();
-                    if (noToolCallRetries < NO_TOOL_CALL_MAX_RETRIES) {
+                    if (onlyThinkContent && toolChoiceRequired && noToolCallRetries < NO_TOOL_CALL_MAX_RETRIES) {
+                        streamCallbackBuffer?.discard();
+                        // Provider-level violation: tool_choice was required, model emitted
+                        // only a <think>...</think> block (or empty content) with no tool
+                        // call. Retry with a corrective nudge up to NO_TOOL_CALL_MAX_RETRIES
+                        // times. After cap, accept as-is (the readback path strips think
+                        // tags and surfaces a clear diagnostic).
                         noToolCallRetries++;
                         (0, runtime_1.emitNervesEvent)({
                             level: "warn",
                             component: "engine",
                             event: "engine.no_tool_call_retry",
-                            message: "model returned a text-only private-return acknowledgement without ponder; retrying with corrective nudge",
+                            message: "model returned only <think> content with no tool call despite tool_choice=required; retrying with corrective nudge",
                             meta: {
                                 attempt: noToolCallRetries,
                                 cap: NO_TOOL_CALL_MAX_RETRIES,
                                 provider: providerRuntime.id,
                                 model: providerRuntime.model,
-                                reason: "private_return_missing_ponder",
                                 contentLength: result.content.length,
                             },
                         });
                         pushGenerated(msg);
                         messages.push({
                             role: "user",
-                            content: `${privateReturnTextAckRetryError} Emit the ponder(action=create, ...) tool call now, or ask a blocking clarification without saying the private work is queued.`,
+                            content: isPrivateRuntimeChannel
+                                ? augmentedToolContext?.noSend === true
+                                    ? "no tool was called this turn. this is an immutable no-send turn; call rest now without creating a continuation."
+                                    : "no tool was called this turn. you must end every turn by calling rest (or surface, ponder, observe). emit the tool call now."
+                                : "no tool was called this turn. you must end every turn by calling settle with your answer (or ponder/observe). emit the tool call now.",
                         });
                         continue;
                     }
-                    const blockedAnswer = "I could not start the private pass. No private-attention packet was created, so no return work was queued.";
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "error",
-                        component: "engine",
-                        event: "engine.private_return_missing_ponder_blocked",
-                        message: "private-return text acknowledgement skipped ponder through the retry cap; failing closed",
-                        meta: {
-                            cap: NO_TOOL_CALL_MAX_RETRIES,
-                            provider: providerRuntime.id,
-                            model: providerRuntime.model,
-                            contentLength: result.content.length,
-                        },
-                    });
-                    msg.content = blockedAnswer;
-                    pushGenerated(msg);
-                    callbacks.onTextChunk(blockedAnswer);
-                    completion = { answer: blockedAnswer, intent: "blocked" };
-                    outcome = "blocked";
-                    done = true;
-                    continue;
-                }
-                if (onlyThinkContent && toolChoiceRequired && noToolCallRetries < NO_TOOL_CALL_MAX_RETRIES) {
-                    streamCallbackBuffer?.discard();
-                    // Provider-level violation: tool_choice was required, model emitted
-                    // only a <think>...</think> block (or empty content) with no tool
-                    // call. Retry with a corrective nudge up to NO_TOOL_CALL_MAX_RETRIES
-                    // times. After cap, accept as-is (the readback path strips think
-                    // tags and surfaces a clear diagnostic).
-                    noToolCallRetries++;
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "engine",
-                        event: "engine.no_tool_call_retry",
-                        message: "model returned only <think> content with no tool call despite tool_choice=required; retrying with corrective nudge",
-                        meta: {
-                            attempt: noToolCallRetries,
-                            cap: NO_TOOL_CALL_MAX_RETRIES,
-                            provider: providerRuntime.id,
-                            model: providerRuntime.model,
-                            contentLength: result.content.length,
-                        },
-                    });
-                    pushGenerated(msg);
-                    messages.push({
-                        role: "user",
-                        content: isPrivateRuntimeChannel
-                            ? augmentedToolContext?.noSend === true
-                                ? "no tool was called this turn. this is an immutable no-send turn; call rest now without creating a continuation."
-                                : "no tool was called this turn. you must end every turn by calling rest (or surface, ponder, observe). emit the tool call now."
-                            : "no tool was called this turn. you must end every turn by calling settle with your answer (or ponder/observe). emit the tool call now.",
-                    });
-                    continue;
-                }
-                // Legitimate text-only response, or cap reached — accept as-is.
-                await streamCallbackBuffer?.flush();
-                pushGenerated(msg);
-                done = true;
-            }
-            else {
-                // Reset the retry counter on any successful tool call.
-                noToolCallRetries = 0;
-                const preCallMessages = structuredClone(messages.filter((message) => message.role !== "system"));
-                const validatedCalls = validateToolCallBatchAtProductionBoundary(result.toolCalls, activeTools);
-                const invalidCall = validatedCalls.find((entry) => "error" in entry);
-                if (invalidCall) {
+                    // Legitimate text-only response, or cap reached — accept as-is.
                     await streamCallbackBuffer?.flush();
                     pushGenerated(msg);
-                    const unadvertisedCall = validatedCalls.find((entry) => !activeToolNames.has(entry.call.name));
-                    for (const entry of validatedCalls) {
-                        const detail = "error" in entry ? entry.error : "another call in this batch had invalid arguments";
-                        const rejection = unadvertisedCall
-                            ? `rejected: ${entry.call.name} was not advertised for this channel; no handler was executed.`
-                            : `invalid tool arguments: ${detail}`;
-                        pushGenerated({ role: "tool", tool_call_id: entry.call.id, content: rejection });
-                        providerRuntime.appendToolOutput(entry.call.id, rejection);
-                        options?.toolBoundaryObserver?.({
-                            name: entry.call.name,
-                            reason: activeToolNames.has(entry.call.name) ? "invalid_arguments" : "profile_excluded",
-                            globallyResolvable: typeof (0, tools_1.resolveToolDefinition)(entry.call.name)?.handler === "function",
-                            invoked: false,
-                            sideEffect: false,
-                        });
-                    }
-                    if (unadvertisedCall) {
-                        (0, runtime_1.emitNervesEvent)({
-                            level: "warn",
-                            component: "engine",
-                            event: "engine.unadvertised_tool_blocked",
-                            message: "blocked an unadvertised tool call before batch execution",
-                            meta: { channel: String(channel), toolName: unadvertisedCall.call.name },
-                        });
-                    }
-                    else {
-                        (0, runtime_1.emitNervesEvent)({
-                            level: "warn",
-                            component: "engine",
-                            event: "engine.tool_arguments_rejected",
-                            message: "tool batch rejected before execution because arguments were invalid",
-                            meta: { toolCallId: invalidCall.call.id, toolName: invalidCall.call.name },
-                        });
-                    }
-                    continue;
-                }
-                const validCalls = validatedCalls;
-                const validatedCallArguments = new Map(validCalls.map((entry) => [
-                    entry.call,
-                    entry.validated.arguments,
-                ]));
-                const habitBlockReason = await habitToolBatchBlockReason(habitSession, result.toolCalls, augmentedToolContext?.delegatedOrigins);
-                if (habitBlockReason) {
-                    streamCallbackBuffer?.discard();
-                    recordBlockedHabitSurfaceAttempts(habitSession, result.toolCalls, habitBlockReason);
-                    pushGenerated(msg);
-                    const blockedOutput = `blocked: ${habitBlockReason}. No tool side effects from this assistant message were executed.`;
-                    for (const call of result.toolCalls) {
-                        pushGenerated({ role: "tool", tool_call_id: call.id, content: blockedOutput });
-                        providerRuntime.appendToolOutput(call.id, blockedOutput);
-                    }
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "engine",
-                        event: "engine.habit_tool_batch_blocked",
-                        message: "habit tool batch blocked before side effects",
-                        meta: { reason: habitBlockReason, toolCalls: result.toolCalls.map((call) => call.name) },
-                    });
-                    continue;
+                    done = true;
                 }
-                const soleTerminalCall = result.toolCalls.length === 1
-                    ? result.toolCalls[0]
-                    : null;
-                const soleTerminalProjection = soleTerminalCall
-                    ? (0, tools_1.resolveToolDefinition)(soleTerminalCall.name)?.terminalProjection
-                    : undefined;
-                if (soleTerminalCall && soleTerminalProjection?.mode === "verbatim") {
-                    const terminalArgs = validatedCallArguments.get(soleTerminalCall);
-                    if (soleTerminalProjection.clearBufferedText
-                        || callbacks.settleOutputMode === "final_only") {
-                        streamCallbackBuffer?.discard();
-                    }
-                    else {
+                else {
+                    // Reset the retry counter on any successful tool call.
+                    noToolCallRetries = 0;
+                    const preCallMessages = structuredClone(messagesWithoutRequiredCorrections().filter((message) => message.role !== "system"));
+                    const validatedCalls = validateToolCallBatchAtProductionBoundary(result.toolCalls, activeTools);
+                    const invalidCall = validatedCalls.find((entry) => "error" in entry);
+                    if (invalidCall) {
                         await streamCallbackBuffer?.flush();
-                    }
-                    if (soleTerminalProjection.clearBufferedText)
-                        callbacks.onClearText?.();
-                    callbacks.onToolStart(soleTerminalCall.name, terminalArgs);
-                    let terminalResult;
-                    try {
-                        const execToolFn = options?.execTool ?? tools_1.execTool;
-                        terminalResult = await execToolFn(soleTerminalCall.name, terminalArgs, augmentedToolContext);
-                    }
-                    catch (error) {
-                        callbacks.onToolEnd(soleTerminalCall.name, (0, tools_1.summarizeArgs)(soleTerminalCall.name, terminalArgs), false);
                         pushGenerated(msg);
-                        const failure = error instanceof Error ? `error: ${error.message}` : `error: ${String(error)}`;
-                        pushGenerated({ role: "tool", tool_call_id: soleTerminalCall.id, content: failure });
-                        providerRuntime.appendToolOutput(soleTerminalCall.id, failure);
-                        callbacks.onTextChunk(failure);
-                        completion = { answer: failure, intent: "blocked" };
-                        outcome = "blocked";
-                        done = true;
+                        const unadvertisedCall = validatedCalls.find((entry) => !activeToolNames.has(entry.call.name));
+                        for (const entry of validatedCalls) {
+                            const detail = "error" in entry ? entry.error : "another call in this batch had invalid arguments";
+                            const rejection = unadvertisedCall
+                                ? `rejected: ${entry.call.name} was not advertised for this channel; no handler was executed.`
+                                : `invalid tool arguments: ${detail}`;
+                            pushGenerated({ role: "tool", tool_call_id: entry.call.id, content: rejection });
+                            providerRuntime.appendToolOutput(entry.call.id, rejection);
+                            options?.toolBoundaryObserver?.({
+                                name: entry.call.name,
+                                reason: activeToolNames.has(entry.call.name) ? "invalid_arguments" : "profile_excluded",
+                                globallyResolvable: typeof (0, tools_1.resolveToolDefinition)(entry.call.name)?.handler === "function",
+                                invoked: false,
+                                sideEffect: false,
+                            });
+                        }
+                        if (unadvertisedCall) {
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "engine",
+                                event: "engine.unadvertised_tool_blocked",
+                                message: "blocked an unadvertised tool call before batch execution",
+                                meta: { channel: String(channel), toolName: unadvertisedCall.call.name },
+                            });
+                        }
+                        else {
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "engine",
+                                event: "engine.tool_arguments_rejected",
+                                message: "tool batch rejected before execution because arguments were invalid",
+                                meta: { toolCallId: invalidCall.call.id, toolName: invalidCall.call.name },
+                            });
+                        }
                         continue;
                     }
-                    callbacks.onToolEnd(soleTerminalCall.name, (0, tools_1.summarizeArgs)(soleTerminalCall.name, terminalArgs), true);
-                    pushGenerated(msg);
-                    pushGenerated({ role: "tool", tool_call_id: soleTerminalCall.id, content: terminalResult });
-                    providerRuntime.appendToolOutput(soleTerminalCall.id, terminalResult);
-                    callbacks.onTextChunk(terminalResult);
-                    completion = { answer: terminalResult, intent: "complete" };
-                    outcome = "settled";
-                    done = true;
-                    continue;
-                }
-                // Check for settle sole call: intercept before tool execution
-                if (isSoleSettle) {
-                    const settleArgs = validatedCallArguments.get(result.toolCalls[0]);
-                    callbacks.onToolStart("settle", settleArgs);
-                    const requiredToolCallsGate = pendingRequiredToolCalls();
-                    if (requiredToolCallsGate) {
+                    const validCalls = validatedCalls;
+                    const validatedCallArguments = new Map(validCalls.map((entry) => [
+                        entry.call,
+                        entry.validated.arguments,
+                    ]));
+                    const habitBlockReason = await habitToolBatchBlockReason(habitSession, result.toolCalls, augmentedToolContext?.delegatedOrigins);
+                    if (habitBlockReason) {
                         streamCallbackBuffer?.discard();
-                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
-                        callbacks.onClearText?.();
-                        queueRequiredCorrection(requiredToolCallsGate.message, "before required tool calls completed");
+                        recordBlockedHabitSurfaceAttempts(habitSession, result.toolCalls, habitBlockReason);
+                        pushGenerated(msg);
+                        const blockedOutput = `blocked: ${habitBlockReason}. No tool side effects from this assistant message were executed.`;
+                        for (const call of result.toolCalls) {
+                            pushGenerated({ role: "tool", tool_call_id: call.id, content: blockedOutput });
+                            providerRuntime.appendToolOutput(call.id, blockedOutput);
+                        }
                         (0, runtime_1.emitNervesEvent)({
                             level: "warn",
                             component: "engine",
-                            event: "engine.required_tool_calls_pending",
-                            message: "settle rejected until required tool handlers dispatch",
-                            meta: { missingToolNames: requiredToolCallsGate.missing },
+                            event: "engine.habit_tool_batch_blocked",
+                            message: "habit tool batch blocked before side effects",
+                            meta: { reason: habitBlockReason, toolCalls: result.toolCalls.map((call) => call.name) },
                         });
                         continue;
                     }
-                    // Private-runtime attention queue gate: reject settle if items remain
-                    const attentionQueue = augmentedToolContext?.delegatedOrigins;
-                    if (isPrivateRuntimeChannel && attentionQueue && attentionQueue.length > 0) {
-                        streamCallbackBuffer?.discard();
-                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
-                        callbacks.onClearText?.();
-                        pushGenerated(msg);
-                        const gateMessage = "current held-work frame still has unsurfaced items — return each listed item with surface(delegationId=...) before you settle. Older transcript claims are historical; only the current held-work frame is the gate.";
-                        pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
-                        continue;
-                    }
-                    // Extract answer from the tool call arguments.
-                    // Supports: {"answer":"text","intent":"..."} or "text" (JSON string).
-                    const { answer, intent } = parseSettlePayload(result.toolCalls[0].arguments);
-                    const requiredAnswerRejection = options?.requiredToolCalls?.validateTerminalAnswer?.(answer);
-                    if (requiredAnswerRejection) {
-                        streamCallbackBuffer?.discard();
-                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
-                        callbacks.onClearText?.();
-                        queueRequiredCorrection(requiredAnswerRejection, "before required terminal answer validation completed");
-                        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.required_tool_answer_rejected", message: "unsupported settle answer rejected after required reads", meta: { answerLength: answer.length } });
-                        continue;
-                    }
-                    // Private-runtime settle: no CompletionMetadata, "(settled)" ack
-                    if (isPrivateRuntimeChannel) {
-                        streamCallbackBuffer?.discard();
-                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), true);
+                    const soleTerminalCall = result.toolCalls.length === 1
+                        ? result.toolCalls[0]
+                        : null;
+                    const soleTerminalProjection = soleTerminalCall
+                        ? (0, tools_1.resolveToolDefinition)(soleTerminalCall.name)?.terminalProjection
+                        : undefined;
+                    if (soleTerminalCall && soleTerminalProjection?.mode === "verbatim") {
+                        const terminalArgs = validatedCallArguments.get(soleTerminalCall);
+                        if (soleTerminalProjection.clearBufferedText
+                            || callbacks.settleOutputMode === "final_only") {
+                            streamCallbackBuffer?.discard();
+                        }
+                        else {
+                            await streamCallbackBuffer?.flush();
+                        }
+                        if (soleTerminalProjection.clearBufferedText)
+                            callbacks.onClearText?.();
+                        callbacks.onToolStart(soleTerminalCall.name, terminalArgs);
+                        let terminalResult;
+                        try {
+                            const execToolFn = options?.execTool ?? tools_1.execTool;
+                            terminalResult = await execToolFn(soleTerminalCall.name, terminalArgs, augmentedToolContext);
+                        }
+                        catch (error) {
+                            callbacks.onToolEnd(soleTerminalCall.name, (0, tools_1.summarizeArgs)(soleTerminalCall.name, terminalArgs), false);
+                            pushGenerated(msg);
+                            const failure = error instanceof Error ? `error: ${error.message}` : `error: ${String(error)}`;
+                            pushGenerated({ role: "tool", tool_call_id: soleTerminalCall.id, content: failure });
+                            providerRuntime.appendToolOutput(soleTerminalCall.id, failure);
+                            callbacks.onTextChunk(failure);
+                            completion = { answer: failure, intent: "blocked" };
+                            outcome = "blocked";
+                            done = true;
+                            continue;
+                        }
+                        callbacks.onToolEnd(soleTerminalCall.name, (0, tools_1.summarizeArgs)(soleTerminalCall.name, terminalArgs), true);
                         pushGenerated(msg);
-                        const settled = "(settled)";
-                        pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: settled });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, settled);
+                        pushGenerated({ role: "tool", tool_call_id: soleTerminalCall.id, content: terminalResult });
+                        providerRuntime.appendToolOutput(soleTerminalCall.id, terminalResult);
+                        callbacks.onTextChunk(terminalResult);
+                        completion = { answer: terminalResult, intent: "complete" };
                         outcome = "settled";
                         done = true;
                         continue;
                     }
-                    // The provider finalizer has already established a top-level string
-                    // answer before ordinary settle handling reaches this point.
-                    const deliveredAnswer = answer;
-                    const retryError = privateReturnAckLeakError(deliveredAnswer, privateReturnHeldTokens)
-                        ?? privateReturnMissingPonderError({
-                            latestUserRequest: latestUserMessageText(messages),
-                            answer: deliveredAnswer,
-                            sawPonder,
-                        })
-                        ?? getSettleRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp, options?.delegationDecision, sawSendMessageSelf, sawPonder, sawQuerySession, options?.currentObligation ?? null, options?.activeWorkFrame?.inner?.job, sawExternalStateQuery);
-                    const validDirectReply = mustResolveBeforeHandoffActive && intent === "direct_reply" && sawSteeringFollowUp;
-                    if (retryError === null) {
-                        try {
-                            if (!result.settleStreamed) {
-                                const acceptedOutputCallbacks = streamCallbackBuffer?.callbacks ?? callbacks;
-                                acceptedOutputCallbacks.onTextChunk(deliveredAnswer);
-                            }
-                            await streamCallbackBuffer?.flush();
+                    // Check for settle sole call: intercept before tool execution
+                    if (isSoleSettle) {
+                        const settleArgs = validatedCallArguments.get(result.toolCalls[0]);
+                        callbacks.onToolStart("settle", settleArgs);
+                        const requiredToolCallsGate = pendingRequiredToolCalls();
+                        if (requiredToolCallsGate) {
+                            streamCallbackBuffer?.discard();
+                            callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
+                            callbacks.onClearText?.();
+                            queueRequiredCorrection(requiredToolCallsGate.message, "before required tool calls completed");
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "engine",
+                                event: "engine.required_tool_calls_pending",
+                                message: "settle rejected until required tool handlers dispatch",
+                                meta: { missingToolNames: requiredToolCallsGate.missing },
+                            });
+                            continue;
                         }
-                        catch (error) {
+                        // Private-runtime attention queue gate: reject settle if items remain
+                        const attentionQueue = augmentedToolContext?.delegatedOrigins;
+                        if (isPrivateRuntimeChannel && attentionQueue && attentionQueue.length > 0) {
+                            streamCallbackBuffer?.discard();
                             callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
+                            callbacks.onClearText?.();
+                            pushGenerated(msg);
+                            const gateMessage = "current held-work frame still has unsurfaced items — return each listed item with surface(delegationId=...) before you settle. Older transcript claims are historical; only the current held-work frame is the gate.";
+                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
+                            providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                            continue;
+                        }
+                        // Extract answer from the tool call arguments.
+                        // Supports: {"answer":"text","intent":"..."} or "text" (JSON string).
+                        const { answer, intent } = parseSettlePayload(result.toolCalls[0].arguments);
+                        const requiredAnswerRejection = options?.requiredToolCalls?.validateTerminalAnswer?.(answer);
+                        if (requiredAnswerRejection) {
                             streamCallbackBuffer?.discard();
-                            finishTerminalProviderError(new streaming_1.SettleFinalizationCallbackError(error), "unknown");
+                            callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
+                            callbacks.onClearText?.();
+                            queueRequiredCorrection(requiredAnswerRejection, "before required terminal answer validation completed");
+                            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.required_tool_answer_rejected", message: "unsupported settle answer rejected after required reads", meta: { answerLength: answer.length } });
                             continue;
                         }
-                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), true);
-                        completion = {
-                            answer: deliveredAnswer,
-                            intent: validDirectReply ? "direct_reply" : intent === "blocked" ? "blocked" : "complete",
-                        };
-                        // Retractable owners already hold the validated answer. Final-only
-                        // owners receive it here, after every semantic continuation gate.
-                        pushGenerated(msg);
-                        if (validDirectReply) {
-                            const resumeWork = "direct reply delivered. resume the unresolved obligation now and keep working until you can finish or clearly report that you are blocked.";
-                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: resumeWork });
-                            providerRuntime.appendToolOutput(result.toolCalls[0].id, resumeWork);
+                        // Private-runtime settle: no CompletionMetadata, "(settled)" ack
+                        if (isPrivateRuntimeChannel) {
+                            streamCallbackBuffer?.discard();
+                            callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), true);
+                            pushGenerated(msg);
+                            const settled = "(settled)";
+                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: settled });
+                            providerRuntime.appendToolOutput(result.toolCalls[0].id, settled);
+                            outcome = "settled";
+                            done = true;
+                            continue;
+                        }
+                        // The provider finalizer has already established a top-level string
+                        // answer before ordinary settle handling reaches this point.
+                        const deliveredAnswer = answer;
+                        const retryError = privateReturnAckLeakError(deliveredAnswer, privateReturnHeldTokens)
+                            ?? privateReturnMissingPonderError({
+                                latestUserRequest: latestUserMessageText(messages),
+                                answer: deliveredAnswer,
+                                sawPonder,
+                            })
+                            ?? getSettleRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp, options?.delegationDecision, sawSendMessageSelf, sawPonder, sawQuerySession, options?.currentObligation ?? null, options?.activeWorkFrame?.inner?.job, sawExternalStateQuery);
+                        const validDirectReply = mustResolveBeforeHandoffActive && intent === "direct_reply" && sawSteeringFollowUp;
+                        if (retryError === null) {
+                            try {
+                                if (!result.settleStreamed) {
+                                    const acceptedOutputCallbacks = streamCallbackBuffer?.callbacks ?? callbacks;
+                                    acceptedOutputCallbacks.onTextChunk(deliveredAnswer);
+                                }
+                                await streamCallbackBuffer?.flush();
+                            }
+                            catch (error) {
+                                callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
+                                streamCallbackBuffer?.discard();
+                                finishTerminalProviderError(new streaming_1.SettleFinalizationCallbackError(error), "unknown");
+                                continue;
+                            }
+                            callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), true);
+                            completion = {
+                                answer: deliveredAnswer,
+                                intent: validDirectReply ? "direct_reply" : intent === "blocked" ? "blocked" : "complete",
+                            };
+                            // Retractable owners already hold the validated answer. Final-only
+                            // owners receive it here, after every semantic continuation gate.
+                            pushGenerated(msg);
+                            if (validDirectReply) {
+                                const resumeWork = "direct reply delivered. resume the unresolved obligation now and keep working until you can finish or clearly report that you are blocked.";
+                                pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: resumeWork });
+                                providerRuntime.appendToolOutput(result.toolCalls[0].id, resumeWork);
+                            }
+                            else {
+                                const delivered = "(delivered)";
+                                pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: delivered });
+                                providerRuntime.appendToolOutput(result.toolCalls[0].id, delivered);
+                                outcome = intent === "blocked" ? "blocked" : "settled";
+                                done = true;
+                            }
                         }
                         else {
-                            const delivered = "(delivered)";
-                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: delivered });
-                            providerRuntime.appendToolOutput(result.toolCalls[0].id, delivered);
-                            outcome = intent === "blocked" ? "blocked" : "settled";
-                            done = true;
+                            // The payload is structurally final, but a semantic continuation
+                            // gate rejected it. Return that exact gate reason to the model.
+                            streamCallbackBuffer?.discard();
+                            callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
+                            callbacks.onClearText?.();
+                            pushGenerated(msg);
+                            const toolRetryMessage = retryError;
+                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: toolRetryMessage });
+                            providerRuntime.appendToolOutput(result.toolCalls[0].id, toolRetryMessage);
                         }
+                        continue;
                     }
-                    else {
-                        // The payload is structurally final, but a semantic continuation
-                        // gate rejected it. Return that exact gate reason to the model.
+                    // Check for observe sole call: intercept before tool execution
+                    const isSoleObserve = result.toolCalls.length === 1 && result.toolCalls[0].name === "observe";
+                    if (isSoleObserve) {
                         streamCallbackBuffer?.discard();
-                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
-                        callbacks.onClearText?.();
-                        pushGenerated(msg);
-                        const toolRetryMessage = retryError;
-                        pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: toolRetryMessage });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, toolRetryMessage);
-                    }
-                    continue;
-                }
-                // Check for observe sole call: intercept before tool execution
-                const isSoleObserve = result.toolCalls.length === 1 && result.toolCalls[0].name === "observe";
-                if (isSoleObserve) {
-                    streamCallbackBuffer?.discard();
-                    const observeArgs = validatedCallArguments.get(result.toolCalls[0]);
-                    let reason;
-                    if (typeof observeArgs?.reason === "string")
-                        reason = observeArgs.reason;
-                    callbacks.onToolStart("observe", observeArgs);
-                    (0, runtime_1.emitNervesEvent)({
-                        component: "engine",
-                        event: "engine.observe",
-                        message: "agent observed without responding",
-                        meta: { ...(reason ? { reason } : {}) },
-                    });
-                    callbacks.onToolEnd("observe", (0, tools_1.summarizeArgs)("observe", observeArgs), true);
-                    pushGenerated(msg);
-                    const silenced = "(silenced)";
-                    pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: silenced });
-                    providerRuntime.appendToolOutput(result.toolCalls[0].id, silenced);
-                    outcome = "observed";
-                    done = true;
-                    continue;
-                }
-                // Check for rest sole call: intercept before tool execution
-                const isSoleRest = result.toolCalls.length === 1 && result.toolCalls[0].name === "rest";
-                if (isSoleRest) {
-                    streamCallbackBuffer?.discard();
-                    const restArgs = validatedCallArguments.get(result.toolCalls[0]);
-                    callbacks.onToolStart("rest", restArgs);
-                    // Attention queue gate: reject rest if items remain
-                    const attentionQueue = augmentedToolContext?.delegatedOrigins;
-                    if (attentionQueue && attentionQueue.length > 0) {
-                        callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), false);
+                        const observeArgs = validatedCallArguments.get(result.toolCalls[0]);
+                        let reason;
+                        if (typeof observeArgs?.reason === "string")
+                            reason = observeArgs.reason;
+                        callbacks.onToolStart("observe", observeArgs);
+                        (0, runtime_1.emitNervesEvent)({
+                            component: "engine",
+                            event: "engine.observe",
+                            message: "agent observed without responding",
+                            meta: { ...(reason ? { reason } : {}) },
+                        });
+                        callbacks.onToolEnd("observe", (0, tools_1.summarizeArgs)("observe", observeArgs), true);
                         pushGenerated(msg);
-                        const gateMessage = "current held-work frame still has unsurfaced items — return each listed item with surface(delegationId=...) before you rest. Older transcript claims are historical; only the current held-work frame is the gate.";
-                        pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                        const silenced = "(silenced)";
+                        pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: silenced });
+                        providerRuntime.appendToolOutput(result.toolCalls[0].id, silenced);
+                        outcome = "observed";
+                        done = true;
                         continue;
                     }
-                    if (hasFreshPendingWork(options) && !freshWorkGateFired) {
-                        freshWorkGateFired = true;
-                        callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), false);
+                    // Check for rest sole call: intercept before tool execution
+                    const isSoleRest = result.toolCalls.length === 1 && result.toolCalls[0].name === "rest";
+                    if (isSoleRest) {
+                        streamCallbackBuffer?.discard();
+                        const restArgs = validatedCallArguments.get(result.toolCalls[0]);
+                        callbacks.onToolStart("rest", restArgs);
+                        // Attention queue gate: reject rest if items remain
+                        const attentionQueue = augmentedToolContext?.delegatedOrigins;
+                        if (attentionQueue && attentionQueue.length > 0) {
+                            callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), false);
+                            pushGenerated(msg);
+                            const gateMessage = "current held-work frame still has unsurfaced items — return each listed item with surface(delegationId=...) before you rest. Older transcript claims are historical; only the current held-work frame is the gate.";
+                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
+                            providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                            continue;
+                        }
+                        if (hasFreshPendingWork(options) && !freshWorkGateFired) {
+                            freshWorkGateFired = true;
+                            callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), false);
+                            pushGenerated(msg);
+                            const gateMessage = "fresh work arrived for me this turn — inspect the pending messages above and take the next concrete action before you rest.";
+                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
+                            providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "info",
+                                component: "engine",
+                                event: "engine.fresh_work_gate_fired",
+                                message: "rest deferred once because pending work arrived this turn; agent has been notified",
+                                meta: { pendingCount: options.pendingMessages.length },
+                            });
+                            continue;
+                        }
+                        callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), true);
                         pushGenerated(msg);
-                        const gateMessage = "fresh work arrived for me this turn — inspect the pending messages above and take the next concrete action before you rest.";
-                        pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                        const ack = "(resting)";
+                        pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: ack });
+                        providerRuntime.appendToolOutput(result.toolCalls[0].id, ack);
                         (0, runtime_1.emitNervesEvent)({
-                            level: "info",
                             component: "engine",
-                            event: "engine.fresh_work_gate_fired",
-                            message: "rest deferred once because pending work arrived this turn; agent has been notified",
-                            meta: { pendingCount: options.pendingMessages.length },
+                            event: "engine.rested",
+                            message: "resting until next heartbeat",
+                            meta: { ...(typeof restArgs?.status === "string" ? { status: restArgs.status } : {}) },
                         });
+                        outcome = "rested";
+                        done = true;
                         continue;
                     }
-                    callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), true);
-                    pushGenerated(msg);
-                    const ack = "(resting)";
-                    pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: ack });
-                    providerRuntime.appendToolOutput(result.toolCalls[0].id, ack);
-                    (0, runtime_1.emitNervesEvent)({
-                        component: "engine",
-                        event: "engine.rested",
-                        message: "resting until next heartbeat",
-                        meta: { ...(typeof restArgs?.status === "string" ? { status: restArgs.status } : {}) },
-                    });
-                    outcome = "rested";
-                    done = true;
-                    continue;
-                }
-                const requiredDispatchRejections = new Map();
-                for (const entry of validCalls) {
-                    const requiredArgs = entry.validated.arguments;
-                    const rejection = options?.requiredToolCalls?.validateToolCallBeforeDispatch?.(entry.call.name, requiredArgs);
-                    if (rejection)
-                        requiredDispatchRejections.set(entry.call.id, { name: entry.call.name, args: requiredArgs, message: rejection });
-                }
-                const approvalCalls = await Promise.all(validCalls.filter((entry) => !requiredDispatchRejections.has(entry.call.id)).map(async (entry) => {
-                    const classification = await (0, tools_1.classifyApprovalForInvocation)(entry.call.name, entry.validated.arguments, augmentedToolContext);
-                    return {
-                        ...entry,
-                        ...classification,
-                    };
-                }));
-                const protectedCall = approvalCalls.find((entry) => entry.policy.kind === "required");
-                if (protectedCall && result.toolCalls.length !== 1) {
-                    streamCallbackBuffer?.discard();
-                    pushGenerated(msg);
-                    for (const call of result.toolCalls) {
-                        const rejection = "rejected: approval-eligible tool must be the sole call; no call in this batch was executed.";
-                        pushGenerated({ role: "tool", tool_call_id: call.id, content: rejection });
-                        providerRuntime.appendToolOutput(call.id, rejection);
+                    const requiredDispatchRejections = new Map();
+                    for (const entry of validCalls) {
+                        const requiredArgs = entry.validated.arguments;
+                        const rejection = options?.requiredToolCalls?.validateToolCallBeforeDispatch?.(entry.call.name, requiredArgs);
+                        if (rejection)
+                            requiredDispatchRejections.set(entry.call.id, { name: entry.call.name, args: requiredArgs, message: rejection });
                     }
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "engine",
-                        event: "engine.approval_mixed_batch_rejected",
-                        message: "protected tool batch rejected before every handler",
-                        meta: { toolCallCount: result.toolCalls.length, protectedToolName: protectedCall.call.name },
-                    });
-                    continue;
-                }
-                if (protectedCall && protectedCall.policy.kind === "required") {
-                    if (!options?.approvalCoordinator) {
+                    const approvalCalls = await Promise.all(validCalls.filter((entry) => !requiredDispatchRejections.has(entry.call.id)).map(async (entry) => {
+                        const classification = await (0, tools_1.classifyApprovalForInvocation)(entry.call.name, entry.validated.arguments, augmentedToolContext);
+                        return {
+                            ...entry,
+                            ...classification,
+                        };
+                    }));
+                    const protectedCall = approvalCalls.find((entry) => entry.policy.kind === "required");
+                    if (protectedCall && result.toolCalls.length !== 1) {
                         streamCallbackBuffer?.discard();
                         pushGenerated(msg);
-                        const rejection = "rejected: this protected tool requires approval, but the approval coordinator is unavailable; the handler was not invoked.";
-                        pushGenerated({ role: "tool", tool_call_id: protectedCall.call.id, content: rejection });
-                        providerRuntime.appendToolOutput(protectedCall.call.id, rejection);
+                        for (const call of result.toolCalls) {
+                            const rejection = "rejected: approval-eligible tool must be the sole call; no call in this batch was executed.";
+                            pushGenerated({ role: "tool", tool_call_id: call.id, content: rejection });
+                            providerRuntime.appendToolOutput(call.id, rejection);
+                        }
                         (0, runtime_1.emitNervesEvent)({
                             level: "warn",
                             component: "engine",
-                            event: "engine.approval_coordinator_unavailable",
-                            message: "protected tool failed closed before handler execution",
-                            meta: { toolName: protectedCall.call.name, toolCallId: protectedCall.call.id },
+                            event: "engine.approval_mixed_batch_rejected",
+                            message: "protected tool batch rejected before every handler",
+                            meta: { toolCallCount: result.toolCalls.length, protectedToolName: protectedCall.call.name },
                         });
                         continue;
                     }
-                    streamCallbackBuffer?.discard();
-                    pushGenerated(msg);
-                    const toolDigest = (0, tool_arguments_1.digestJson)({
-                        name: protectedCall.call.name,
-                        schemaDigest: protectedCall.validated.schemaDigest,
-                        policyId: protectedCall.policy.policyId,
-                    });
-                    const policyDigest = (0, tool_arguments_1.digestJson)({
-                        policyId: protectedCall.policy.policyId,
-                        actionClass: protectedCall.policy.actionClass,
-                        classification: "required",
-                    });
-                    const committed = await options.approvalCoordinator.propose({
-                        toolCall: structuredClone(msg.tool_calls[0]),
-                        arguments: structuredClone(protectedCall.validated.arguments),
-                        preCallMessages,
-                        frozenAssistantMessage: structuredClone(msg),
-                        schemaDigest: protectedCall.validated.schemaDigest,
-                        toolDigest,
-                        policyDigest,
-                        policyId: protectedCall.policy.policyId,
-                        actionClass: protectedCall.policy.actionClass,
-                    });
-                    suspension = {
-                        approvalId: committed.approvalId,
-                        toolCallId: protectedCall.call.id,
-                        checkpointDigest: committed.checkpointDigest,
-                        suspendedSessionRevision: committed.suspendedSessionRevision,
-                    };
-                    outcome = "suspended";
-                    done = true;
-                    (0, runtime_1.emitNervesEvent)({
-                        component: "engine",
-                        event: "engine.approval_turn_suspended",
-                        message: "agent turn suspended before protected tool execution",
-                        meta: { approvalId: committed.approvalId, toolCallId: protectedCall.call.id },
-                    });
-                    continue;
-                }
-                const containsSoleCallOnlyViolation = result.toolCalls.length > 1
-                    && result.toolCalls.some((call) => {
-                        const terminalProjection = (0, tools_1.resolveToolDefinition)(call.name)?.terminalProjection;
-                        return SOLE_CALL_REJECTION[call.name] !== undefined
-                            || terminalProjection?.requiresSoleCall === true;
-                    });
-                if (callbacks.settleOutputMode === "final_only" && containsSoleCallOnlyViolation) {
-                    streamCallbackBuffer?.discard();
-                }
-                else {
-                    await streamCallbackBuffer?.flush();
-                }
-                pushGenerated(msg);
-                // Execute tools (sole-call tools in mixed calls are rejected inline)
-                for (const tc of result.toolCalls) {
-                    if (signal?.aborted)
-                        break;
-                    const requiredDispatchRejection = requiredDispatchRejections.get(tc.id);
-                    if (requiredDispatchRejection) {
-                        callbacks.onToolStart(tc.name, requiredDispatchRejection.args);
-                        callbacks.onToolEnd(tc.name, (0, tools_1.summarizeArgs)(tc.name, requiredDispatchRejection.args), false);
-                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: requiredDispatchRejection.message });
-                        providerRuntime.appendToolOutput(tc.id, requiredDispatchRejection.message);
-                        options?.toolBoundaryObserver?.({
-                            name: tc.name,
-                            reason: "dependency_rejected",
-                            globallyResolvable: typeof (0, tools_1.resolveToolDefinition)(tc.name)?.handler === "function",
-                            invoked: false,
-                            sideEffect: false,
+                    if (protectedCall && protectedCall.policy.kind === "required") {
+                        if (!options?.approvalCoordinator) {
+                            streamCallbackBuffer?.discard();
+                            pushGenerated(msg);
+                            const rejection = "rejected: this protected tool requires approval, but the approval coordinator is unavailable; the handler was not invoked.";
+                            pushGenerated({ role: "tool", tool_call_id: protectedCall.call.id, content: rejection });
+                            providerRuntime.appendToolOutput(protectedCall.call.id, rejection);
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "engine",
+                                event: "engine.approval_coordinator_unavailable",
+                                message: "protected tool failed closed before handler execution",
+                                meta: { toolName: protectedCall.call.name, toolCallId: protectedCall.call.id },
+                            });
+                            continue;
+                        }
+                        streamCallbackBuffer?.discard();
+                        pushGenerated(msg);
+                        const toolDigest = (0, tool_arguments_1.digestJson)({
+                            name: protectedCall.call.name,
+                            schemaDigest: protectedCall.validated.schemaDigest,
+                            policyId: protectedCall.policy.policyId,
+                        });
+                        const policyDigest = (0, tool_arguments_1.digestJson)({
+                            policyId: protectedCall.policy.policyId,
+                            actionClass: protectedCall.policy.actionClass,
+                            classification: "required",
                         });
+                        const committed = await options.approvalCoordinator.propose({
+                            toolCall: structuredClone(msg.tool_calls[0]),
+                            arguments: structuredClone(protectedCall.validated.arguments),
+                            preCallMessages,
+                            frozenAssistantMessage: structuredClone(msg),
+                            schemaDigest: protectedCall.validated.schemaDigest,
+                            toolDigest,
+                            policyDigest,
+                            policyId: protectedCall.policy.policyId,
+                            actionClass: protectedCall.policy.actionClass,
+                        });
+                        suspension = {
+                            approvalId: committed.approvalId,
+                            toolCallId: protectedCall.call.id,
+                            checkpointDigest: committed.checkpointDigest,
+                            suspendedSessionRevision: committed.suspendedSessionRevision,
+                        };
+                        outcome = "suspended";
+                        done = true;
                         (0, runtime_1.emitNervesEvent)({
-                            level: "warn",
                             component: "engine",
-                            event: "engine.required_tool_dispatch_rejected",
-                            message: "required tool dependency rejected before approval and handler dispatch",
-                            meta: { toolName: tc.name },
+                            event: "engine.approval_turn_suspended",
+                            message: "agent turn suspended before protected tool execution",
+                            meta: { approvalId: committed.approvalId, toolCallId: protectedCall.call.id },
                         });
                         continue;
                     }
-                    // Reject sole-call tools when mixed with other tool calls
-                    const terminalProjection = (0, tools_1.resolveToolDefinition)(tc.name)?.terminalProjection;
-                    const soleCallRejection = SOLE_CALL_REJECTION[tc.name]
-                        ?? (terminalProjection?.requiresSoleCall
-                            ? `rejected: ${tc.name} must be the only tool call.`
-                            : undefined);
-                    if (soleCallRejection) {
-                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: soleCallRejection });
-                        providerRuntime.appendToolOutput(tc.id, soleCallRejection);
-                        continue;
-                    }
-                    const args = validatedCallArguments.get(tc);
-                    const currentEffectFingerprint = effectFingerprint(tc.name, tc.arguments);
-                    if (forcingHistoricalEffect
-                        && currentEffectFingerprint
-                        && !unresolvedHistoricalEffects.some((effect) => effect.fingerprint === currentEffectFingerprint)) {
-                        const rejection = "rejected: this turn is retrying an unresolved historical effect, and these mutation arguments do not match it. Read current state or retry the exact failed effect.";
-                        callbacks.onToolStart(tc.name, args);
-                        callbacks.onToolEnd(tc.name, (0, tools_1.summarizeArgs)(tc.name, args), false);
-                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: rejection });
-                        providerRuntime.appendToolOutput(tc.id, rejection);
-                        continue;
+                    const containsSoleCallOnlyViolation = result.toolCalls.length > 1
+                        && result.toolCalls.some((call) => {
+                            const terminalProjection = (0, tools_1.resolveToolDefinition)(call.name)?.terminalProjection;
+                            return SOLE_CALL_REJECTION[call.name] !== undefined
+                                || terminalProjection?.requiresSoleCall === true;
+                        });
+                    if (callbacks.settleOutputMode === "final_only" && containsSoleCallOnlyViolation) {
+                        streamCallbackBuffer?.discard();
                     }
-                    if (tc.name === "send_message" && args.friendId === "self") {
-                        const latestUserText = latestUserMessageText(messages);
-                        if (!isPrivateRuntimeChannel && looksLikePrivateReturnRequest(latestUserText)) {
-                            const argSummary = (0, tools_1.summarizeArgs)(tc.name, args);
-                            const rejection = "private-return requests must use ponder, not send_message(friendId=self). Create a typed ponder packet with the marker/source request preserved, then only acknowledge that the private pass is queued.";
-                            callbacks.onToolStart(tc.name, args);
-                            callbacks.onToolEnd(tc.name, argSummary, false);
-                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: rejection });
-                            providerRuntime.appendToolOutput(tc.id, rejection);
-                            continue;
-                        }
-                        sawSendMessageSelf = true;
+                    else {
+                        await streamCallbackBuffer?.flush();
                     }
-                    if (tc.name === "speak") {
-                        // The canonical pre-batch schema gate guarantees a required string.
-                        const speakArgs = JSON.parse(tc.arguments);
-                        const speakMessage = speakArgs.message;
-                        const argSummary = (0, tools_1.summarizeArgs)("speak", { message: speakMessage });
-                        callbacks.onToolStart("speak", { message: speakMessage });
-                        if (speakMessage.trim().length === 0) {
-                            const err = "speak requires a non-empty `message` string.";
-                            callbacks.onToolEnd("speak", argSummary, false);
-                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: err });
-                            providerRuntime.appendToolOutput(tc.id, err);
+                    pushGenerated(msg);
+                    // Execute tools (sole-call tools in mixed calls are rejected inline)
+                    for (const tc of result.toolCalls) {
+                        if (signal?.aborted)
+                            break;
+                        const requiredDispatchRejection = requiredDispatchRejections.get(tc.id);
+                        if (requiredDispatchRejection) {
+                            callbacks.onToolStart(tc.name, requiredDispatchRejection.args);
+                            callbacks.onToolEnd(tc.name, (0, tools_1.summarizeArgs)(tc.name, requiredDispatchRejection.args), false);
+                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: requiredDispatchRejection.message });
+                            providerRuntime.appendToolOutput(tc.id, requiredDispatchRejection.message);
+                            options?.toolBoundaryObserver?.({
+                                name: tc.name,
+                                reason: "dependency_rejected",
+                                globallyResolvable: typeof (0, tools_1.resolveToolDefinition)(tc.name)?.handler === "function",
+                                invoked: false,
+                                sideEffect: false,
+                            });
                             (0, runtime_1.emitNervesEvent)({
                                 level: "warn",
                                 component: "engine",
-                                event: "engine.speak_invalid",
-                                message: "speak rejected: missing or empty message",
-                                meta: {},
+                                event: "engine.required_tool_dispatch_rejected",
+                                message: "required tool dependency rejected before approval and handler dispatch",
+                                meta: { toolName: tc.name },
                             });
                             continue;
                         }
-                        callbacks.onTextChunk(speakMessage);
-                        let speakDeliveryError = null;
-                        try {
-                            await callbacks.flushNow?.();
+                        // Reject sole-call tools when mixed with other tool calls
+                        const terminalProjection = (0, tools_1.resolveToolDefinition)(tc.name)?.terminalProjection;
+                        const soleCallRejection = SOLE_CALL_REJECTION[tc.name]
+                            ?? (terminalProjection?.requiresSoleCall
+                                ? `rejected: ${tc.name} must be the only tool call.`
+                                : undefined);
+                        if (soleCallRejection) {
+                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: soleCallRejection });
+                            providerRuntime.appendToolOutput(tc.id, soleCallRejection);
+                            continue;
                         }
-                        catch (err) {
-                            speakDeliveryError = err instanceof Error ? err : new Error(String(err));
+                        const args = validatedCallArguments.get(tc);
+                        const currentEffectFingerprint = effectFingerprint(tc.name, tc.arguments);
+                        if (forcingHistoricalEffect
+                            && currentEffectFingerprint
+                            && !unresolvedHistoricalEffects.some((effect) => effect.fingerprint === currentEffectFingerprint)) {
+                            const rejection = "rejected: this turn is retrying an unresolved historical effect, and these mutation arguments do not match it. Read current state or retry the exact failed effect.";
+                            callbacks.onToolStart(tc.name, args);
+                            callbacks.onToolEnd(tc.name, (0, tools_1.summarizeArgs)(tc.name, args), false);
+                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: rejection });
+                            providerRuntime.appendToolOutput(tc.id, rejection);
+                            continue;
                         }
-                        if (speakDeliveryError) {
-                            callbacks.onToolEnd("speak", argSummary, false);
-                            const failMsg = `speak delivery failed: ${speakDeliveryError.message}. the message did not reach your friend; do not assume they saw it.`;
-                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: failMsg });
-                            providerRuntime.appendToolOutput(tc.id, failMsg);
+                        if (tc.name === "send_message" && args.friendId === "self") {
+                            const latestUserText = latestUserMessageText(messages);
+                            if (!isPrivateRuntimeChannel && looksLikePrivateReturnRequest(latestUserText)) {
+                                const argSummary = (0, tools_1.summarizeArgs)(tc.name, args);
+                                const rejection = "private-return requests must use ponder, not send_message(friendId=self). Create a typed ponder packet with the marker/source request preserved, then only acknowledge that the private pass is queued.";
+                                callbacks.onToolStart(tc.name, args);
+                                callbacks.onToolEnd(tc.name, argSummary, false);
+                                pushGenerated({ role: "tool", tool_call_id: tc.id, content: rejection });
+                                providerRuntime.appendToolOutput(tc.id, rejection);
+                                continue;
+                            }
+                            sawSendMessageSelf = true;
+                        }
+                        if (tc.name === "speak") {
+                            // The canonical pre-batch schema gate guarantees a required string.
+                            const speakArgs = JSON.parse(tc.arguments);
+                            const speakMessage = speakArgs.message;
+                            const argSummary = (0, tools_1.summarizeArgs)("speak", { message: speakMessage });
+                            callbacks.onToolStart("speak", { message: speakMessage });
+                            if (speakMessage.trim().length === 0) {
+                                const err = "speak requires a non-empty `message` string.";
+                                callbacks.onToolEnd("speak", argSummary, false);
+                                pushGenerated({ role: "tool", tool_call_id: tc.id, content: err });
+                                providerRuntime.appendToolOutput(tc.id, err);
+                                (0, runtime_1.emitNervesEvent)({
+                                    level: "warn",
+                                    component: "engine",
+                                    event: "engine.speak_invalid",
+                                    message: "speak rejected: missing or empty message",
+                                    meta: {},
+                                });
+                                continue;
+                            }
+                            callbacks.onTextChunk(speakMessage);
+                            let speakDeliveryError = null;
+                            try {
+                                await callbacks.flushNow?.();
+                            }
+                            catch (err) {
+                                speakDeliveryError = err instanceof Error ? err : new Error(String(err));
+                            }
+                            if (speakDeliveryError) {
+                                callbacks.onToolEnd("speak", argSummary, false);
+                                const failMsg = `speak delivery failed: ${speakDeliveryError.message}. the message did not reach your friend; do not assume they saw it.`;
+                                pushGenerated({ role: "tool", tool_call_id: tc.id, content: failMsg });
+                                providerRuntime.appendToolOutput(tc.id, failMsg);
+                                (0, runtime_1.emitNervesEvent)({
+                                    level: "error",
+                                    component: "engine",
+                                    event: "engine.speak_delivery_failed",
+                                    message: "speak delivery failed",
+                                    meta: { error: speakDeliveryError.message, messageLength: speakMessage.length },
+                                });
+                                continue;
+                            }
+                            callbacks.onToolEnd("speak", argSummary, true);
+                            const ack = "(spoken)";
+                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: ack });
+                            providerRuntime.appendToolOutput(tc.id, ack);
                             (0, runtime_1.emitNervesEvent)({
-                                level: "error",
                                 component: "engine",
-                                event: "engine.speak_delivery_failed",
-                                message: "speak delivery failed",
-                                meta: { error: speakDeliveryError.message, messageLength: speakMessage.length },
+                                event: "engine.speak",
+                                message: "agent spoke mid-turn",
+                                meta: { messageLength: speakMessage.length },
                             });
                             continue;
                         }
-                        callbacks.onToolEnd("speak", argSummary, true);
-                        const ack = "(spoken)";
-                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: ack });
-                        providerRuntime.appendToolOutput(tc.id, ack);
-                        (0, runtime_1.emitNervesEvent)({
-                            component: "engine",
-                            event: "engine.speak",
-                            message: "agent spoke mid-turn",
-                            meta: { messageLength: speakMessage.length },
-                        });
-                        continue;
-                    }
-                    if (tc.name === "ponder") {
-                        const parsedArgs = normalizeLegacyPonderArgs(parsePonderPayload(tc.arguments));
-                        const argSummary = (0, tools_1.summarizeArgs)(tc.name, parsedArgs);
-                        callbacks.onToolStart(tc.name, parsedArgs);
-                        let toolResult;
-                        let success = false;
-                        try {
-                            const action = parsedArgs.action ?? "create";
-                            const currentSession = augmentedToolContext?.currentSession;
-                            const currentOrigin = currentSession
-                                ? { friendId: currentSession.friendId, channel: currentSession.channel, key: currentSession.key }
-                                : undefined;
-                            const isInnerChannel = currentOrigin?.friendId === "self" && currentOrigin?.channel === "inner";
-                            const shouldCreateReturnObligation = !!currentOrigin && !isInnerChannel;
-                            const attentionQueue = augmentedToolContext?.delegatedOrigins ?? [];
-                            const successCriteria = parseSuccessCriteria(parsedArgs.success_criteria);
-                            const payload = parsePacketPayload(parsedArgs.payload_json);
-                            let packet;
-                            let returnObligationId = null;
-                            let resultAction = "created";
-                            let privateReturnSourceRequest = "";
-                            if (action === "create") {
-                                if (isInnerChannel && attentionQueue.length > 0) {
-                                    throw new Error("private runtime already has held return work in the attention queue; surface the existing delegationId instead of creating a replacement ponder packet.");
-                                }
-                                const kind = parsedArgs.kind;
-                                const objective = typeof parsedArgs.objective === "string" ? parsedArgs.objective.trim() : "";
-                                const summary = typeof parsedArgs.summary === "string" ? parsedArgs.summary.trim() : "";
-                                const sourceRequest = currentOrigin && !isInnerChannel ? latestUserMessageText(messages) : "";
-                                privateReturnSourceRequest = sourceRequest;
-                                if (!kind || !objective || !successCriteria || !payload) {
-                                    throw new Error("ponder create requires kind, objective, success_criteria, and valid payload_json.");
-                                }
-                                const packetPayload = sourceRequest
-                                    ? { ...payload, sourceRequest }
-                                    : payload;
-                                const createLinkedReturnObligation = (id, packetId) => {
-                                    (0, obligations_1.createReturnObligation)((0, identity_2.getAgentName)(), {
-                                        id,
-                                        origin: currentOrigin,
-                                        status: "queued",
-                                        delegatedContent: buildPonderDelegatedContent({ summary, objective, sourceRequest }),
-                                        packetId,
-                                        createdAt: Date.now(),
-                                    });
-                                };
-                                const agentRoot = (0, identity_2.getAgentRoot)();
-                                let relatedObligationId;
-                                if (currentOrigin && !isInnerChannel) {
-                                    try {
-                                        const obligation = (0, obligations_1.createObligation)(agentRoot, {
+                        if (tc.name === "ponder") {
+                            const parsedArgs = normalizeLegacyPonderArgs(parsePonderPayload(tc.arguments));
+                            const argSummary = (0, tools_1.summarizeArgs)(tc.name, parsedArgs);
+                            callbacks.onToolStart(tc.name, parsedArgs);
+                            let toolResult;
+                            let success = false;
+                            try {
+                                const action = parsedArgs.action ?? "create";
+                                const currentSession = augmentedToolContext?.currentSession;
+                                const currentOrigin = currentSession
+                                    ? { friendId: currentSession.friendId, channel: currentSession.channel, key: currentSession.key }
+                                    : undefined;
+                                const isInnerChannel = currentOrigin?.friendId === "self" && currentOrigin?.channel === "inner";
+                                const shouldCreateReturnObligation = !!currentOrigin && !isInnerChannel;
+                                const attentionQueue = augmentedToolContext?.delegatedOrigins ?? [];
+                                const successCriteria = parseSuccessCriteria(parsedArgs.success_criteria);
+                                const payload = parsePacketPayload(parsedArgs.payload_json);
+                                let packet;
+                                let returnObligationId = null;
+                                let resultAction = "created";
+                                let privateReturnSourceRequest = "";
+                                if (action === "create") {
+                                    if (isInnerChannel && attentionQueue.length > 0) {
+                                        throw new Error("private runtime already has held return work in the attention queue; surface the existing delegationId instead of creating a replacement ponder packet.");
+                                    }
+                                    const kind = parsedArgs.kind;
+                                    const objective = typeof parsedArgs.objective === "string" ? parsedArgs.objective.trim() : "";
+                                    const summary = typeof parsedArgs.summary === "string" ? parsedArgs.summary.trim() : "";
+                                    const sourceRequest = currentOrigin && !isInnerChannel ? latestUserMessageText(messages) : "";
+                                    privateReturnSourceRequest = sourceRequest;
+                                    if (!kind || !objective || !successCriteria || !payload) {
+                                        throw new Error("ponder create requires kind, objective, success_criteria, and valid payload_json.");
+                                    }
+                                    const packetPayload = sourceRequest
+                                        ? { ...payload, sourceRequest }
+                                        : payload;
+                                    const createLinkedReturnObligation = (id, packetId) => {
+                                        (0, obligations_1.createReturnObligation)((0, identity_2.getAgentName)(), {
+                                            id,
                                             origin: currentOrigin,
-                                            content: objective,
+                                            status: "queued",
+                                            delegatedContent: buildPonderDelegatedContent({ summary, objective, sourceRequest }),
+                                            packetId,
+                                            createdAt: Date.now(),
                                         });
-                                        relatedObligationId = obligation.id;
+                                    };
+                                    const agentRoot = (0, identity_2.getAgentRoot)();
+                                    let relatedObligationId;
+                                    if (currentOrigin && !isInnerChannel) {
+                                        try {
+                                            const obligation = (0, obligations_1.createObligation)(agentRoot, {
+                                                origin: currentOrigin,
+                                                content: objective,
+                                            });
+                                            relatedObligationId = obligation.id;
+                                        }
+                                        catch {
+                                            relatedObligationId = undefined;
+                                        }
                                     }
-                                    catch {
-                                        relatedObligationId = undefined;
-                                    }
-                                }
-                                const frictionSignature = kind === "harness_friction" && typeof packetPayload.frictionSignature === "string"
-                                    ? packetPayload.frictionSignature
-                                    : null;
-                                const existing = frictionSignature && currentOrigin
-                                    ? (0, packets_1.findHarnessFrictionPacket)(agentRoot, currentOrigin, frictionSignature)
-                                    : null;
-                                if (existing) {
-                                    resultAction = "revised";
-                                    const existingActiveReturnId = shouldCreateReturnObligation
-                                        ? activeReturnObligationId((0, identity_2.getAgentName)(), existing.relatedReturnObligationId)
+                                    const frictionSignature = kind === "harness_friction" && typeof packetPayload.frictionSignature === "string"
+                                        ? packetPayload.frictionSignature
+                                        : null;
+                                    const existing = frictionSignature && currentOrigin
+                                        ? (0, packets_1.findHarnessFrictionPacket)(agentRoot, currentOrigin, frictionSignature)
                                         : null;
-                                    returnObligationId = existingActiveReturnId
-                                        ?? (shouldCreateReturnObligation ? (0, obligations_1.generateObligationId)(Date.now()) : null);
-                                    packet = existing.status === "drafting"
-                                        ? (0, packets_1.revisePonderPacket)(agentRoot, existing.id, {
+                                    if (existing) {
+                                        resultAction = "revised";
+                                        const existingActiveReturnId = shouldCreateReturnObligation
+                                            ? activeReturnObligationId((0, identity_2.getAgentName)(), existing.relatedReturnObligationId)
+                                            : null;
+                                        returnObligationId = existingActiveReturnId
+                                            ?? (shouldCreateReturnObligation ? (0, obligations_1.generateObligationId)(Date.now()) : null);
+                                        packet = existing.status === "drafting"
+                                            ? (0, packets_1.revisePonderPacket)(agentRoot, existing.id, {
+                                                kind,
+                                                objective,
+                                                summary,
+                                                successCriteria,
+                                                payload: packetPayload,
+                                            })
+                                            : existing;
+                                        if (returnObligationId && returnObligationId !== existing.relatedReturnObligationId) {
+                                            packet = (0, packets_1.advancePonderPacket)(agentRoot, packet.id, { relatedReturnObligationId: returnObligationId });
+                                            createLinkedReturnObligation(returnObligationId, packet.id);
+                                        }
+                                    }
+                                    else {
+                                        returnObligationId = shouldCreateReturnObligation ? (0, obligations_1.generateObligationId)(Date.now()) : null;
+                                        packet = (0, packets_1.createPonderPacket)(agentRoot, {
                                             kind,
                                             objective,
                                             summary,
                                             successCriteria,
+                                            ...(currentOrigin ? { origin: currentOrigin } : {}),
+                                            ...(relatedObligationId ? { relatedObligationId } : {}),
+                                            ...(returnObligationId ? { relatedReturnObligationId: returnObligationId } : {}),
+                                            ...(parsedArgs.follows_packet_id ? { followsPacketId: parsedArgs.follows_packet_id } : {}),
                                             payload: packetPayload,
-                                        })
-                                        : existing;
-                                    if (returnObligationId && returnObligationId !== existing.relatedReturnObligationId) {
-                                        packet = (0, packets_1.advancePonderPacket)(agentRoot, packet.id, { relatedReturnObligationId: returnObligationId });
-                                        createLinkedReturnObligation(returnObligationId, packet.id);
+                                        });
+                                        if (returnObligationId) {
+                                            createLinkedReturnObligation(returnObligationId, packet.id);
+                                        }
                                     }
                                 }
                                 else {
-                                    returnObligationId = shouldCreateReturnObligation ? (0, obligations_1.generateObligationId)(Date.now()) : null;
-                                    packet = (0, packets_1.createPonderPacket)(agentRoot, {
+                                    const packetId = typeof parsedArgs.packet_id === "string" ? parsedArgs.packet_id.trim() : "";
+                                    const kind = parsedArgs.kind;
+                                    const objective = typeof parsedArgs.objective === "string" ? parsedArgs.objective.trim() : "";
+                                    const summary = typeof parsedArgs.summary === "string" ? parsedArgs.summary.trim() : "";
+                                    if (!packetId || !kind || !objective || !successCriteria || !payload) {
+                                        throw new Error("ponder revise requires packet_id, kind, objective, success_criteria, and valid payload_json.");
+                                    }
+                                    packet = (0, packets_1.revisePonderPacket)((0, identity_2.getAgentRoot)(), packetId, {
                                         kind,
                                         objective,
                                         summary,
                                         successCriteria,
-                                        ...(currentOrigin ? { origin: currentOrigin } : {}),
-                                        ...(relatedObligationId ? { relatedObligationId } : {}),
-                                        ...(returnObligationId ? { relatedReturnObligationId: returnObligationId } : {}),
-                                        ...(parsedArgs.follows_packet_id ? { followsPacketId: parsedArgs.follows_packet_id } : {}),
-                                        payload: packetPayload,
+                                        payload,
                                     });
-                                    if (returnObligationId) {
-                                        createLinkedReturnObligation(returnObligationId, packet.id);
-                                    }
+                                    returnObligationId = packet.relatedReturnObligationId
+                                        && !(packet.origin?.friendId === "self" && packet.origin.channel === "inner")
+                                        ? packet.relatedReturnObligationId
+                                        : null;
+                                    resultAction = "revised";
                                 }
-                            }
-                            else {
-                                const packetId = typeof parsedArgs.packet_id === "string" ? parsedArgs.packet_id.trim() : "";
-                                const kind = parsedArgs.kind;
-                                const objective = typeof parsedArgs.objective === "string" ? parsedArgs.objective.trim() : "";
-                                const summary = typeof parsedArgs.summary === "string" ? parsedArgs.summary.trim() : "";
-                                if (!packetId || !kind || !objective || !successCriteria || !payload) {
-                                    throw new Error("ponder revise requires packet_id, kind, objective, success_criteria, and valid payload_json.");
+                                if (returnObligationId) {
+                                    for (const token of extractPrivateReturnHeldTokens(privateReturnSourceRequest)) {
+                                        privateReturnHeldTokens.add(token);
+                                    }
+                                    const agentName = (0, identity_2.getAgentName)();
+                                    await (0, socket_client_1.requestPrivateWake)(agentName, augmentedToolContext?.daemonSocketPath, buildPonderReturnPrivateWakeOptions({ agentName, packet, returnObligationId })).catch(() => undefined);
                                 }
-                                packet = (0, packets_1.revisePonderPacket)((0, identity_2.getAgentRoot)(), packetId, {
-                                    kind,
-                                    objective,
-                                    summary,
-                                    successCriteria,
-                                    payload,
+                                sawPonder = true;
+                                toolResult = buildPonderResult(packet, resultAction, returnObligationId);
+                                success = true;
+                                (0, runtime_1.emitNervesEvent)({
+                                    component: "engine",
+                                    event: "engine.ponder_packet",
+                                    message: "ponder packet touched",
+                                    meta: {
+                                        action: resultAction,
+                                        packetId: packet.id,
+                                        kind: packet.kind,
+                                        status: packet.status,
+                                    },
                                 });
-                                returnObligationId = packet.relatedReturnObligationId
-                                    && !(packet.origin?.friendId === "self" && packet.origin.channel === "inner")
-                                    ? packet.relatedReturnObligationId
-                                    : null;
-                                resultAction = "revised";
                             }
-                            if (returnObligationId) {
-                                for (const token of extractPrivateReturnHeldTokens(privateReturnSourceRequest)) {
-                                    privateReturnHeldTokens.add(token);
-                                }
-                                const agentName = (0, identity_2.getAgentName)();
-                                await (0, socket_client_1.requestPrivateWake)(agentName, augmentedToolContext?.daemonSocketPath, buildPonderReturnPrivateWakeOptions({ agentName, packet, returnObligationId })).catch(() => undefined);
+                            catch (error) {
+                                toolResult = error instanceof Error ? error.message : String(error);
                             }
-                            sawPonder = true;
-                            toolResult = buildPonderResult(packet, resultAction, returnObligationId);
-                            success = true;
-                            (0, runtime_1.emitNervesEvent)({
-                                component: "engine",
-                                event: "engine.ponder_packet",
-                                message: "ponder packet touched",
-                                meta: {
-                                    action: resultAction,
-                                    packetId: packet.id,
-                                    kind: packet.kind,
-                                    status: packet.status,
-                                },
-                            });
+                            callbacks.onToolEnd(tc.name, argSummary, success);
+                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: toolResult });
+                            providerRuntime.appendToolOutput(tc.id, toolResult);
+                            continue;
                         }
-                        catch (error) {
-                            toolResult = error instanceof Error ? error.message : String(error);
+                        /* v8 ignore next -- flag tested via truth-check integration tests @preserve */
+                        if (tc.name === "query_session")
+                            sawQuerySession = true;
+                        /* v8 ignore next -- flag tested via truth-check integration tests @preserve */
+                        if (tc.name === "bridge_manage")
+                            sawBridgeManage = true;
+                        /* v8 ignore next -- flag tested via truth-check integration tests @preserve */
+                        if (isExternalStateQuery(tc.name, args))
+                            sawExternalStateQuery = true;
+                        const argSummary = (0, tools_1.summarizeArgs)(tc.name, args);
+                        const toolLoop = (0, tool_loop_1.detectToolLoop)(toolLoopState, tc.name, args);
+                        if (toolLoop.stuck) {
+                            const rejection = `loop guard: ${toolLoop.message}`;
+                            callbacks.onToolStart(tc.name, args);
+                            callbacks.onToolEnd(tc.name, argSummary, false);
+                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: rejection });
+                            providerRuntime.appendToolOutput(tc.id, rejection);
+                            continue;
                         }
-                        callbacks.onToolEnd(tc.name, argSummary, success);
-                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: toolResult });
-                        providerRuntime.appendToolOutput(tc.id, toolResult);
-                        continue;
-                    }
-                    /* v8 ignore next -- flag tested via truth-check integration tests @preserve */
-                    if (tc.name === "query_session")
-                        sawQuerySession = true;
-                    /* v8 ignore next -- flag tested via truth-check integration tests @preserve */
-                    if (tc.name === "bridge_manage")
-                        sawBridgeManage = true;
-                    /* v8 ignore next -- flag tested via truth-check integration tests @preserve */
-                    if (isExternalStateQuery(tc.name, args))
-                        sawExternalStateQuery = true;
-                    const argSummary = (0, tools_1.summarizeArgs)(tc.name, args);
-                    const toolLoop = (0, tool_loop_1.detectToolLoop)(toolLoopState, tc.name, args);
-                    if (toolLoop.stuck) {
-                        const rejection = `loop guard: ${toolLoop.message}`;
                         callbacks.onToolStart(tc.name, args);
-                        callbacks.onToolEnd(tc.name, argSummary, false);
-                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: rejection });
-                        providerRuntime.appendToolOutput(tc.id, rejection);
-                        continue;
-                    }
-                    callbacks.onToolStart(tc.name, args);
-                    let toolResult;
-                    let success;
-                    try {
-                        const execToolFn = options?.execTool ?? tools_1.execTool;
-                        const routineActionSelection = approvalCalls.find((entry) => entry.call.id === tc.id)?.routineActionSelection;
-                        const executionToolContext = routineActionSelection && augmentedToolContext ? { ...augmentedToolContext, routineActionSelection } : augmentedToolContext;
-                        if (requiredToolCallNames.includes(tc.name) && !options?.requiredToolCalls?.requireSuccessfulResults)
+                        let toolResult;
+                        let success;
+                        try {
+                            const execToolFn = options?.execTool ?? tools_1.execTool;
+                            const routineActionSelection = approvalCalls.find((entry) => entry.call.id === tc.id)?.routineActionSelection;
+                            const executionToolContext = routineActionSelection && augmentedToolContext ? { ...augmentedToolContext, routineActionSelection } : augmentedToolContext;
+                            if (requiredToolCallNames.includes(tc.name) && !options?.requiredToolCalls?.requireSuccessfulResults)
+                                dispatchedRequiredToolCalls.add(tc.name);
+                            toolResult = await execToolFn(tc.name, args, executionToolContext);
+                            success = true;
+                        }
+                        catch (e) {
+                            toolResult = `error: ${e}`;
+                            success = false;
+                            augmentedToolContext?.habitSession?.recordError?.(toolResult);
+                        }
+                        const validatedRequiredResult = success && requiredToolCallNames.includes(tc.name) && options?.requiredToolCalls?.requireSuccessfulResults
+                            ? requiredToolResultSucceeded(tc.name, toolResult, args, options.requiredToolCalls.validateRequiredToolResult)
+                            : false;
+                        if (validatedRequiredResult) {
                             dispatchedRequiredToolCalls.add(tc.name);
-                        toolResult = await execToolFn(tc.name, args, executionToolContext);
-                        success = true;
-                    }
-                    catch (e) {
-                        toolResult = `error: ${e}`;
-                        success = false;
-                        augmentedToolContext?.habitSession?.recordError?.(toolResult);
-                    }
-                    const validatedRequiredResult = success && requiredToolCallNames.includes(tc.name) && options?.requiredToolCalls?.requireSuccessfulResults
-                        ? requiredToolResultSucceeded(tc.name, toolResult, args, options.requiredToolCalls.validateRequiredToolResult)
-                        : false;
-                    if (validatedRequiredResult) {
-                        dispatchedRequiredToolCalls.add(tc.name);
-                        for (const requiredName of options?.requiredToolCalls?.requiredToolCallsAfterResult?.(tc.name, args, toolResult) ?? []) {
-                            if (!candidateToolNames.has(requiredName)) {
-                                (0, runtime_1.emitNervesEvent)({ level: "error", component: "engine", event: "engine.required_tool_unadvertised", message: "dependent required tool is not advertised for the active channel", meta: { toolName: requiredName, channel: String(channel) } });
-                                throw new Error(`dependent required tool is not advertised for this channel: ${requiredName}`);
+                            for (const requiredName of options?.requiredToolCalls?.requiredToolCallsAfterResult?.(tc.name, args, toolResult) ?? []) {
+                                if (!candidateToolNames.has(requiredName)) {
+                                    (0, runtime_1.emitNervesEvent)({ level: "error", component: "engine", event: "engine.required_tool_unadvertised", message: "dependent required tool is not advertised for the active channel", meta: { toolName: requiredName, channel: String(channel) } });
+                                    throw new Error(`dependent required tool is not advertised for this channel: ${requiredName}`);
+                                }
+                                if (!requiredToolCallNames.includes(requiredName))
+                                    requiredToolCallNames.push(requiredName);
                             }
-                            if (!requiredToolCallNames.includes(requiredName))
-                                requiredToolCallNames.push(requiredName);
                         }
+                        if (success && currentEffectFingerprint && !toolResultIndicatesFailure(toolResult)) {
+                            unresolvedHistoricalEffects = unresolvedHistoricalEffects.filter((effect) => effect.fingerprint !== currentEffectFingerprint);
+                        }
+                        const resolvedRiskProfile = (0, tools_1.resolveToolDefinition)(tc.name)?.riskProfile;
+                        const toolRiskProfile = typeof resolvedRiskProfile === "function" ? resolvedRiskProfile(args) : resolvedRiskProfile;
+                        options?.toolBoundaryObserver?.({
+                            name: tc.name,
+                            reason: "dispatched",
+                            globallyResolvable: typeof (0, tools_1.resolveToolDefinition)(tc.name)?.handler === "function",
+                            invoked: true,
+                            sideEffect: success && toolRiskProfile?.mutates !== "none",
+                        });
+                        toolResult = (0, tool_friction_1.rewriteToolResultForModel)(tc.name, toolResult, toolFrictionLedger);
+                        (0, tool_loop_1.recordToolOutcome)(toolLoopState, tc.name, args, toolResult, success);
+                        callbacks.onToolEnd(tc.name, (0, tools_1.buildToolResultSummary)(tc.name, args, toolResult, success), success);
+                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: toolResult });
+                        providerRuntime.appendToolOutput(tc.id, toolResult);
+                        callbacks.onToolResult?.(messagesWithoutRequiredCorrections());
                     }
-                    if (success && currentEffectFingerprint && !toolResultIndicatesFailure(toolResult)) {
-                        unresolvedHistoricalEffects = unresolvedHistoricalEffects.filter((effect) => effect.fingerprint !== currentEffectFingerprint);
-                    }
-                    const resolvedRiskProfile = (0, tools_1.resolveToolDefinition)(tc.name)?.riskProfile;
-                    const toolRiskProfile = typeof resolvedRiskProfile === "function" ? resolvedRiskProfile(args) : resolvedRiskProfile;
-                    options?.toolBoundaryObserver?.({
-                        name: tc.name,
-                        reason: "dispatched",
-                        globallyResolvable: typeof (0, tools_1.resolveToolDefinition)(tc.name)?.handler === "function",
-                        invoked: true,
-                        sideEffect: success && toolRiskProfile?.mutates !== "none",
-                    });
-                    toolResult = (0, tool_friction_1.rewriteToolResultForModel)(tc.name, toolResult, toolFrictionLedger);
-                    (0, tool_loop_1.recordToolOutcome)(toolLoopState, tc.name, args, toolResult, success);
-                    callbacks.onToolEnd(tc.name, (0, tools_1.buildToolResultSummary)(tc.name, args, toolResult, success), success);
-                    pushGenerated({ role: "tool", tool_call_id: tc.id, content: toolResult });
-                    providerRuntime.appendToolOutput(tc.id, toolResult);
-                    callbacks.onToolResult?.(messages);
                 }
             }
-        }
-        catch (e) {
-            // Abort is not an error — just stop cleanly
-            if (e instanceof provider_attempt_1.ProviderAttemptAbortError || signal?.aborted) {
-                stripLastToolCalls(messages);
-                stripLastToolCalls(generatedMessages);
-                outcome = "aborted";
-                break;
-            }
-            const errorForClassification = e instanceof Error ? e : /* v8 ignore next -- defensive @preserve */ new Error(String(e));
-            let providerClassification;
-            try {
-                providerClassification = providerRuntime.classifyError(errorForClassification);
-            }
-            catch {
-                /* v8 ignore next -- defensive: classifyError should not throw @preserve */
-                providerClassification = "unknown";
+            catch (e) {
+                // Abort is not an error — just stop cleanly
+                if (e instanceof provider_attempt_1.ProviderAttemptAbortError || signal?.aborted) {
+                    stripLastToolCalls(messages);
+                    stripLastToolCalls(generatedMessages);
+                    outcome = "aborted";
+                    break;
+                }
+                const errorForClassification = e instanceof Error ? e : /* v8 ignore next -- defensive @preserve */ new Error(String(e));
+                let providerClassification;
+                try {
+                    providerClassification = providerRuntime.classifyError(errorForClassification);
+                }
+                catch {
+                    /* v8 ignore next -- defensive: classifyError should not throw @preserve */
+                    providerClassification = "unknown";
+                }
+                finishTerminalProviderError(errorForClassification, providerClassification);
             }
-            finishTerminalProviderError(errorForClassification, providerClassification);
         }
     }
+    finally {
+        removeRequiredCorrections();
+    }
     options?.captureGeneratedMessages?.(structuredClone(generatedMessages));
     (0, runtime_1.emitNervesEvent)({
         event: "engine.turn_end",