@ouro.bot/cli 0.1.0-alpha.132 → 0.1.0-alpha.134

package/changelog.json

@@ -1,6 +1,29 @@
 {
   "_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.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": [
+        "Inner return obligations: delegated inner dialog work now tracks a ReturnObligation through queued → running → returned/deferred lifecycle.",
+        "Exact-origin routing: inner dialog completions route back to the session that delegated the work, not just the freshest active session.",
+        "Active work frame surfaces pending inner return obligations so the agent knows what's outstanding."
+      ]
+    },
     {
       "version": "0.1.0-alpha.132",
       "changes": [

package/dist/heart/active-work.js

@@ -439,6 +439,7 @@ function buildActiveWorkFrame(input) {
         otherCodingSessions,
         pendingObligations,
         targetCandidates: input.targetCandidates ?? [],
+        innerReturnObligations: input.innerReturnObligations ?? [],
         bridgeSuggestion: suggestBridgeForActiveWork({
             currentSession: input.currentSession,
             currentObligation: input.currentObligation,
@@ -588,6 +589,16 @@ function formatActiveWorkFrame(frame) {
             lines.push(obligationLine);
         }
     }
+    if (frame.innerReturnObligations && frame.innerReturnObligations.length > 0) {
+        lines.push("");
+        lines.push("## inner return obligations");
+        for (const ob of frame.innerReturnObligations) {
+            const preview = ob.delegatedContent.length > 60
+                ? `${ob.delegatedContent.slice(0, 57)}...`
+                : ob.delegatedContent;
+            lines.push(`- [${ob.status}] ${ob.origin.friendId}/${ob.origin.channel}/${ob.origin.key}: ${preview}`);
+        }
+    }
     // Bridge suggestion
     if (frame.bridgeSuggestion) {
         lines.push("");

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.",
+    go_inward: "rejected: go_inward must be the only tool call. finish your other work first, then call go_inward alone.",
+};
 const DELEGATION_REASON_PROSE_HANDOFF = {
     explicit_reflection: "something in the conversation called for reflection",
     cross_session: "this touches other conversations",
@@ -183,34 +191,34 @@ function buildGoInwardHandoffPacket(params) {
     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,9 +245,9 @@ 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, sawGoInward, _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
@@ -248,11 +256,11 @@ function getFinalAnswerRetryError(mustResolveBeforeHandoff, intent, sawSteeringF
     }
     // 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;
@@ -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 go_inward (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
+        //
+        // go_inward, 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.goInwardTool] : []),
+            ...(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,44 @@ 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) {
+                    // Inner dialog attention queue gate: reject settle if items remain
+                    const attentionQueue = (augmentedToolContext ?? options?.toolContext)?.delegatedOrigins;
+                    if (isInnerDialog && attentionQueue && attentionQueue.length > 0) {
+                        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) {
+                        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, sawGoInward, 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";
@@ -615,9 +654,9 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             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,26 +676,26 @@ 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.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) {
+                // Check for observe sole call: intercept before tool execution
+                const isSoleObserve = result.toolCalls.length === 1 && result.toolCalls[0].name === "observe";
+                if (isSoleObserve) {
                     let reason;
                     try {
                         const parsed = JSON.parse(result.toolCalls[0].arguments);
@@ -666,7 +705,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     catch { /* ignore */ }
                     (0, runtime_1.emitNervesEvent)({
                         component: "engine",
-                        event: "engine.no_response",
+                        event: "engine.observe",
                         message: "agent declined to respond in group chat",
                         meta: { ...(reason ? { reason } : {}) },
                     });
@@ -674,7 +713,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     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;
                 }
@@ -686,8 +725,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         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 : "";
+                    /* 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
@@ -700,7 +739,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     }
                     // Build handoff packet and enqueue
                     const handoffContent = buildGoInwardHandoffPacket({
-                        content,
+                        topic,
                         mode,
                         delegationDecision: options?.delegationDecision,
                         currentSession: options?.toolContext?.currentSession ?? null,
@@ -736,7 +775,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                                     channel: currentSession.channel,
                                     key: currentSession.key,
                                 },
-                                content,
+                                content: topic,
                             });
                         }
                         catch {
@@ -756,36 +795,22 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         component: "engine",
                         event: "engine.go_inward",
                         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";
                     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 = {};

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/ouro-path-installer.js

@@ -46,6 +46,11 @@ if [ ! -e "$ENTRY" ]; then
 fi
 exec node "$ENTRY" "$@"
 `;
+function writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync) {
+    mkdirSync(path.dirname(scriptPath), { recursive: true });
+    writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+    chmodSync(scriptPath, 0o755);
+}
 function detectShellProfile(homeDir, shell) {
     if (!shell)
         return null;
@@ -151,9 +156,9 @@ function installOuroCommand(deps = {}) {
         meta: { scriptPath, binDir },
     });
     try {
-        mkdirSync(binDir, { recursive: true });
-        writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
-        chmodSync(scriptPath, 0o755);
+        if (!modernCurrent) {
+            writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync);
+        }
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
@@ -166,8 +171,8 @@ function installOuroCommand(deps = {}) {
         return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: error instanceof Error ? error.message : /* v8 ignore next -- defensive @preserve */ String(error), repairedOldLauncher };
     }
     // Check if ~/.ouro-cli/bin is already in PATH
-    let shellProfileUpdated = null;
     const pathReady = isBinDirInPath(binDir, envPath);
+    let shellProfileUpdated = null;
     if (!pathReady) {
         const profilePath = detectShellProfile(homeDir, shell);
         if (profilePath) {
@@ -199,7 +204,7 @@ function installOuroCommand(deps = {}) {
         component: "daemon",
         event: "daemon.ouro_path_install_end",
         message: "ouro command installed",
-        meta: { scriptPath, pathReady, shellProfileUpdated },
+        meta: { scriptPath, pathReady, shellProfileUpdated, oldScriptPath: oldExists ? oldScriptPath : null },
     });
     return { installed: true, scriptPath, pathReady, shellProfileUpdated, repairedOldLauncher };
 }

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) {

package/dist/heart/daemon/thoughts.js

@@ -93,7 +93,7 @@ function extractToolNames(messages) {
         if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
             for (const tc of msg.tool_calls) {
                 const toolFunction = extractToolFunction(tc);
-                if (toolFunction?.name && toolFunction.name !== "final_answer")
+                if (toolFunction?.name && toolFunction.name !== "settle")
                     names.push(toolFunction.name);
             }
         }
@@ -321,15 +321,15 @@ function formatInnerDialogStatus(status) {
     }
     return lines.join("\n");
 }
-/** Extract text from a final_answer tool call's arguments. */
-function extractFinalAnswer(messages) {
+/** Extract text from a settle tool call's arguments. */
+function extractSettleAnswer(messages) {
     for (let k = messages.length - 1; k >= 0; k--) {
         const msg = messages[k];
         if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls))
             continue;
         for (const tc of msg.tool_calls) {
             const toolFunction = extractToolFunction(tc);
-            if (toolFunction?.name !== "final_answer")
+            if (toolFunction?.name !== "settle")
                 continue;
             try {
                 const parsed = JSON.parse(toolFunction.arguments ?? "{}");
@@ -348,7 +348,7 @@ function extractThoughtResponseFromMessages(messages) {
     const lastAssistant = assistantMsgs.reverse().find((message) => contentToText(message.content).trim().length > 0);
     return lastAssistant
         ? contentToText(lastAssistant.content).trim()
-        : extractFinalAnswer(messages);
+        : extractSettleAnswer(messages);
 }
 function parseInnerDialogSession(sessionPath) {
     (0, runtime_1.emitNervesEvent)({
@@ -397,7 +397,7 @@ function parseInnerDialogSession(sessionPath) {
             j++;
         }
         // Find the last assistant text response in this turn.
-        // With tool_choice="required", the response may be inside a final_answer tool call.
+        // With tool_choice="required", the response may be inside a settle tool call.
         const response = extractThoughtResponseFromMessages(turnMessages);
         const tools = extractToolNames(turnMessages);
         turns.push({

package/dist/heart/delegation.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.decideDelegation = decideDelegation;
 const runtime_1 = require("../nerves/runtime");
 const CROSS_SESSION_TOOLS = new Set(["query_session", "send_message", "bridge_manage"]);
-const FAST_PATH_TOOLS = new Set(["final_answer"]);
+const FAST_PATH_TOOLS = new Set(["settle"]);
 const REFLECTION_PATTERN = /\b(think|reflect|ponder|surface|surfaces|surfaced|sit with|metaboli[sz]e)\b/i;
 const CROSS_SESSION_PATTERN = /\b(other chat|other session|across chats?|across sessions?|keep .* aligned|relay|carry .* across)\b/i;
 function hasExplicitReflection(ingressTexts) {