@ouro.bot/cli 0.1.0-alpha.53 → 0.1.0-alpha.530

package/dist/heart/core.js

@@ -1,94 +1,162 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasToolIntent = exports.buildSystem = exports.toResponsesTools = exports.toResponsesInput = exports.streamResponsesApi = exports.streamChatCompletion = exports.getToolsForChannel = exports.summarizeArgs = exports.execTool = exports.tools = void 0;
 exports.createProviderRegistry = createProviderRegistry;
 exports.resetProviderRuntime = resetProviderRuntime;
 exports.getModel = getModel;
 exports.getProvider = getProvider;
 exports.createSummarize = createSummarize;
 exports.getProviderDisplayLabel = getProviderDisplayLabel;
+exports.isChatStyleChannel = isChatStyleChannel;
+exports.isExternalStateQuery = isExternalStateQuery;
+exports.getSettleRetryError = getSettleRetryError;
 exports.stripLastToolCalls = stripLastToolCalls;
 exports.repairOrphanedToolCalls = repairOrphanedToolCalls;
-exports.isTransientError = isTransientError;
-exports.classifyTransientError = classifyTransientError;
 exports.runAgent = runAgent;
 const config_1 = require("./config");
 const identity_1 = require("./identity");
 const tools_1 = require("../repertoire/tools");
 const channel_1 = require("../mind/friends/channel");
+const tools_2 = require("../repertoire/tools");
 const runtime_1 = require("../nerves/runtime");
 const context_1 = require("../mind/context");
 const prompt_1 = require("../mind/prompt");
-const associative_recall_1 = require("../mind/associative-recall");
+const kept_notes_1 = require("./kept-notes");
+const error_classification_1 = require("./providers/error-classification");
 const anthropic_1 = require("./providers/anthropic");
 const azure_1 = require("./providers/azure");
 const minimax_1 = require("./providers/minimax");
 const openai_codex_1 = require("./providers/openai-codex");
-let _providerRuntime = null;
-function createProviderRegistry() {
-    const factories = {
-        azure: azure_1.createAzureProviderRuntime,
-        anthropic: anthropic_1.createAnthropicProviderRuntime,
-        minimax: minimax_1.createMinimaxProviderRuntime,
-        "openai-codex": openai_codex_1.createOpenAICodexProviderRuntime,
+const github_copilot_1 = require("./providers/github-copilot");
+const identity_2 = require("./identity");
+const socket_client_1 = require("./daemon/socket-client");
+const obligations_1 = require("../arc/obligations");
+const tool_loop_1 = require("./tool-loop");
+const packets_1 = require("../arc/packets");
+const tool_friction_1 = require("./tool-friction");
+const provider_models_1 = require("./provider-models");
+const provider_credentials_1 = require("./provider-credentials");
+const provider_state_1 = require("./provider-state");
+const provider_attempt_1 = require("./provider-attempt");
+const _providerRuntimes = {
+    human: null,
+    agent: null,
+};
+function providerLaneForFacing(facing) {
+    return facing === "human" ? "outward" : "inner";
+}
+function resolveRuntimeProviderBinding(facing) {
+    const agentName = (0, identity_2.getAgentName)();
+    const lane = providerLaneForFacing(facing);
+    const stateResult = (0, provider_state_1.readProviderState)((0, identity_2.getAgentRoot)(agentName));
+    if (stateResult.ok) {
+        const binding = stateResult.state.lanes[lane];
+        return { lane, provider: binding.provider, model: binding.model };
+    }
+    if (stateResult.reason === "invalid") {
+        throw new Error(`provider state for ${agentName} is invalid at ${stateResult.statePath}: ${stateResult.error}`);
+    }
+    // First-run and SerpentGuide bootstrap path. Daemon startup normally
+    // bootstraps state/providers.json from agent.json before model calls.
+    const config = (0, identity_1.loadAgentConfig)();
+    const facingConfig = facing === "human" ? config.humanFacing : config.agentFacing;
+    return { lane, provider: facingConfig.provider, model: facingConfig.model };
+}
+async function getProviderRuntimeFingerprint(facing) {
+    const agentName = (0, identity_2.getAgentName)();
+    const binding = resolveRuntimeProviderBinding(facing);
+    const credential = await (0, provider_credentials_1.readProviderCredentialRecord)(agentName, binding.provider);
+    if (!credential.ok) {
+        throw new Error([
+            `${binding.lane} provider ${binding.provider} (${binding.model}) has no credentials for ${agentName}.`,
+            credential.error,
+            `Run \`ouro auth --agent ${agentName} --provider ${binding.provider}\`.`,
+        ].join("\n"));
+    }
+    return {
+        binding,
+        fingerprint: JSON.stringify({
+            lane: binding.lane,
+            provider: binding.provider,
+            model: binding.model,
+            credentialRevision: credential.record.revision,
+        }),
+        credential: credential.record,
     };
+}
+function createProviderRegistry() {
     return {
-        resolve() {
-            const provider = (0, identity_1.loadAgentConfig)().provider;
-            return factories[provider]();
+        resolve(provider, model, credential) {
+            const providerConfig = { ...credential.config, ...credential.credentials };
+            switch (provider) {
+                case "azure":
+                    return (0, azure_1.createAzureProviderRuntime)(model, providerConfig);
+                case "anthropic":
+                    return (0, anthropic_1.createAnthropicProviderRuntime)(model, providerConfig);
+                case "minimax":
+                    return (0, minimax_1.createMinimaxProviderRuntime)(model, providerConfig);
+                case "openai-codex":
+                    return (0, openai_codex_1.createOpenAICodexProviderRuntime)(model, providerConfig);
+                case "github-copilot":
+                    return (0, github_copilot_1.createGithubCopilotProviderRuntime)(model, providerConfig);
+            }
         },
     };
 }
-function getProviderRuntime() {
-    if (!_providerRuntime) {
-        try {
-            _providerRuntime = createProviderRegistry().resolve();
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "engine.provider_init_error",
-                component: "engine",
-                message: msg,
-                meta: {},
-            });
-            // eslint-disable-next-line no-console -- pre-boot guard: provider init failure
-            console.error(`\n[fatal] ${msg}\n`);
-            process.exit(1);
-            throw new Error("unreachable");
-        }
-        if (!_providerRuntime) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "engine.provider_init_error",
-                component: "engine",
-                message: "provider runtime could not be initialized.",
-                meta: {},
-            });
-            process.exit(1);
-            throw new Error("unreachable");
+async function getProviderRuntime(facing = "human") {
+    try {
+        const { binding, fingerprint, credential } = await getProviderRuntimeFingerprint(facing);
+        const cached = _providerRuntimes[facing];
+        if (!cached || cached.fingerprint !== fingerprint) {
+            const runtime = createProviderRegistry().resolve(binding.provider, binding.model, credential);
+            _providerRuntimes[facing] = runtime ? { fingerprint, runtime } : null;
         }
     }
-    return _providerRuntime;
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.provider_init_error",
+            component: "engine",
+            message: msg,
+            meta: { facing },
+        });
+        // eslint-disable-next-line no-console -- pre-boot guard: provider init failure
+        console.error(`\n[fatal] ${msg}\n`);
+        throw error instanceof Error ? error : new Error(msg);
+    }
+    if (!_providerRuntimes[facing]) {
+        const msg = "provider runtime could not be initialized.";
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.provider_init_error",
+            component: "engine",
+            message: msg,
+            meta: { facing },
+        });
+        // eslint-disable-next-line no-console -- pre-boot guard: provider init failure
+        console.error(`\n[fatal] ${msg}\n`);
+        throw new Error(msg);
+    }
+    return _providerRuntimes[facing].runtime;
 }
 /**
- * Clear the cached provider runtime so the next call to getProviderRuntime()
- * re-creates it from current config. Used by the adoption specialist to
- * switch provider context without restarting the process.
+ * Clear the cached provider runtime so the next access re-creates it from
+ * current config. Runtime access also auto-refreshes when the selected
+ * provider fingerprint changes on disk.
  */
 function resetProviderRuntime() {
-    _providerRuntime = null;
+    _providerRuntimes.human = null;
+    _providerRuntimes.agent = null;
 }
-function getModel() {
-    return getProviderRuntime().model;
+function getModel(facing = "human") {
+    return resolveRuntimeProviderBinding(facing).model;
 }
-function getProvider() {
-    return getProviderRuntime().id;
+function getProvider(facing = "human") {
+    return resolveRuntimeProviderBinding(facing).provider;
 }
-function createSummarize() {
+function createSummarize(facing = "human") {
     return async (transcript, instruction) => {
-        const runtime = getProviderRuntime();
+        const runtime = await getProviderRuntime(facing);
         const client = runtime.client;
         const response = await client.chat.completions.create({
             model: runtime.model,
@@ -101,32 +169,66 @@ function createSummarize() {
         return response.choices?.[0]?.message?.content ?? transcript;
     };
 }
-function getProviderDisplayLabel() {
-    const model = getModel();
+function getProviderDisplayLabel(facing = "human") {
+    const binding = resolveRuntimeProviderBinding(facing);
+    const provider = binding.provider;
+    const model = binding.model || "unknown";
     const providerLabelBuilders = {
-        azure: () => `azure openai (${(0, config_1.getAzureConfig)().deployment || "default"}, model: ${model})`,
+        azure: () => {
+            return `azure openai (model: ${model})`;
+        },
         anthropic: () => `anthropic (${model})`,
         minimax: () => `minimax (${model})`,
         "openai-codex": () => `openai codex (${model})`,
+        /* v8 ignore next -- branch: tested via display label unit test @preserve */
+        "github-copilot": () => `github copilot (${model})`,
     };
-    return providerLabelBuilders[getProvider()]();
+    return providerLabelBuilders[provider]();
+}
+/**
+ * Strip <think>...</think> blocks for the violation-detection check at the
+ * end of a streaming turn. Used to tell legitimate text-only responses
+ * apart from the MiniMax-M2.7 "only thinking, no tool call" violation
+ * shape. Mirrors the more thorough stripThinkBlocks helper in
+ * senses/shared-turn.ts (which is for operator-facing output) — kept
+ * inline here to avoid pulling senses/ into the core module's import graph.
+ */
+function stripThinkBlocksForViolationCheck(input) {
+    let out = input;
+    for (;;) {
+        const open = out.indexOf("<think>");
+        if (open === -1)
+            break;
+        const close = out.indexOf("</think>", open + "<think>".length);
+        if (close === -1) {
+            out = out.slice(0, open);
+            break;
+        }
+        out = out.slice(0, open) + out.slice(close + "</think>".length);
+    }
+    return out.trim();
+}
+function hasFreshPendingWork(options) {
+    const pendingMessages = options?.pendingMessages;
+    if (!Array.isArray(pendingMessages))
+        return false;
+    return pendingMessages.some((message) => typeof message?.content === "string"
+        && message.content.trim().length > 0);
 }
-// Re-export tools, execTool, summarizeArgs from ./tools for backward compat
-var tools_2 = require("../repertoire/tools");
-Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_2.tools; } });
-Object.defineProperty(exports, "execTool", { enumerable: true, get: function () { return tools_2.execTool; } });
-Object.defineProperty(exports, "summarizeArgs", { enumerable: true, get: function () { return tools_2.summarizeArgs; } });
-Object.defineProperty(exports, "getToolsForChannel", { enumerable: true, get: function () { return tools_2.getToolsForChannel; } });
-// Re-export streaming functions for backward compat
-var streaming_1 = require("./streaming");
-Object.defineProperty(exports, "streamChatCompletion", { enumerable: true, get: function () { return streaming_1.streamChatCompletion; } });
-Object.defineProperty(exports, "streamResponsesApi", { enumerable: true, get: function () { return streaming_1.streamResponsesApi; } });
-Object.defineProperty(exports, "toResponsesInput", { enumerable: true, get: function () { return streaming_1.toResponsesInput; } });
-Object.defineProperty(exports, "toResponsesTools", { enumerable: true, get: function () { return streaming_1.toResponsesTools; } });
-// Re-export prompt functions for backward compat
-var prompt_2 = require("../mind/prompt");
-Object.defineProperty(exports, "buildSystem", { enumerable: true, get: function () { return prompt_2.buildSystem; } });
-function parseFinalAnswerPayload(argumentsText) {
+/** Chat-style channels expose the `speak` tool — outer human-conversation channels
+ *  where mid-turn delivery is meaningful. Inner dialog has `ponder`. MCP returns
+ *  synchronously. Mail is batch. Anything else (unknown channel) treats as non-chat. */
+function isChatStyleChannel(channel) {
+    return channel === "cli" || channel === "teams" || channel === "bluebubbles";
+}
+// Sole-call tools must be the only tool call in a turn. When they appear
+// alongside other tools, the sole-call tool is rejected with this message.
+const SOLE_CALL_REJECTION = {
+    settle: "rejected: settle must be the only tool call. finish your work first, then call settle alone.",
+    observe: "rejected: observe must be the only tool call. call observe alone when you want to stay silent.",
+    rest: "rejected: rest must be the only tool call. finish your work first, then call rest alone.",
+};
+function parseSettlePayload(argumentsText) {
     try {
         const parsed = JSON.parse(argumentsText);
         if (typeof parsed === "string") {
@@ -146,18 +248,93 @@ function parseFinalAnswerPayload(argumentsText) {
         return {};
     }
 }
-function getFinalAnswerRetryError(mustResolveBeforeHandoff, intent, sawSteeringFollowUp) {
+function parsePonderPayload(argumentsText) {
+    try {
+        const parsed = JSON.parse(argumentsText);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function parseSuccessCriteria(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const criteria = raw
+        .split("\n")
+        .map((line) => line.replace(/^\s*[-*]\s*/, "").trim())
+        .filter((line) => line.length > 0);
+    return criteria.length > 0 ? criteria : null;
+}
+function parsePacketPayload(raw) {
+    if (typeof raw !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeLegacyPonderArgs(parsed) {
+    if (typeof parsed.thought !== "string" || parsed.thought.trim().length === 0) {
+        return parsed;
+    }
+    return {
+        action: "create",
+        kind: "reflection",
+        objective: parsed.thought.trim(),
+        summary: typeof parsed.say === "string" ? parsed.say.trim() : "",
+        success_criteria: "- preserve the thread for later work",
+        payload_json: "{}",
+    };
+}
+function buildPonderResult(packet, action, returnObligationId) {
+    return JSON.stringify({
+        ok: true,
+        packet_id: packet.id,
+        action,
+        status: packet.status,
+        return_obligation_id: returnObligationId,
+    }, null, 2);
+}
+/** Returns true when a tool call queries external state (GitHub, npm registry). */
+function isExternalStateQuery(toolName, args) {
+    if (toolName !== "shell")
+        return false;
+    const cmd = String(args.command ?? "");
+    return /\bgh\s+(pr|run|api|issue)\b/.test(cmd) || /\bnpm\s+(view|info|show)\b/.test(cmd);
+}
+function getSettleRetryError(mustResolveBeforeHandoff, intent, sawSteeringFollowUp, _delegationDecision, sawSendMessageSelf, sawPonder, _sawQuerySession, currentObligation, innerJob, sawExternalStateQuery) {
+    // Delegation adherence removed: the delegation decision is surfaced in the
+    // system prompt as a suggestion. Hard-gating settle caused infinite
+    // rejection loops where the agent couldn't respond to the user at all.
+    // The agent is free to follow or ignore the delegation hint.
+    // 2. Pending obligation not addressed
+    if (innerJob?.obligationStatus === "pending" && !sawSendMessageSelf && !sawPonder) {
+        return "you're still holding something from an earlier conversation -- someone is waiting for your answer. finish the thought first, or ponder to keep working on it privately.";
+    }
+    // 3. mustResolveBeforeHandoff + missing intent
     if (mustResolveBeforeHandoff && !intent) {
-        return "your final_answer is missing required intent. when you must keep going until done or blocked, call final_answer again with answer plus intent=complete, blocked, or direct_reply.";
+        return "your settle is missing required intent. when you must keep going until done or blocked, call settle again with answer plus intent=complete, blocked, or direct_reply.";
     }
+    // 4. mustResolveBeforeHandoff + direct_reply without follow-up
     if (mustResolveBeforeHandoff && intent === "direct_reply" && !sawSteeringFollowUp) {
-        return "your final_answer used intent=direct_reply without a newer steering follow-up. continue the unresolved work, or call final_answer again with intent=complete or blocked when appropriate.";
+        return "your settle used intent=direct_reply without a newer steering follow-up. continue the unresolved work, or call settle again with intent=complete or blocked when appropriate.";
     }
-    return "your final_answer was incomplete or malformed. call final_answer again with your complete response.";
+    // 5. mustResolveBeforeHandoff + complete while a live return loop is still active
+    if (mustResolveBeforeHandoff && intent === "complete" && currentObligation && !sawSteeringFollowUp) {
+        return "you still owe the live session a visible return on this work. don't end the turn yet — continue until you've brought back the external-state update, or use intent=blocked with the concrete blocker.";
+    }
+    // 6. External-state grounding: obligation + complete requires fresh external verification
+    if (intent === "complete" && currentObligation && !sawExternalStateQuery && !sawSteeringFollowUp) {
+        return "you're claiming this work is complete, but the external state hasn't been verified this turn. ground your claim with a fresh check (gh pr view, npm view, gh run view, etc.) before calling settle.";
+    }
+    return null;
 }
-// Re-export kick utilities for backward compat
-var kicks_1 = require("./kicks");
-Object.defineProperty(exports, "hasToolIntent", { enumerable: true, get: function () { return kicks_1.hasToolIntent; } });
 function upsertSystemPrompt(messages, systemText) {
     const systemMessage = { role: "system", content: systemText };
     if (messages[0]?.role === "system") {
@@ -195,27 +372,39 @@ const TOOL_SCAN_BOUNDARY_ROLES = new Set(["assistant", "user"]);
 // 1. If an assistant message has tool_calls but missing tool results, inject synthetic error results.
 // 2. If a tool result's tool_call_id doesn't match any tool_calls in a preceding assistant message, remove it.
 // This prevents 400 errors from the API after an aborted turn.
+//
+// Position-aware: a tool result is orphaned when its tool_call_id hasn't been
+// defined by an assistant message AT THIS POSITION yet. MiniMax-M2.7 reuses
+// canonical tool_call_ids across turns, so the global-set check that this
+// function used previously kept misordered tool results that MiniMax then
+// rejected with error 2013 ("tool result's tool id not found"). Walking
+// in order matches what MiniMax actually enforces.
 function repairOrphanedToolCalls(messages) {
-    // Pass 1: collect all valid tool_call IDs from assistant messages
-    const validCallIds = new Set();
-    for (const msg of messages) {
+    // Pass 1: walk in order, accumulate seen tool_call_ids per-position, and
+    // mark tool results for removal if their id hasn't been defined yet.
+    const seenCallIds = new Set();
+    const removeIndices = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
         if (msg.role === "assistant") {
             const asst = msg;
             if (asst.tool_calls) {
                 for (const tc of asst.tool_calls)
-                    validCallIds.add(tc.id);
+                    seenCallIds.add(tc.id);
             }
+            continue;
         }
-    }
-    // Pass 2: remove orphaned tool results (tool_call_id not in any assistant's tool_calls)
-    for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i].role === "tool") {
-            const toolMsg = messages[i];
-            if (!validCallIds.has(toolMsg.tool_call_id)) {
-                messages.splice(i, 1);
+        if (msg.role === "tool") {
+            const toolMsg = msg;
+            if (!seenCallIds.has(toolMsg.tool_call_id)) {
+                removeIndices.push(i);
             }
         }
     }
+    // Splice from the end so earlier indices stay valid.
+    for (let i = removeIndices.length - 1; i >= 0; i--) {
+        messages.splice(removeIndices[i], 1);
+    }
     // Pass 3: inject synthetic results for tool_calls missing their tool results
     for (let i = 0; i < messages.length; i++) {
         const msg = messages[i];
@@ -237,10 +426,13 @@ function repairOrphanedToolCalls(messages) {
         }
         const missing = asst.tool_calls.filter((tc) => !resultIds.has(tc.id));
         if (missing.length > 0) {
+            // AX rule: the agent must see what happened. Don't say "interrupted"
+            // — that's vague. Tell them the result was lost, possible causes,
+            // and what to do next.
             const syntheticResults = missing.map((tc) => ({
                 role: "tool",
                 tool_call_id: tc.id,
-                content: "error: tool call was interrupted (previous turn timed out or was aborted)",
+                content: "error: this tool call's result was lost — the previous turn ended before the tool finished (provider rejection, daemon interrupt, or the tool itself errored). if the work needs to be done, retry the tool call now.",
             }));
             let insertAt = i + 1;
             while (insertAt < messages.length && messages[insertAt].role === "tool")
@@ -263,49 +455,67 @@ function isContextOverflow(err) {
         return true;
     return false;
 }
-// Detect transient network errors worth retrying
-function isTransientError(err) {
-    if (!(err instanceof Error))
-        return false;
-    const msg = err.message || "";
-    const code = err.code || "";
-    // Node.js network error codes
-    if (["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "EPIPE",
-        "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "ECONNABORTED"].includes(code))
-        return true;
-    // OpenAI SDK / fetch errors
-    if (msg.includes("fetch failed"))
-        return true;
-    if (msg.includes("network") && !msg.includes("context"))
-        return true;
-    if (msg.includes("ECONNRESET") || msg.includes("ETIMEDOUT"))
-        return true;
-    if (msg.includes("socket hang up"))
-        return true;
-    if (msg.includes("getaddrinfo"))
-        return true;
-    // HTTP 429 / 500 / 502 / 503 / 504
-    const status = err.status;
-    if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504)
-        return true;
-    return false;
+const RETRY_LABELS = {
+    "auth-failure": "auth error",
+    "usage-limit": "usage limit",
+    "rate-limit": "rate limited",
+    "server-error": "server error",
+    "network-error": "network error",
+    "unknown": "error",
+};
+function waitForProviderRetry(delayMs, signal) {
+    if (!signal) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, delayMs);
+        });
+    }
+    return new Promise((resolve, reject) => {
+        let timer;
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new provider_attempt_1.ProviderAttemptAbortError());
+        };
+        timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, delayMs);
+        if (signal.aborted) {
+            onAbort();
+            return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
 }
-function classifyTransientError(err) {
-    if (!(err instanceof Error))
-        return "unknown error";
-    const status = err.status;
-    if (status === 429)
-        return "rate limited";
-    if (status === 401 || status === 403)
-        return "auth error";
-    if (status && status >= 500)
-        return "server error";
-    return "network error";
+function buildAuthFailureGuidance(provider, model, agentName, detail) {
+    const mismatch = (0, provider_models_1.getProviderModelMismatchMessage)(provider, model);
+    const modelLabel = model
+        ? mismatch
+            ? `${provider} [configured model: ${model}]`
+            : `${provider} (${model})`
+        : provider;
+    const lines = [`${modelLabel} authentication failed.`];
+    const cleanDetail = detail.replace(/\s+/g, " ").trim();
+    if (cleanDetail)
+        lines.push(`provider detail: ${cleanDetail.length > 300 ? `${cleanDetail.slice(0, 297)}...` : cleanDetail}`);
+    lines.push("");
+    lines.push("To keep using this provider:");
+    lines.push(`  1. Run \`ouro auth --agent ${agentName} --provider ${provider}\``);
+    if (mismatch) {
+        const defaultModel = (0, provider_models_1.getDefaultModelForProvider)(provider);
+        lines.push("");
+        lines.push("Config warning:");
+        lines.push(`  - ${mismatch}`);
+        lines.push("  - Repair the configured model with:");
+        lines.push(`    \`ouro config model --agent ${agentName} --facing human ${defaultModel}\``);
+        lines.push(`    \`ouro config model --agent ${agentName} --facing agent ${defaultModel}\``);
+    }
+    lines.push("");
+    lines.push(`To use another configured provider instead, run \`ouro auth switch --agent ${agentName} --provider <provider>\`.`);
+    return lines.join("\n");
 }
-const MAX_RETRIES = 3;
-const RETRY_BASE_MS = 2000;
 async function runAgent(messages, callbacks, channel, signal, options) {
-    const providerRuntime = getProviderRuntime();
+    const facing = (0, channel_1.channelToFacing)(channel);
+    let providerRuntime = await getProviderRuntime(facing);
     const provider = providerRuntime.id;
     const toolChoiceRequired = options?.toolChoiceRequired ?? true;
     const traceId = options?.traceId;
@@ -329,6 +539,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     // Refresh system prompt at start of each turn when channel is provided.
     // If refresh fails, keep existing system prompt (or inject a minimal safe fallback)
     // so turn execution remains consistent and non-fatal.
+    let structuredSystemPrompt;
     if (channel) {
         try {
             const buildSystemOptions = {
@@ -337,7 +548,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 supportedReasoningEfforts: providerRuntime.supportedReasoningEfforts,
             };
             const refreshed = await (0, prompt_1.buildSystem)(channel, buildSystemOptions, currentContext);
-            upsertSystemPrompt(messages, refreshed);
+            structuredSystemPrompt = refreshed;
+            upsertSystemPrompt(messages, (0, prompt_1.flattenSystemPrompt)(refreshed));
         }
         catch (error) {
             const hadExistingSystemPrompt = messages[0]?.role === "system" && typeof messages[0].content === "string";
@@ -358,40 +570,120 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             });
         }
     }
-    await (0, associative_recall_1.injectAssociativeRecall)(messages);
+    if (channel) {
+        await (0, kept_notes_1.injectKeptNotes)(messages, {
+            channel,
+            friend: currentContext?.friend,
+            judge: async (input) => (0, kept_notes_1.createKeptNotesJudge)(await getProviderRuntime("agent"), signal)(input),
+            signal,
+            traceId,
+        });
+    }
     let done = false;
     let lastUsage;
     let overflowRetried = false;
-    let retryCount = 0;
-    let outcome = "complete";
+    let outcome = "settled";
     let completion;
+    let terminalError;
+    let terminalErrorClassification;
     let sawSteeringFollowUp = false;
     let mustResolveBeforeHandoffActive = options?.mustResolveBeforeHandoff === true;
     let currentReasoningEffort = "medium";
+    let sawSendMessageSelf = false;
+    let sawPonder = false;
+    let sawQuerySession = false;
+    let sawBridgeManage = false;
+    let sawExternalStateQuery = false;
+    // Once-per-turn flag for the fresh-work rest gate. Without this, an agent
+    // that called rest, was told "fresh work arrived", processed the items,
+    // and called rest again would get the same message forever — the gate
+    // condition is read from the turn-start snapshot of pendingMessages,
+    // which doesn't update mid-turn. The agent only needs to be told once;
+    // after that, repeated rest attempts mean they've acknowledged.
+    let freshWorkGateFired = false;
+    // Counter for "no tool call returned despite tool_choice=required" violations.
+    // MiniMax reasoning models occasionally emit only a <think>...</think>
+    // block and stop, without any tool call — even when tool_choice is set to
+    // "required". This is a provider-level violation; the harness retries with
+    // a corrective nudge up to a small cap rather than silently accepting an
+    // empty turn.
+    let noToolCallRetries = 0;
+    const NO_TOOL_CALL_MAX_RETRIES = 2;
+    const toolLoopState = (0, tool_loop_1.createToolLoopState)();
+    const toolFrictionLedger = (0, tool_friction_1.createToolFrictionLedger)();
+    const finishTerminalProviderError = (error, classification) => {
+        terminalError = error;
+        terminalErrorClassification = classification;
+        /* v8 ignore start — auth-failure guidance: tested via provider error classification tests @preserve */
+        if (terminalErrorClassification === "auth-failure") {
+            const agentName = (0, identity_2.getAgentName)();
+            const currentProvider = providerRuntime.id;
+            callbacks.onError(new Error(buildAuthFailureGuidance(currentProvider, providerRuntime.model, agentName, terminalError.message)), "terminal");
+        }
+        else {
+            callbacks.onError(terminalError, "terminal");
+        }
+        /* v8 ignore stop */
+        const errorDetails = (0, error_classification_1.extractProviderErrorDetails)(terminalError);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.error",
+            trace_id: traceId,
+            component: "engine",
+            message: terminalError.message,
+            meta: {
+                provider: providerRuntime.id,
+                model: providerRuntime.model,
+                errorClassification: terminalErrorClassification,
+                ...(errorDetails.status !== undefined ? { httpStatus: errorDetails.status } : {}),
+                ...(errorDetails.bodyExcerpt ? { bodyExcerpt: errorDetails.bodyExcerpt } : {}),
+                summary: (0, error_classification_1.summarizeProviderError)(terminalError, terminalErrorClassification, providerRuntime.id, providerRuntime.model),
+            },
+        });
+        stripLastToolCalls(messages);
+        outcome = "errored";
+        done = true;
+    };
     // Prevent MaxListenersExceeded warning — each iteration adds a listener
     try {
         require("events").setMaxListeners(50, signal);
     }
     catch { /* unsupported */ }
     const toolPreferences = currentContext?.friend?.toolPreferences;
-    const baseTools = options?.tools ?? (0, tools_1.getToolsForChannel)(channel ? (0, channel_1.getChannelCapabilities)(channel) : undefined, toolPreferences && Object.keys(toolPreferences).length > 0 ? toolPreferences : undefined, currentContext, providerRuntime.capabilities);
+    const baseTools = options?.tools ?? (0, tools_1.getToolsForChannel)(channel ? (0, channel_1.getChannelCapabilities)(channel) : undefined, toolPreferences && Object.keys(toolPreferences).length > 0 ? toolPreferences : undefined, currentContext, providerRuntime.capabilities, options?.mcpManager, providerRuntime.model);
     // Augment tool context with reasoning effort controls from provider
     const augmentedToolContext = options?.toolContext
         ? {
             ...options.toolContext,
             supportedReasoningEfforts: providerRuntime.supportedReasoningEfforts,
             setReasoningEffort: (level) => { currentReasoningEffort = level; },
+            activeWorkFrame: options?.activeWorkFrame,
         }
         : undefined;
     // 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) {
-        // When toolChoiceRequired is true (the default), include final_answer
-        // so the model can signal completion. With tool_choice: required, the
-        // model must call a tool every turn — final_answer is how it exits.
-        // Overridable via options.toolChoiceRequired = false (e.g. CLI).
-        const activeTools = toolChoiceRequired ? [...baseTools, tools_1.finalAnswerTool] : baseTools;
+        // Channel-based tool filtering:
+        // - Inner dialog: 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).
+        // Inner dialog 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 isInnerDialog = channel === "inner";
+        const filteredBaseTools = isInnerDialog
+            ? baseTools.filter((t) => t.function.name !== "send_message")
+            : baseTools;
+        const activeTools = [
+            ...filteredBaseTools,
+            tools_1.ponderTool,
+            ...(isInnerDialog ? [tools_2.surfaceToolDef, tools_1.restTool] : []),
+            ...(!isInnerDialog ? [tools_1.observeTool] : []),
+            ...(!isInnerDialog ? [tools_1.settleTool] : []),
+            ...(isChatStyleChannel(channel ?? "") ? [tools_1.speakTool] : []),
+        ];
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
         if (steeringFollowUps.length > 0) {
             const hasSupersedingFollowUp = steeringFollowUps.some((followUp) => followUp.effect === "clear_and_supersede");
@@ -418,26 +710,124 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             break;
         }
         try {
-            callbacks.onModelStart();
-            const result = await providerRuntime.streamTurn({
-                messages,
-                activeTools,
-                callbacks,
-                signal,
-                traceId,
-                toolChoiceRequired,
-                reasoningEffort: currentReasoningEffort,
+            const callProviderTurn = async () => {
+                callbacks.onModelStart();
+                try {
+                    return await providerRuntime.streamTurn({
+                        messages,
+                        activeTools,
+                        callbacks,
+                        signal,
+                        traceId,
+                        toolChoiceRequired,
+                        reasoningEffort: currentReasoningEffort,
+                        eagerSettleStreaming: true,
+                        systemPrompt: structuredSystemPrompt,
+                    });
+                }
+                catch (error) {
+                    if (signal?.aborted)
+                        throw new provider_attempt_1.ProviderAttemptAbortError();
+                    throw error;
+                }
+            };
+            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);
+                        const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
+                        const trimmed = (0, context_1.trimMessages)(messages, maxTokens, contextMargin, maxTokens * 2);
+                        messages.splice(0, messages.length, ...trimmed);
+                        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 {
+                        await (0, provider_credentials_1.refreshProviderCredentialPool)((0, identity_2.getAgentName)(), {
+                            preserveCachedOnFailure: true,
+                            providers: [record.provider],
+                        });
+                        _providerRuntimes[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;
+            }
+            const result = attempt.value;
             // Track usage from the latest API call
             if (result.usage)
                 lastUsage = result.usage;
-            retryCount = 0; // reset on success
             // SHARED: build CC-format assistant message from TurnResult
             const msg = {
                 role: "assistant",
             };
-            if (result.content)
-                msg.content = result.content;
+            // 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,
@@ -457,35 +847,108 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             }
             // Phase annotation for Codex provider
             const hasPhaseAnnotation = providerRuntime.capabilities.has("phase-annotation");
-            const isSoleFinalAnswer = result.toolCalls.length === 1 && result.toolCalls[0].name === "final_answer";
+            const isSoleSettle = result.toolCalls.length === 1 && result.toolCalls[0].name === "settle";
             if (hasPhaseAnnotation) {
-                msg.phase = isSoleFinalAnswer ? "final_answer" : "commentary";
+                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;
             if (!result.toolCalls.length) {
-                // No tool calls — accept response as-is.
-                // (Kick detection disabled; tool_choice: required + final_answer
-                // is the primary loop control. See src/heart/kicks.ts to re-enable.)
+                if (onlyThinkContent && toolChoiceRequired && noToolCallRetries < NO_TOOL_CALL_MAX_RETRIES) {
+                    // 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,
+                        },
+                    });
+                    messages.push(msg);
+                    messages.push({
+                        role: "user",
+                        content: isInnerDialog
+                            ? "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.
                 messages.push(msg);
                 done = true;
             }
             else {
-                // Check for final_answer sole call: intercept before tool execution
-                if (isSoleFinalAnswer) {
+                // Reset the retry counter on any successful tool call.
+                noToolCallRetries = 0;
+                // Check for settle sole call: intercept before tool execution
+                if (isSoleSettle) {
+                    /* v8 ignore next -- defensive: JSON.parse catch for malformed settle args @preserve */
+                    const settleArgs = (() => { try {
+                        return JSON.parse(result.toolCalls[0].arguments);
+                    }
+                    catch {
+                        return {};
+                    } })();
+                    callbacks.onToolStart("settle", settleArgs);
+                    // Inner dialog attention queue gate: reject settle if items remain
+                    const attentionQueue = (augmentedToolContext ?? options?.toolContext)?.delegatedOrigins;
+                    if (isInnerDialog && attentionQueue && attentionQueue.length > 0) {
+                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
+                        callbacks.onClearText?.();
+                        messages.push(msg);
+                        const gateMessage = "you're holding thoughts someone is waiting for — surface them before you settle.";
+                        messages.push({ 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 } = parseFinalAnswerPayload(result.toolCalls[0].arguments);
+                    const { answer, intent } = parseSettlePayload(result.toolCalls[0].arguments);
+                    // Inner dialog settle: no CompletionMetadata, "(settled)" ack
+                    if (isInnerDialog) {
+                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), true);
+                        messages.push(msg);
+                        const settled = "(settled)";
+                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: settled });
+                        providerRuntime.appendToolOutput(result.toolCalls[0].id, settled);
+                        outcome = "settled";
+                        done = true;
+                        continue;
+                    }
+                    const retryError = getSettleRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp, options?.delegationDecision, sawSendMessageSelf, sawPonder, sawQuerySession, options?.currentObligation ?? null, options?.activeWorkFrame?.inner?.job, sawExternalStateQuery);
+                    const deliveredAnswer = answer;
                     const validDirectReply = mustResolveBeforeHandoffActive && intent === "direct_reply" && sawSteeringFollowUp;
                     const validTerminalIntent = intent === "complete" || intent === "blocked";
-                    const validClosure = answer != null
+                    const validClosure = deliveredAnswer != null
+                        && !retryError
                         && (!mustResolveBeforeHandoffActive || validDirectReply || validTerminalIntent);
                     if (validClosure) {
+                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), true);
                         completion = {
-                            answer,
+                            answer: deliveredAnswer,
                             intent: validDirectReply ? "direct_reply" : intent === "blocked" ? "blocked" : "complete",
                         };
-                        if (result.finalAnswerStreamed) {
+                        if (result.settleStreamed) {
                             // The streaming layer already parsed and emitted the answer
-                            // progressively via FinalAnswerParser. Skip clearing and
+                            // progressively via SettleParser. Skip clearing and
                             // re-emitting to avoid double-delivery.
                         }
                         else {
@@ -493,7 +956,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             callbacks.onClearText?.();
                             // Emit the answer through the callback pipeline so channels receive it.
                             // Never truncate -- channel adapters handle splitting long messages.
-                            callbacks.onTextChunk(answer);
+                            callbacks.onTextChunk(deliveredAnswer);
                         }
                         messages.push(msg);
                         if (validDirectReply) {
@@ -505,32 +968,114 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             const delivered = "(delivered)";
                             messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: delivered });
                             providerRuntime.appendToolOutput(result.toolCalls[0].id, delivered);
-                            outcome = intent === "blocked" ? "blocked" : "complete";
+                            outcome = intent === "blocked" ? "blocked" : "settled";
                             done = true;
                         }
                     }
                     else {
-                        // Answer is undefined -- the model's final_answer was incomplete or
+                        // Answer is undefined -- the model's settle was incomplete or
                         // malformed. Clear any partial streamed text or noise, then push the
                         // assistant msg + error tool result and let the model try again.
+                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
                         callbacks.onClearText?.();
-                        const retryError = getFinalAnswerRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp);
                         messages.push(msg);
-                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: retryError });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, retryError);
+                        const toolRetryMessage = retryError
+                            ?? "your settle was incomplete or malformed. call settle again with your complete response.";
+                        messages.push({ 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) {
+                    /* v8 ignore next -- defensive: JSON.parse catch for malformed observe args @preserve */
+                    const observeArgs = (() => { try {
+                        return JSON.parse(result.toolCalls[0].arguments);
+                    }
+                    catch {
+                        return {};
+                    } })();
+                    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);
+                    messages.push(msg);
+                    const silenced = "(silenced)";
+                    messages.push({ 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) {
+                    const restArgs = (() => { try {
+                        return JSON.parse(result.toolCalls[0].arguments);
+                    }
+                    catch {
+                        return {};
+                    } })();
+                    callbacks.onToolStart("rest", restArgs);
+                    // Attention queue gate: reject rest if items remain
+                    const attentionQueue = (augmentedToolContext ?? options?.toolContext)?.delegatedOrigins;
+                    if (attentionQueue && attentionQueue.length > 0) {
+                        callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), false);
+                        messages.push(msg);
+                        const gateMessage = "you're holding thoughts someone is waiting for — surface them before you rest.";
+                        messages.push({ 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);
+                        messages.push(msg);
+                        const gateMessage = "fresh work arrived for me this turn — inspect the pending messages above and take the next concrete action before you rest.";
+                        messages.push({ 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);
+                    messages.push(msg);
+                    const ack = "(resting)";
+                    messages.push({ 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;
                 }
                 messages.push(msg);
-                // SHARED: execute tools (final_answer in mixed calls is rejected inline)
+                // Execute tools (sole-call tools in mixed calls are rejected inline)
                 for (const tc of result.toolCalls) {
                     if (signal?.aborted)
                         break;
-                    // Intercept final_answer in mixed call: reject it
-                    if (tc.name === "final_answer") {
-                        const rejection = "rejected: final_answer must be the only tool call. Finish your work first, then call final_answer alone.";
-                        messages.push({ role: "tool", tool_call_id: tc.id, content: rejection });
-                        providerRuntime.appendToolOutput(tc.id, rejection);
+                    // Reject sole-call tools when mixed with other tool calls
+                    const soleCallRejection = SOLE_CALL_REJECTION[tc.name];
+                    if (soleCallRejection) {
+                        messages.push({ role: "tool", tool_call_id: tc.id, content: soleCallRejection });
+                        providerRuntime.appendToolOutput(tc.id, soleCallRejection);
                         continue;
                     }
                     let args = {};
@@ -540,21 +1085,213 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     catch {
                         /* ignore */
                     }
-                    const argSummary = (0, tools_1.summarizeArgs)(tc.name, args);
-                    // Confirmation check for mutate tools
-                    if ((0, tools_1.isConfirmationRequired)(tc.name) && !options?.skipConfirmation) {
-                        let decision = "denied";
-                        if (callbacks.onConfirmAction) {
-                            decision = await callbacks.onConfirmAction(tc.name, args);
+                    if (tc.name === "send_message" && args.friendId === "self") {
+                        sawSendMessageSelf = true;
+                    }
+                    if (tc.name === "speak") {
+                        let speakArgs = {};
+                        try {
+                            speakArgs = JSON.parse(tc.arguments);
+                        }
+                        catch { /* malformed */ }
+                        const speakMessage = typeof speakArgs.message === "string" ? 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);
+                            messages.push({ 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 (decision !== "confirmed") {
-                            const cancelled = "Action cancelled by user.";
-                            callbacks.onToolStart(tc.name, args);
-                            callbacks.onToolEnd(tc.name, argSummary, false);
-                            messages.push({ role: "tool", tool_call_id: tc.id, content: cancelled });
-                            providerRuntime.appendToolOutput(tc.id, cancelled);
+                        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.`;
+                            messages.push({ 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)";
+                        messages.push({ 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 ?? options?.toolContext)?.currentSession;
+                            const currentOrigin = currentSession
+                                ? { friendId: currentSession.friendId, channel: currentSession.channel, key: currentSession.key }
+                                : undefined;
+                            const isInnerChannel = currentOrigin?.friendId === "self" && currentOrigin?.channel === "inner";
+                            const successCriteria = parseSuccessCriteria(parsedArgs.success_criteria);
+                            const payload = parsePacketPayload(parsedArgs.payload_json);
+                            let packet;
+                            let returnObligationId = null;
+                            let resultAction = "created";
+                            if (action === "create") {
+                                const kind = parsedArgs.kind;
+                                const objective = typeof parsedArgs.objective === "string" ? parsedArgs.objective.trim() : "";
+                                const summary = typeof parsedArgs.summary === "string" ? parsedArgs.summary.trim() : "";
+                                if (!kind || !objective || !successCriteria || !payload) {
+                                    throw new Error("ponder create requires kind, objective, success_criteria, and valid payload_json.");
+                                }
+                                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;
+                                    }
+                                }
+                                const frictionSignature = kind === "harness_friction" && typeof payload.frictionSignature === "string"
+                                    ? payload.frictionSignature
+                                    : null;
+                                const existing = frictionSignature && currentOrigin
+                                    ? (0, packets_1.findHarnessFrictionPacket)(agentRoot, currentOrigin, frictionSignature)
+                                    : null;
+                                if (existing) {
+                                    resultAction = "revised";
+                                    returnObligationId = existing.relatedReturnObligationId ?? null;
+                                    packet = existing.status === "drafting"
+                                        ? (0, packets_1.revisePonderPacket)(agentRoot, existing.id, {
+                                            kind,
+                                            objective,
+                                            summary,
+                                            successCriteria,
+                                            payload,
+                                        })
+                                        : existing;
+                                }
+                                else {
+                                    returnObligationId = (0, obligations_1.generateObligationId)(Date.now());
+                                    packet = (0, packets_1.createPonderPacket)(agentRoot, {
+                                        kind,
+                                        objective,
+                                        summary,
+                                        successCriteria,
+                                        ...(currentOrigin ? { origin: currentOrigin } : {}),
+                                        ...(relatedObligationId ? { relatedObligationId } : {}),
+                                        relatedReturnObligationId: returnObligationId,
+                                        ...(parsedArgs.follows_packet_id ? { followsPacketId: parsedArgs.follows_packet_id } : {}),
+                                        payload,
+                                    });
+                                    (0, obligations_1.createReturnObligation)((0, identity_2.getAgentName)(), {
+                                        id: returnObligationId,
+                                        origin: currentOrigin ?? { friendId: "self", channel: "inner", key: "dialog" },
+                                        status: "queued",
+                                        delegatedContent: (summary || objective).length > 120 ? `${(summary || objective).slice(0, 117)}...` : (summary || objective),
+                                        packetId: packet.id,
+                                        createdAt: Date.now(),
+                                    });
+                                }
+                            }
+                            else if (action === "revise") {
+                                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,
+                                    payload,
+                                });
+                                returnObligationId = packet.relatedReturnObligationId ?? null;
+                                resultAction = "revised";
+                            }
+                            else {
+                                throw new Error("ponder requires action=create or revise.");
+                            }
+                            try {
+                                await (0, socket_client_1.requestInnerWake)((0, identity_2.getAgentName)());
+                            }
+                            catch { /* daemon may not be running */ }
+                            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,
+                                },
+                            });
+                        }
+                        catch (error) {
+                            toolResult = error instanceof Error ? error.message : String(error);
+                        }
+                        callbacks.onToolEnd(tc.name, argSummary, success);
+                        messages.push({ 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);
+                        messages.push({ role: "tool", tool_call_id: tc.id, content: rejection });
+                        providerRuntime.appendToolOutput(tc.id, rejection);
+                        continue;
                     }
                     callbacks.onToolStart(tc.name, args);
                     let toolResult;
@@ -568,69 +1305,32 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         toolResult = `error: ${e}`;
                         success = false;
                     }
-                    callbacks.onToolEnd(tc.name, argSummary, success);
+                    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);
                     messages.push({ 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 (signal?.aborted) {
+            if (e instanceof provider_attempt_1.ProviderAttemptAbortError || signal?.aborted) {
                 stripLastToolCalls(messages);
                 outcome = "aborted";
                 break;
             }
-            // Context overflow: trim aggressively and retry once
-            if (isContextOverflow(e) && !overflowRetried) {
-                overflowRetried = true;
-                stripLastToolCalls(messages);
-                const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
-                const trimmed = (0, context_1.trimMessages)(messages, maxTokens, contextMargin, maxTokens * 2);
-                messages.splice(0, messages.length, ...trimmed);
-                providerRuntime.resetTurnState(messages);
-                callbacks.onError(new Error("context trimmed, retrying..."), "transient");
-                continue;
+            const errorForClassification = e instanceof Error ? e : /* v8 ignore next -- defensive @preserve */ new Error(String(e));
+            let providerClassification;
+            try {
+                providerClassification = providerRuntime.classifyError(errorForClassification);
             }
-            // Transient errors: retry with exponential backoff
-            if (isTransientError(e) && retryCount < MAX_RETRIES) {
-                retryCount++;
-                const delay = RETRY_BASE_MS * Math.pow(2, retryCount - 1);
-                const cause = classifyTransientError(e);
-                callbacks.onError(new Error(`${cause}, retrying in ${delay / 1000}s (${retryCount}/${MAX_RETRIES})...`), "transient");
-                // Wait with abort support
-                const aborted = await new Promise((resolve) => {
-                    const timer = setTimeout(() => resolve(false), delay);
-                    if (signal) {
-                        const onAbort = () => { clearTimeout(timer); resolve(true); };
-                        if (signal.aborted) {
-                            clearTimeout(timer);
-                            resolve(true);
-                            return;
-                        }
-                        signal.addEventListener("abort", onAbort, { once: true });
-                    }
-                });
-                if (aborted) {
-                    stripLastToolCalls(messages);
-                    outcome = "aborted";
-                    break;
-                }
-                providerRuntime.resetTurnState(messages);
-                continue;
+            catch {
+                /* v8 ignore next -- defensive: classifyError should not throw @preserve */
+                providerClassification = "unknown";
             }
-            callbacks.onError(e instanceof Error ? e : new Error(String(e)), "terminal");
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "engine.error",
-                trace_id: traceId,
-                component: "engine",
-                message: e instanceof Error ? e.message : String(e),
-                meta: {},
-            });
-            stripLastToolCalls(messages);
-            outcome = "errored";
-            done = true;
+            finishTerminalProviderError(errorForClassification, providerClassification);
         }
     }
     (0, runtime_1.emitNervesEvent)({
@@ -638,7 +1338,12 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         trace_id: traceId,
         component: "engine",
         message: "runAgent turn completed",
-        meta: { done },
+        meta: { done, sawPonder, sawQuerySession, sawBridgeManage },
     });
-    return { usage: lastUsage, outcome, completion };
+    return {
+        usage: lastUsage,
+        outcome,
+        completion,
+        ...(terminalError ? { error: terminalError, errorClassification: terminalErrorClassification } : {}),
+    };
 }