@ouro.bot/cli 0.1.0-alpha.140 → 0.1.0-alpha.142

package/changelog.json

@@ -1,6 +1,25 @@
 {
   "_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.142",
+      "changes": [
+        "Surface tool fulfills heart obligations on successful routing: findPendingObligationForOrigin + fulfillObligation called after inner obligation advance, wrapped in try/catch.",
+        "New fulfillHeartObligation callback on HandleSurfaceInput — origin-based lookup independent of inner obligationId.",
+        "ouro inner status command: reads runtime.json, journal dir, heartbeat cadence, attention count. Shows last turn, status, heartbeat health, journal listing, held thoughts."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.141",
+      "changes": [
+        "Ponder tool replaces descend: thought+say required from outer sessions, parameterless from inner dialog. Creates heart obligation, enqueues pending with delegatedFrom, emits say text outward.",
+        "Ponder from inner dialog enqueues synthetic pending message (no delegatedFrom) to continue thinking across turns.",
+        "Rest tool for inner dialog: parameterless, gated by attention queue. Rejected with guidance when unsurfaced thoughts remain.",
+        "Settle removed from inner dialog tool set (replaced by rest). Outer sessions still use settle.",
+        "Session migration: descend -> ponder added to migrateToolNames(). go_inward now maps to ponder.",
+        "Ponder and rest added to CIRCUIT_BREAKER_EXEMPT and SOLE_CALL_REJECTION."
+      ]
+    },
     {
       "version": "0.1.0-alpha.140",
       "changes": [

package/dist/heart/core.js

@@ -176,7 +176,8 @@ Object.defineProperty(exports, "buildSystem", { enumerable: true, get: function
 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.",
+    ponder: "rejected: ponder must be the only tool call. finish your other work first, then call ponder alone.",
+    rest: "rejected: rest must be the only tool call. finish your work first, then call rest alone.",
 };
 const DELEGATION_REASON_PROSE_HANDOFF = {
     explicit_reflection: "something in the conversation called for reflection",
@@ -186,7 +187,7 @@ 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 buildDescendHandoffPacket(params) {
+function buildPonderHandoffPacket(params) {
     const reasons = params.delegationDecision?.reasons ?? [];
     const reasonProse = reasons.length > 0
         ? reasons.map((r) => DELEGATION_REASON_PROSE_HANDOFF[r]).join("; ")
@@ -245,14 +246,14 @@ 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 getSettleRetryError(mustResolveBeforeHandoff, intent, sawSteeringFollowUp, _delegationDecision, sawSendMessageSelf, sawDescend, _sawQuerySession, currentObligation, innerJob, sawExternalStateQuery) {
+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 && !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.";
+    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) {
@@ -496,7 +497,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let mustResolveBeforeHandoffActive = options?.mustResolveBeforeHandoff === true;
     let currentReasoningEffort = "medium";
     let sawSendMessageSelf = false;
-    let sawDescend = false;
+    let sawPonder = false;
     let sawQuerySession = false;
     let sawBridgeManage = false;
     let sawExternalStateQuery = false;
@@ -522,11 +523,13 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     providerRuntime.resetTurnState(messages);
     while (!done) {
         // Channel-based tool filtering:
-        // - Inner dialog: exclude descend (already inward), send_message (delivery via surface), observe (no one to observe)
+        // - Inner dialog: exclude 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.
+        // 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
@@ -534,10 +537,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             : baseTools;
         const activeTools = [
             ...filteredBaseTools,
-            ...(!isInnerDialog ? [tools_1.descendTool] : []),
-            ...(isInnerDialog ? [surface_tool_1.surfaceToolDef] : []),
+            tools_1.ponderTool,
+            ...(isInnerDialog ? [surface_tool_1.surfaceToolDef, tools_1.restTool] : []),
             ...(currentContext?.isGroupChat && !isInnerDialog ? [tools_1.observeTool] : []),
-            tools_1.settleTool,
+            ...(!isInnerDialog ? [tools_1.settleTool] : []),
         ];
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
         if (steeringFollowUps.length > 0) {
@@ -652,7 +655,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         done = true;
                         continue;
                     }
-                    const retryError = getSettleRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp, options?.delegationDecision, sawSendMessageSelf, sawDescend, sawQuerySession, options?.currentObligation ?? null, options?.activeWorkFrame?.inner?.job, sawExternalStateQuery);
+                    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";
@@ -734,94 +737,157 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     done = true;
                     continue;
                 }
-                // Check for descend sole call: intercept before tool execution
-                const isSoleDescend = result.toolCalls.length === 1 && result.toolCalls[0].name === "descend";
-                if (isSoleDescend) {
+                // Check for ponder sole call: intercept before tool execution
+                const isSolePonder = result.toolCalls.length === 1 && result.toolCalls[0].name === "ponder";
+                if (isSolePonder) {
                     let parsedArgs = {};
                     try {
                         parsedArgs = JSON.parse(result.toolCalls[0].arguments);
                     }
                     catch { /* ignore */ }
-                    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
-                        : undefined;
-                    const mode = parsedMode || "reflect";
-                    // Emit outward answer if provided
-                    if (answer) {
-                        callbacks.onClearText?.();
-                        callbacks.onTextChunk(answer);
-                    }
-                    // Build handoff packet and enqueue
-                    const handoffContent = buildDescendHandoffPacket({
-                        topic,
-                        mode,
-                        delegationDecision: options?.delegationDecision,
-                        currentSession: options?.toolContext?.currentSession ?? null,
-                        currentObligation: options?.currentObligation ?? null,
-                        outwardClosureRequired: options?.delegationDecision?.outwardClosureRequired ?? false,
-                    });
-                    const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_2.getAgentName)());
+                    callbacks.onToolStart("ponder", parsedArgs);
                     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: {
+                    if (!isInnerChannel) {
+                        // Outer session: thought and say are required
+                        const thought = typeof parsedArgs.thought === "string" ? parsedArgs.thought : undefined;
+                        const say = typeof parsedArgs.say === "string" ? parsedArgs.say : undefined;
+                        if (!thought || !say) {
+                            callbacks.onToolEnd("ponder", (0, tools_1.summarizeArgs)("ponder", parsedArgs), false);
+                            messages.push(msg);
+                            const errorMsg = "ponder requires both thought and say when called from a conversation. thought is what needs more thinking; say is what you tell them before going quiet.";
+                            messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: errorMsg });
+                            providerRuntime.appendToolOutput(result.toolCalls[0].id, errorMsg);
+                            continue;
+                        }
+                        // Emit outward say text
+                        callbacks.onClearText?.();
+                        callbacks.onTextChunk(say);
+                        // Build handoff packet and enqueue
+                        const handoffContent = buildPonderHandoffPacket({
+                            topic: thought,
+                            mode: "reflect",
+                            delegationDecision: options?.delegationDecision,
+                            currentSession: currentSession ?? null,
+                            currentObligation: options?.currentObligation ?? null,
+                            outwardClosureRequired: options?.delegationDecision?.outwardClosureRequired ?? false,
+                        });
+                        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_2.getAgentName)());
+                        // Create obligation FIRST so we can attach its ID to the pending message
+                        let createdObligationId;
+                        if (currentSession) {
+                            try {
+                                const obligation = (0, obligations_1.createObligation)((0, identity_2.getAgentRoot)(), {
+                                    origin: {
+                                        friendId: currentSession.friendId,
+                                        channel: currentSession.channel,
+                                        key: currentSession.key,
+                                    },
+                                    content: thought,
+                                });
+                                createdObligationId = obligation.id;
+                            }
+                            catch {
+                                /* v8 ignore next -- defensive: obligation store write failure should not break ponder @preserve */
+                            }
+                        }
+                        const envelope = {
+                            from: (0, identity_2.getAgentName)(),
+                            friendId: "self",
+                            channel: "inner",
+                            key: "dialog",
+                            content: handoffContent,
+                            timestamp: Date.now(),
+                            ...(currentSession ? {
+                                delegatedFrom: {
                                     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 */
+                                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);
+                        try {
+                            await (0, socket_client_1.requestInnerWake)((0, identity_2.getAgentName)());
                         }
+                        catch { /* daemon may not be running */ }
+                        callbacks.onToolEnd("ponder", (0, tools_1.summarizeArgs)("ponder", parsedArgs), true);
+                        sawPonder = true;
+                        messages.push(msg);
+                        const ack = "(pondering)";
+                        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.pondered",
+                            message: "pondering",
+                            meta: { hasThought: true, hasSay: true, contentSnippet: thought.slice(0, 80) },
+                        });
                     }
-                    const envelope = {
-                        from: (0, identity_2.getAgentName)(),
-                        friendId: "self",
-                        channel: "inner",
-                        key: "dialog",
-                        content: handoffContent,
-                        timestamp: Date.now(),
-                        mode,
-                        ...(currentSession && !isInnerChannel ? {
-                            delegatedFrom: {
-                                friendId: currentSession.friendId,
-                                channel: currentSession.channel,
-                                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);
-                    try {
-                        await (0, socket_client_1.requestInnerWake)((0, identity_2.getAgentName)());
+                    else {
+                        // Inner dialog: parameterless, enqueue synthetic pending WITHOUT delegatedFrom
+                        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_2.getAgentName)());
+                        const envelope = {
+                            from: (0, identity_2.getAgentName)(),
+                            friendId: "self",
+                            channel: "inner",
+                            key: "dialog",
+                            content: "continuing to think...",
+                            timestamp: Date.now(),
+                        };
+                        (0, pending_1.queuePendingMessage)(pendingDir, envelope);
+                        callbacks.onToolEnd("ponder", (0, tools_1.summarizeArgs)("ponder", parsedArgs), true);
+                        sawPonder = true;
+                        messages.push(msg);
+                        const ack = "(pondering)";
+                        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.pondered",
+                            message: "pondering from inner dialog",
+                            meta: { inner: true },
+                        });
+                    }
+                    outcome = "pondered";
+                    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;
                     }
-                    catch { /* daemon may not be running */ }
-                    callbacks.onToolEnd("descend", (0, tools_1.summarizeArgs)("descend", parsedArgs), true);
-                    sawDescend = true;
+                    callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), true);
                     messages.push(msg);
-                    const ack = "(going inward)";
+                    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.descended",
-                        message: "taking thread inward",
-                        meta: { mode, hasAnswer: answer !== undefined, contentSnippet: topic.slice(0, 80) },
+                        event: "engine.rested",
+                        message: "resting until next heartbeat",
+                        meta: {},
                     });
-                    outcome = "descended";
+                    outcome = "rested";
                     done = true;
                     continue;
                 }
@@ -981,7 +1047,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         trace_id: traceId,
         component: "engine",
         message: "runAgent turn completed",
-        meta: { done, sawDescend, sawQuerySession, sawBridgeManage },
+        meta: { done, sawPonder, sawQuerySession, sawBridgeManage },
     });
     return {
         usage: lastUsage,

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

@@ -295,6 +295,7 @@ function usage() {
         "  ouro friend create --name <name> [--trust <level>] [--agent <name>]",
         "  ouro friend update <id> --trust <level> [--agent <name>]",
         "  ouro thoughts [--last <n>] [--json] [--follow] [--agent <name>]",
+        "  ouro inner [--agent <name>]",
         "  ouro friend link <agent> --friend <id> --provider <p> --external-id <eid>",
         "  ouro friend unlink <agent> --friend <id> --provider <p> --external-id <eid>",
         "  ouro whoami [--agent <name>]",
@@ -987,6 +988,10 @@ function parseOuroCommand(args) {
         return parseThoughtsCommand(args.slice(1));
     if (head === "attention")
         return parseAttentionCommand(args.slice(1));
+    if (head === "inner") {
+        const { agent } = extractAgentFlag(args.slice(1));
+        return { kind: "inner.status", ...(agent ? { agent } : {}) };
+    }
     if (head === "chat") {
         if (!second)
             throw new Error(`Usage\n${usage()}`);
@@ -2607,6 +2612,89 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         }
     }
     /* v8 ignore stop */
+    // ── inner dialog status (local, no daemon socket needed) ──
+    /* v8 ignore start -- inner status handler: requires real agent state on disk @preserve */
+    if (command.kind === "inner.status") {
+        try {
+            const agentName = command.agent ?? (0, identity_1.getAgentName)();
+            const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+            const { buildInnerStatusOutput } = await Promise.resolve().then(() => __importStar(require("./inner-status")));
+            const { sessionPath: getSessionPath } = await Promise.resolve().then(() => __importStar(require("../config")));
+            const { parseCadenceMs, DEFAULT_CADENCE_MS } = await Promise.resolve().then(() => __importStar(require("./heartbeat-timer")));
+            const { parseFrontmatter } = await Promise.resolve().then(() => __importStar(require("../../repertoire/tasks/parser")));
+            const { listActiveObligations } = await Promise.resolve().then(() => __importStar(require("../../mind/obligations")));
+            // Read runtime state
+            const innerSessionPath = getSessionPath("inner-dialog", "inner", "session");
+            const runtimeJsonPath = path.join(path.dirname(innerSessionPath), "runtime.json");
+            let runtimeState = null;
+            try {
+                const raw = fs.readFileSync(runtimeJsonPath, "utf-8");
+                runtimeState = JSON.parse(raw);
+            }
+            catch { /* missing or corrupt — will show "unknown" */ }
+            // Read journal files
+            const journalDir = path.join(agentRoot, "journal");
+            let journalFiles = [];
+            try {
+                const entries = fs.readdirSync(journalDir, { withFileTypes: true });
+                journalFiles = entries
+                    .filter((e) => e.isFile() && !e.name.startsWith("."))
+                    .map((e) => {
+                    const stat = fs.statSync(path.join(journalDir, e.name));
+                    return { name: e.name, mtimeMs: stat.mtimeMs };
+                });
+            }
+            catch { /* missing dir — will show (empty) */ }
+            // Read heartbeat cadence
+            let heartbeat = null;
+            try {
+                const habitsDir = path.join(agentRoot, "habits");
+                const habitFiles = fs.readdirSync(habitsDir);
+                const heartbeatFile = habitFiles.find((f) => f.endsWith("-heartbeat.md"));
+                let cadenceMs = DEFAULT_CADENCE_MS;
+                if (heartbeatFile) {
+                    const content = fs.readFileSync(path.join(habitsDir, heartbeatFile), "utf-8");
+                    const lines = content.split(/\r?\n/);
+                    if (lines[0]?.trim() === "---") {
+                        const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+                        if (closing !== -1) {
+                            const rawFrontmatter = lines.slice(1, closing).join("\n");
+                            const frontmatter = parseFrontmatter(rawFrontmatter);
+                            const parsed = parseCadenceMs(frontmatter.cadence);
+                            if (parsed !== null)
+                                cadenceMs = parsed;
+                        }
+                    }
+                }
+                let lastCompletedAt = null;
+                if (runtimeState?.lastCompletedAt) {
+                    const ms = new Date(runtimeState.lastCompletedAt).getTime();
+                    if (!Number.isNaN(ms))
+                        lastCompletedAt = ms;
+                }
+                heartbeat = { cadenceMs, lastCompletedAt };
+            }
+            catch { /* no habits — heartbeat unknown */ }
+            // Attention count
+            const activeObligations = listActiveObligations(agentName);
+            const message = buildInnerStatusOutput({
+                agentName,
+                runtimeState,
+                journalFiles,
+                heartbeat,
+                attentionCount: activeObligations.length,
+                now: Date.now(),
+            });
+            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/inner-status.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInnerStatusOutput = buildInnerStatusOutput;
+const runtime_1 = require("../../nerves/runtime");
+function formatRelativeTime(elapsedMs) {
+    const minutes = Math.floor(elapsedMs / (60 * 1000));
+    if (minutes < 1)
+        return "just now";
+    if (minutes === 1)
+        return "1 minute ago";
+    if (minutes < 60)
+        return `${minutes} minutes ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours === 1)
+        return "1 hour ago";
+    return `${hours} hours ago`;
+}
+function formatCadence(cadenceMs) {
+    const minutes = Math.round(cadenceMs / (60 * 1000));
+    if (minutes >= 60) {
+        const hours = Math.round(minutes / 60);
+        return `${hours}h`;
+    }
+    return `${minutes}m`;
+}
+function buildInnerStatusOutput(input) {
+    const { agentName, runtimeState, journalFiles, heartbeat, attentionCount, now } = input;
+    const lines = [];
+    lines.push(`inner dialog status: ${agentName}`);
+    // Last turn
+    if (runtimeState?.lastCompletedAt) {
+        const lastMs = new Date(runtimeState.lastCompletedAt).getTime();
+        const elapsed = now - lastMs;
+        const relativeTime = formatRelativeTime(elapsed);
+        const reasonSuffix = runtimeState.reason ? ` (${runtimeState.reason})` : "";
+        lines.push(`  last turn: ${relativeTime}${reasonSuffix}`);
+    }
+    else {
+        lines.push("  last turn: unknown");
+    }
+    // Status
+    if (runtimeState) {
+        const reasonSuffix = runtimeState.status === "running" && runtimeState.reason ? ` (${runtimeState.reason})` : "";
+        lines.push(`  status: ${runtimeState.status}${reasonSuffix}`);
+    }
+    else {
+        lines.push("  status: unknown");
+    }
+    // Heartbeat health
+    if (heartbeat && heartbeat.lastCompletedAt !== null) {
+        const elapsed = now - heartbeat.lastCompletedAt;
+        const threshold = heartbeat.cadenceMs * 1.5;
+        const health = elapsed < threshold ? "healthy" : "overdue";
+        const cadenceStr = formatCadence(heartbeat.cadenceMs);
+        const sinceStr = formatRelativeTime(elapsed);
+        lines.push(`  heartbeat: ${health} (cadence ${cadenceStr}, ${sinceStr})`);
+    }
+    else {
+        lines.push("  heartbeat: unknown");
+    }
+    // Journal
+    if (journalFiles.length === 0) {
+        lines.push("  journal: (empty)");
+    }
+    else {
+        lines.push("  journal:");
+        const sorted = [...journalFiles].sort((a, b) => b.mtimeMs - a.mtimeMs);
+        for (const file of sorted) {
+            const elapsed = now - file.mtimeMs;
+            const relativeTime = formatRelativeTime(elapsed);
+            lines.push(`    - ${file.name} (${relativeTime})`);
+        }
+    }
+    // Attention
+    const thoughtWord = attentionCount === 1 ? "thought" : "thoughts";
+    lines.push(`  attention: ${attentionCount} held ${thoughtWord}`);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.inner_status_read",
+        message: "inner dialog status read",
+        meta: {
+            agentName,
+            status: runtimeState?.status ?? "unknown",
+            journalCount: journalFiles.length,
+            attentionCount,
+        },
+    });
+    return lines.join("\n");
+}

package/dist/heart/tool-loop.js

@@ -180,8 +180,10 @@ function recordToolOutcome(state, toolName, args, result, success) {
 }
 // Tools that must never be blocked by the circuit breaker.
 // settle = end the turn, surface = deliver results outward.
-// Blocking these traps the agent: it can think all it wants but can never speak.
-const CIRCUIT_BREAKER_EXEMPT = new Set(["settle", "surface"]);
+// ponder = continue thinking (inner dialog) or hand off to inner dialog (outer).
+// rest = end inner dialog turn (added in Unit 8b).
+// Blocking these traps the agent: it can think all it wants but can never speak or stop.
+const CIRCUIT_BREAKER_EXEMPT = new Set(["settle", "surface", "ponder", "rest"]);
 function detectToolLoop(state, toolName, args) {
     if (state.history.length >= exports.GLOBAL_CIRCUIT_BREAKER_LIMIT && !CIRCUIT_BREAKER_EXEMPT.has(toolName)) {
         return emitDetection("global_circuit_breaker", toolName, state.history.length, `this turn has already made ${state.history.length} tool calls. stop thrashing, use the current evidence, and either change approach or answer truthfully with the best grounded status.`);

package/dist/mind/context.js

@@ -263,7 +263,8 @@ function stripOrphanedToolResults(messages) {
 const TOOL_NAME_MIGRATIONS = {
     final_answer: "settle",
     no_response: "observe",
-    go_inward: "descend",
+    go_inward: "ponder",
+    descend: "ponder",
     memory_save: "diary_write",
     memory_search: "recall",
 };

package/dist/mind/prompt.js

@@ -566,7 +566,7 @@ i should orient around that live lane first, then decide what still needs to com
         return `## where my attention is
 i have unfinished work that needs attention before i move on.
 
-i can take it inward with descend to think privately, or address it directly here.`;
+i can take it inward with ponder to think privately, or address it directly here.`;
     }
     if (cog === "shared-work") {
         /* v8 ignore stop */

package/dist/repertoire/tools-base.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.settleTool = exports.observeTool = exports.descendTool = exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = void 0;
+exports.restTool = exports.settleTool = exports.observeTool = exports.ponderTool = exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = void 0;
 exports.renderInnerProgressStatus = renderInnerProgressStatus;
 const fs = __importStar(require("fs"));
 const fg = __importStar(require("fast-glob"));
@@ -1362,29 +1362,23 @@ exports.baseToolDefinitions = [
     ...tools_1.codingToolDefinitions,
 ];
 exports.tools = exports.baseToolDefinitions.map((d) => d.tool);
-exports.descendTool = {
+exports.ponderTool = {
     type: "function",
     function: {
-        name: "descend",
-        description: "i need to think about this privately. this takes the current thread inward -- i'll sit with it, work through it, or carry it to where it needs to go. must be the only tool call in the turn.",
+        name: "ponder",
+        description: "i need to sit with this. from a conversation, takes the thread inward with a thought and a parting word. from inner dialog, keeps the wheel turning for another pass. must be the only tool call in the turn.",
         parameters: {
             type: "object",
             properties: {
-                topic: {
+                thought: {
                     type: "string",
-                    description: "the question or topic that needs private thought — brief framing, not your analysis. your inner dialog will do the actual thinking.",
+                    description: "the question or thread that needs more thought — brief framing, not analysis. required from a conversation, ignored from inner dialog.",
                 },
-                answer: {
+                say: {
                     type: "string",
-                    description: "if i want to say something outward before going inward -- an acknowledgment, a 'let me think about that', whatever feels right",
-                },
-                mode: {
-                    type: "string",
-                    enum: ["reflect", "plan", "relay"],
-                    description: "reflect: something to sit with. plan: something to work through. relay: something to carry across.",
+                    description: "what you say before going quiet — speak to what caught your attention, not just that something did. required from a conversation, ignored from inner dialog.",
                 },
             },
-            required: ["topic"],
         },
     },
 };
@@ -1416,3 +1410,14 @@ exports.settleTool = {
         },
     },
 };
+exports.restTool = {
+    type: "function",
+    function: {
+        name: "rest",
+        description: "put this down for now — the wheel stops until the next heartbeat. must be the only tool call in the turn.",
+        parameters: {
+            type: "object",
+            properties: {},
+        },
+    },
+};

package/dist/repertoire/tools.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.descendTool = exports.observeTool = exports.settleTool = exports.tools = void 0;
+exports.restTool = exports.ponderTool = exports.observeTool = exports.settleTool = exports.tools = void 0;
 exports.getToolsForChannel = getToolsForChannel;
 exports.isConfirmationRequired = isConfirmationRequired;
 exports.execTool = execTool;
@@ -48,6 +48,7 @@ const guardrails_1 = require("./guardrails");
 const identity_1 = require("../heart/identity");
 const surface_tool_1 = require("../senses/surface-tool");
 const obligations_1 = require("../mind/obligations");
+const obligations_2 = require("../heart/obligations");
 const session_activity_1 = require("../heart/session-activity");
 const path = __importStar(require("path"));
 function safeGetAgentRoot() {
@@ -63,7 +64,8 @@ var tools_base_2 = require("./tools-base");
 Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_base_2.tools; } });
 Object.defineProperty(exports, "settleTool", { enumerable: true, get: function () { return tools_base_2.settleTool; } });
 Object.defineProperty(exports, "observeTool", { enumerable: true, get: function () { return tools_base_2.observeTool; } });
-Object.defineProperty(exports, "descendTool", { enumerable: true, get: function () { return tools_base_2.descendTool; } });
+Object.defineProperty(exports, "ponderTool", { enumerable: true, get: function () { return tools_base_2.ponderTool; } });
+Object.defineProperty(exports, "restTool", { enumerable: true, get: function () { return tools_base_2.restTool; } });
 // Surface tool handler: routes content to friend's freshest session
 /* v8 ignore start -- surface handler wiring: core logic tested via surface-tool.test.ts; this wires identity/routing deps @preserve */
 const surfaceToolDefinition = {
@@ -206,6 +208,20 @@ const surfaceToolDefinition = {
                 }
                 /* v8 ignore stop */
             },
+            fulfillHeartObligation: (origin) => {
+                /* v8 ignore start -- heart obligation fulfillment: tested via surface-tool.test.ts @preserve */
+                try {
+                    const agentRoot = (0, identity_1.getAgentRoot)();
+                    const heartObligation = (0, obligations_2.findPendingObligationForOrigin)(agentRoot, origin);
+                    if (heartObligation) {
+                        (0, obligations_2.fulfillObligation)(agentRoot, heartObligation.id);
+                    }
+                }
+                catch {
+                    // swallowed — heart obligation fulfillment must never break surface delivery
+                }
+                /* v8 ignore stop */
+            },
         });
     },
     summaryKeys: ["content", "delegationId"],

package/dist/senses/surface-tool.js

@@ -31,7 +31,7 @@ exports.surfaceToolDef = {
     },
 };
 async function handleSurface(input) {
-    const { content, delegationId, friendId, queue, routeToFriend, advanceObligation } = input;
+    const { content, delegationId, friendId, queue, routeToFriend, advanceObligation, fulfillHeartObligation } = input;
     // Resolve target friend
     let targetFriendId;
     let queueItem;
@@ -74,6 +74,19 @@ async function handleSurface(input) {
                 returnTarget: "surface",
             });
         }
+        // Fulfill the heart obligation for this origin (separate from inner/mind obligation)
+        if (fulfillHeartObligation) {
+            try {
+                fulfillHeartObligation({
+                    friendId: queueItem.friendId,
+                    channel: queueItem.channel,
+                    key: queueItem.key,
+                });
+            }
+            catch {
+                // swallowed — heart obligation fulfillment must never break surface delivery
+            }
+        }
         (0, attention_queue_1.dequeueAttentionItem)(queue, delegationId);
     }
     // Return delivery status

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.140",
+  "version": "0.1.0-alpha.142",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",