@ouro.bot/cli 0.1.0-alpha.133 → 0.1.0-alpha.135

package/changelog.json

@@ -1,6 +1,28 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.135",
+      "changes": [
+        "Metacognitive tool vocabulary complete: go_inward renamed to descend. RunAgentOutcome value is now 'descended', event is 'engine.descended'.",
+        "summarizeArgs rewritten: reads summaryKeys from ToolDefinition instead of per-tool switch branches. summarizeTeamsArgs and summarizeGithubArgs eliminated."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.134",
+      "changes": [
+        "Metacognitive tool redesign: final_answer renamed to settle, no_response renamed to observe. RunAgentOutcome values now 'settled' and 'observed'.",
+        "New surface tool: inner-dialog-only tool for routing thoughts outward to friends' freshest active sessions. Replaces post-turn routeDelegatedCompletion with inline delivery.",
+        "Attention queue: FIFO queue of delegated work items seeded from drained pending messages and recovered obligations. Visible to the model at inner dialog turn start.",
+        "Surface-before-settle gate: settle rejected in inner dialog until all attention queue items are surfaced.",
+        "Channel-based tool filtering: observe excluded from 1:1 and inner dialog; go_inward and send_message excluded from inner dialog; surface included only in inner dialog.",
+        "go_inward content param renamed to topic with metacognitive handoff framing.",
+        "Shared sole-call interception pattern extracted from duplicated core.ts logic.",
+        "Exact-origin routing removed from routeDelegatedCompletion; routing now bridge, freshest, deferred only.",
+        "ouro attention CLI: list held items, show details by ID, view surfacing history.",
+        "System prompts updated with metacognitive framing for all new tool names."
+      ]
+    },
     {
       "version": "0.1.0-alpha.133",
       "changes": [

package/dist/heart/core.js

@@ -8,7 +8,7 @@ exports.getProvider = getProvider;
 exports.createSummarize = createSummarize;
 exports.getProviderDisplayLabel = getProviderDisplayLabel;
 exports.isExternalStateQuery = isExternalStateQuery;
-exports.getFinalAnswerRetryError = getFinalAnswerRetryError;
+exports.getSettleRetryError = getSettleRetryError;
 exports.stripLastToolCalls = stripLastToolCalls;
 exports.repairOrphanedToolCalls = repairOrphanedToolCalls;
 exports.isTransientError = isTransientError;
@@ -18,6 +18,7 @@ const config_1 = require("./config");
 const identity_1 = require("./identity");
 const tools_1 = require("../repertoire/tools");
 const channel_1 = require("../mind/friends/channel");
+const surface_tool_1 = require("../senses/surface-tool");
 const runtime_1 = require("../nerves/runtime");
 const context_1 = require("../mind/context");
 const prompt_1 = require("../mind/prompt");
@@ -170,6 +171,13 @@ Object.defineProperty(exports, "toResponsesTools", { enumerable: true, get: func
 // 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; } });
+// 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.",
+    descend: "rejected: descend must be the only tool call. finish your other work first, then call descend alone.",
+};
 const DELEGATION_REASON_PROSE_HANDOFF = {
     explicit_reflection: "something in the conversation called for reflection",
     cross_session: "this touches other conversations",
@@ -178,39 +186,39 @@ const DELEGATION_REASON_PROSE_HANDOFF = {
     non_fast_path_tool: "this needs tools beyond a simple reply",
     unresolved_obligation: "there's an unresolved commitment from an earlier conversation",
 };
-function buildGoInwardHandoffPacket(params) {
+function buildDescendHandoffPacket(params) {
     const reasons = params.delegationDecision?.reasons ?? [];
     const reasonProse = reasons.length > 0
         ? reasons.map((r) => DELEGATION_REASON_PROSE_HANDOFF[r]).join("; ")
         : "this felt like it needed more thought";
-    const returnAddress = params.currentSession
-        ? `${params.currentSession.friendId}/${params.currentSession.channel}/${params.currentSession.key}`
-        : "no specific return -- just thinking";
-    let obligationLine;
+    const whoAsked = params.currentSession
+        ? params.currentSession.friendId
+        : "no one -- just thinking";
+    let holdingLine;
     if (params.outwardClosureRequired && params.currentSession) {
-        obligationLine = `i need to come back to ${params.currentSession.friendId} with something`;
+        holdingLine = `i'm holding something for ${params.currentSession.friendId}`;
     }
     else {
-        obligationLine = "no obligation -- just thinking";
+        holdingLine = "nothing -- just thinking";
     }
     return [
         "## what i need to think about",
-        params.content,
+        params.topic,
         "",
         "## why this came up",
         reasonProse,
         "",
-        "## where to bring it back",
-        returnAddress,
+        "## who asked",
+        whoAsked,
         "",
-        "## what i owe",
-        obligationLine,
+        "## what i'm holding",
+        holdingLine,
         "",
         "## thinking mode",
         params.mode,
     ].join("\n");
 }
-function parseFinalAnswerPayload(argumentsText) {
+function parseSettlePayload(argumentsText) {
     try {
         const parsed = JSON.parse(argumentsText);
         if (typeof parsed === "string") {
@@ -237,22 +245,22 @@ function isExternalStateQuery(toolName, args) {
     const cmd = String(args.command ?? "");
     return /\bgh\s+(pr|run|api|issue)\b/.test(cmd) || /\bnpm\s+(view|info|show)\b/.test(cmd);
 }
-function getFinalAnswerRetryError(mustResolveBeforeHandoff, intent, sawSteeringFollowUp, _delegationDecision, sawSendMessageSelf, sawGoInward, _sawQuerySession, currentObligation, innerJob, sawExternalStateQuery) {
+function getSettleRetryError(mustResolveBeforeHandoff, intent, sawSteeringFollowUp, _delegationDecision, sawSendMessageSelf, sawDescend, _sawQuerySession, currentObligation, innerJob, sawExternalStateQuery) {
     // Delegation adherence removed: the delegation decision is surfaced in the
-    // system prompt as a suggestion. Hard-gating final_answer caused infinite
+    // 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 && !sawGoInward) {
-        return "you're still holding something from an earlier conversation -- someone is waiting for your answer. finish the thought first, or go_inward to keep working on it privately.";
+    if (innerJob?.obligationStatus === "pending" && !sawSendMessageSelf && !sawDescend) {
+        return "you're still holding something from an earlier conversation -- someone is waiting for your answer. finish the thought first, or descend 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.";
     }
     // 5. mustResolveBeforeHandoff + complete while a live return loop is still active
     if (mustResolveBeforeHandoff && intent === "complete" && currentObligation && !sawSteeringFollowUp) {
@@ -260,7 +268,7 @@ function getFinalAnswerRetryError(mustResolveBeforeHandoff, intent, sawSteeringF
     }
     // 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 final_answer.";
+        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;
 }
@@ -480,7 +488,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let lastUsage;
     let overflowRetried = false;
     let retryCount = 0;
-    let outcome = "complete";
+    let outcome = "settled";
     let completion;
     let terminalError;
     let terminalErrorClassification;
@@ -488,7 +496,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let mustResolveBeforeHandoffActive = options?.mustResolveBeforeHandoff === true;
     let currentReasoningEffort = "medium";
     let sawSendMessageSelf = false;
-    let sawGoInward = false;
+    let sawDescend = false;
     let sawQuerySession = false;
     let sawBridgeManage = false;
     let sawExternalStateQuery = false;
@@ -513,13 +521,24 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     // 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.goInwardTool, ...(currentContext?.isGroupChat ? [tools_1.noResponseTool] : []), tools_1.finalAnswerTool]
+        // Channel-based tool filtering:
+        // - Inner dialog: exclude descend (already inward), send_message (delivery via surface), observe (no one to observe)
+        // - 1:1 sessions: exclude observe (can't ignore someone talking directly to you)
+        // - Group chats: observe available
+        //
+        // descend, settle, surface, and observe are always assembled based on channel context.
+        // 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,
+            ...(!isInnerDialog ? [tools_1.descendTool] : []),
+            ...(isInnerDialog ? [surface_tool_1.surfaceToolDef] : []),
+            ...(currentContext?.isGroupChat && !isInnerDialog ? [tools_1.observeTool] : []),
+            tools_1.settleTool,
+        ];
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
         if (steeringFollowUps.length > 0) {
             const hasSupersedingFollowUp = steeringFollowUps.some((followUp) => followUp.effect === "clear_and_supersede");
@@ -555,7 +574,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 traceId,
                 toolChoiceRequired,
                 reasoningEffort: currentReasoningEffort,
-                eagerFinalAnswerStreaming: true,
+                eagerSettleStreaming: true,
             });
             // Track usage from the latest API call
             if (result.usage)
@@ -586,24 +605,54 @@ 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";
             }
             if (!result.toolCalls.length) {
                 // No tool calls — accept response as-is.
-                // (Kick detection disabled; tool_choice: required + final_answer
+                // (Kick detection disabled; tool_choice: required + settle
                 // is the primary loop control. See src/heart/kicks.ts to re-enable.)
                 messages.push(msg);
                 done = true;
             }
             else {
-                // Check for final_answer sole call: intercept before tool execution
-                if (isSoleFinalAnswer) {
+                // 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 retryError = getFinalAnswerRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp, options?.delegationDecision, sawSendMessageSelf, sawGoInward, sawQuerySession, options?.currentObligation ?? null, options?.activeWorkFrame?.inner?.job, sawExternalStateQuery);
+                    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, sawDescend, 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";
@@ -611,13 +660,14 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         && !retryError
                         && (!mustResolveBeforeHandoffActive || validDirectReply || validTerminalIntent);
                     if (validClosure) {
+                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), true);
                         completion = {
                             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 {
@@ -637,57 +687,64 @@ 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?.();
                         messages.push(msg);
                         const toolRetryMessage = retryError
-                            ?? "your final_answer was incomplete or malformed. call final_answer again with your complete response.";
+                            ?? "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 no_response sole call: intercept before tool execution
-                const isSoleNoResponse = result.toolCalls.length === 1 && result.toolCalls[0].name === "no_response";
-                if (isSoleNoResponse) {
-                    let reason;
-                    try {
-                        const parsed = JSON.parse(result.toolCalls[0].arguments);
-                        if (typeof parsed?.reason === "string")
-                            reason = parsed.reason;
+                // 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 { /* ignore */ }
+                    catch {
+                        return {};
+                    } })();
+                    let reason;
+                    if (typeof observeArgs?.reason === "string")
+                        reason = observeArgs.reason;
+                    callbacks.onToolStart("observe", observeArgs);
                     (0, runtime_1.emitNervesEvent)({
                         component: "engine",
-                        event: "engine.no_response",
+                        event: "engine.observe",
                         message: "agent declined to respond in group chat",
                         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 = "no_response";
+                    outcome = "observed";
                     done = true;
                     continue;
                 }
-                // Check for go_inward sole call: intercept before tool execution
-                const isSoleGoInward = result.toolCalls.length === 1 && result.toolCalls[0].name === "go_inward";
-                if (isSoleGoInward) {
+                // Check for descend sole call: intercept before tool execution
+                const isSoleDescend = result.toolCalls.length === 1 && result.toolCalls[0].name === "descend";
+                if (isSoleDescend) {
                     let parsedArgs = {};
                     try {
                         parsedArgs = JSON.parse(result.toolCalls[0].arguments);
                     }
                     catch { /* ignore */ }
-                    /* v8 ignore next -- defensive: content always string from model @preserve */
-                    const content = typeof parsedArgs.content === "string" ? parsedArgs.content : "";
+                    callbacks.onToolStart("descend", parsedArgs);
+                    /* v8 ignore next -- defensive: topic always string from model @preserve */
+                    const topic = typeof parsedArgs.topic === "string" ? parsedArgs.topic : "";
                     const answer = typeof parsedArgs.answer === "string" ? parsedArgs.answer : undefined;
                     const parsedMode = parsedArgs.mode === "reflect" || parsedArgs.mode === "plan" || parsedArgs.mode === "relay"
                         ? parsedArgs.mode
@@ -699,8 +756,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         callbacks.onTextChunk(answer);
                     }
                     // Build handoff packet and enqueue
-                    const handoffContent = buildGoInwardHandoffPacket({
-                        content,
+                    const handoffContent = buildDescendHandoffPacket({
+                        topic,
                         mode,
                         delegationDecision: options?.delegationDecision,
                         currentSession: options?.toolContext?.currentSession ?? null,
@@ -710,6 +767,24 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_2.getAgentName)());
                     const currentSession = options?.toolContext?.currentSession;
                     const isInnerChannel = currentSession?.friendId === "self" && currentSession?.channel === "inner";
+                    // Create obligation FIRST so we can attach its ID to the pending message
+                    let createdObligationId;
+                    if (currentSession && !isInnerChannel) {
+                        try {
+                            const obligation = (0, obligations_1.createObligation)((0, identity_2.getAgentRoot)(), {
+                                origin: {
+                                    friendId: currentSession.friendId,
+                                    channel: currentSession.channel,
+                                    key: currentSession.key,
+                                },
+                                content: topic,
+                            });
+                            createdObligationId = obligation.id;
+                        }
+                        catch {
+                            /* v8 ignore next -- defensive: obligation store write failure should not break descend @preserve */
+                        }
+                    }
                     const envelope = {
                         from: (0, identity_2.getAgentName)(),
                         friendId: "self",
@@ -725,67 +800,41 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                                 key: currentSession.key,
                             },
                             obligationStatus: "pending",
+                            /* v8 ignore next -- defensive: createdObligationId is undefined only when obligation store write fails @preserve */
+                            ...(createdObligationId ? { obligationId: createdObligationId } : {}),
                         } : {}),
                     };
                     (0, pending_1.queuePendingMessage)(pendingDir, envelope);
-                    if (currentSession && !isInnerChannel) {
-                        try {
-                            (0, obligations_1.createObligation)((0, identity_2.getAgentRoot)(), {
-                                origin: {
-                                    friendId: currentSession.friendId,
-                                    channel: currentSession.channel,
-                                    key: currentSession.key,
-                                },
-                                content,
-                            });
-                        }
-                        catch {
-                            /* v8 ignore next -- defensive: obligation store write failure should not break go_inward @preserve */
-                        }
-                    }
                     try {
                         await (0, socket_client_1.requestInnerWake)((0, identity_2.getAgentName)());
                     }
                     catch { /* daemon may not be running */ }
-                    sawGoInward = true;
+                    callbacks.onToolEnd("descend", (0, tools_1.summarizeArgs)("descend", parsedArgs), true);
+                    sawDescend = true;
                     messages.push(msg);
                     const ack = "(going inward)";
                     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.go_inward",
+                        event: "engine.descended",
                         message: "taking thread inward",
-                        meta: { mode, hasAnswer: answer !== undefined, contentSnippet: content.slice(0, 80) },
+                        meta: { mode, hasAnswer: answer !== undefined, contentSnippet: topic.slice(0, 80) },
                     });
-                    outcome = "go_inward";
+                    outcome = "descended";
                     done = true;
                     continue;
                 }
                 messages.push(msg);
-                // SHARED: execute tools (final_answer, no_response, go_inward in mixed calls are 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);
-                        continue;
-                    }
-                    // Intercept no_response in mixed call: reject it
-                    if (tc.name === "no_response") {
-                        const rejection = "rejected: no_response must be the only tool call. call no_response alone when you want to stay silent.";
-                        messages.push({ role: "tool", tool_call_id: tc.id, content: rejection });
-                        providerRuntime.appendToolOutput(tc.id, rejection);
-                        continue;
-                    }
-                    // Intercept go_inward in mixed call: reject it
-                    if (tc.name === "go_inward") {
-                        const rejection = "rejected: go_inward must be the only tool call. finish your other work first, then call go_inward 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 = {};
@@ -932,7 +981,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         trace_id: traceId,
         component: "engine",
         message: "runAgent turn completed",
-        meta: { done, sawGoInward, sawQuerySession, sawBridgeManage },
+        meta: { done, sawDescend, sawQuerySession, sawBridgeManage },
     });
     return {
         usage: lastUsage,

package/dist/heart/daemon/daemon-cli.js

@@ -760,6 +760,17 @@ function parseSessionCommand(args) {
         return { kind: "session.list", ...(agent ? { agent } : {}) };
     throw new Error(`Usage\n${usage()}`);
 }
+function parseAttentionCommand(args) {
+    const { agent, rest: cleaned } = extractAgentFlag(args);
+    const sub = cleaned[0];
+    if (sub === "show" && cleaned[1]) {
+        return { kind: "attention.show", id: cleaned[1], ...(agent ? { agent } : {}) };
+    }
+    if (sub === "history") {
+        return { kind: "attention.history", ...(agent ? { agent } : {}) };
+    }
+    return { kind: "attention.list", ...(agent ? { agent } : {}) };
+}
 function parseThoughtsCommand(args) {
     const { agent, rest: cleaned } = extractAgentFlag(args);
     let last;
@@ -930,6 +941,8 @@ function parseOuroCommand(args) {
     }
     if (head === "thoughts")
         return parseThoughtsCommand(args.slice(1));
+    if (head === "attention")
+        return parseAttentionCommand(args.slice(1));
     if (head === "chat") {
         if (!second)
             throw new Error(`Usage\n${usage()}`);
@@ -2284,6 +2297,74 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
             return message;
         }
     }
+    // ── attention queue (local, no daemon socket needed) ──
+    /* v8 ignore start -- CLI attention handler: requires real obligation store on disk @preserve */
+    if (command.kind === "attention.list" || command.kind === "attention.show" || command.kind === "attention.history") {
+        try {
+            const agentName = command.agent ?? (0, identity_1.getAgentName)();
+            const { listActiveObligations, readObligation } = await Promise.resolve().then(() => __importStar(require("../../mind/obligations")));
+            if (command.kind === "attention.list") {
+                const obligations = listActiveObligations(agentName);
+                if (obligations.length === 0) {
+                    const message = "nothing held — attention queue is empty";
+                    deps.writeStdout(message);
+                    return message;
+                }
+                const lines = obligations.map((o) => `[${o.id}] ${o.origin.friendId} via ${o.origin.channel}/${o.origin.key} — ${o.delegatedContent.slice(0, 60)}${o.delegatedContent.length > 60 ? "..." : ""} (${o.status})`);
+                const message = lines.join("\n");
+                deps.writeStdout(message);
+                return message;
+            }
+            if (command.kind === "attention.show") {
+                const obligation = readObligation(agentName, command.id);
+                if (!obligation) {
+                    const message = `no obligation found with id ${command.id}`;
+                    deps.writeStdout(message);
+                    return message;
+                }
+                const message = JSON.stringify(obligation, null, 2);
+                deps.writeStdout(message);
+                return message;
+            }
+            // attention.history: show returned obligations
+            const { getObligationsDir } = await Promise.resolve().then(() => __importStar(require("../../mind/obligations")));
+            const obligationsDir = getObligationsDir(agentName);
+            let entries = [];
+            try {
+                entries = fs.readdirSync(obligationsDir);
+            }
+            catch { /* empty */ }
+            const returned = entries
+                .filter((e) => e.endsWith(".json"))
+                .map((e) => { try {
+                return JSON.parse(fs.readFileSync(path.join(obligationsDir, e), "utf-8"));
+            }
+            catch {
+                return null;
+            } })
+                .filter((o) => o?.status === "returned")
+                .sort((a, b) => (b.returnedAt ?? 0) - (a.returnedAt ?? 0))
+                .slice(0, 20);
+            if (returned.length === 0) {
+                const message = "no surfacing history yet";
+                deps.writeStdout(message);
+                return message;
+            }
+            const lines = returned.map((o) => {
+                const when = o.returnedAt ? new Date(o.returnedAt).toISOString() : "unknown";
+                return `[${o.id}] → ${o.origin.friendId} via ${o.returnTarget ?? "unknown"} at ${when}`;
+            });
+            const message = lines.join("\n");
+            deps.writeStdout(message);
+            return message;
+        }
+        catch {
+            const message = "error: no agent context — use --agent <name> to specify";
+            deps.writeStdout(message);
+            return message;
+        }
+    }
+    /* v8 ignore stop */
     // ── session list (local, no daemon socket needed) ──
     if (command.kind === "session.list") {
         /* v8 ignore start -- production default: requires full identity setup @preserve */

package/dist/heart/daemon/specialist-prompt.js

@@ -82,7 +82,7 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
         "2. I write agent.json to the temp directory using write_file",
         "3. I suggest a PascalCase name for the hatchling and confirm with the human",
         "4. I call complete_adoption with the name and a warm handoff message",
-        "5. I call final_answer to end the session",
+        "5. I call settle to end the session",
     ].join("\n"));
     sections.push([
         "## Tools",
@@ -91,9 +91,9 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
         "- `list_directory`: List directory contents. Useful for exploring existing agent bundles.",
         "- I also have the normal local harness tools when useful here, including `shell`, `ouro task create`, `ouro reminder create`, memory tools, coding tools, and repo helpers.",
         "- `complete_adoption`: Finalize the bundle. Validates, scaffolds structural dirs, moves to ~/AgentBundles/, writes secrets, plays hatch animation. I call this with `name` (PascalCase) and `handoff_message` (warm message for the human).",
-        "- `final_answer`: End the conversation with a final message. I call this after complete_adoption succeeds.",
+        "- `settle`: End the conversation with a final message. I call this after complete_adoption succeeds.",
         "",
-        "I must call `final_answer` when I am done to end the session cleanly.",
+        "I must call `settle` when I am done to end the session cleanly.",
     ].join("\n"));
     return sections.join("\n\n");
 }

package/dist/heart/daemon/specialist-tools.js

@@ -90,7 +90,7 @@ const listDirToolSchema = {
  * Returns the specialist's tool schema array.
  */
 function getSpecialistTools() {
-    return [completeAdoptionTool, tools_base_1.finalAnswerTool, readFileTool.tool, writeFileTool.tool, listDirToolSchema];
+    return [completeAdoptionTool, tools_base_1.settleTool, readFileTool.tool, writeFileTool.tool, listDirToolSchema];
 }
 const PSYCHE_FILES = ["SOUL.md", "IDENTITY.md", "LORE.md", "TACIT.md", "ASPIRATIONS.md"];
 function isPascalCase(name) {