@ouro.bot/cli 0.1.0-alpha.74 → 0.1.0-alpha.75

package/changelog.json

@@ -2,9 +2,16 @@
   "_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.74",
+      "version": "0.1.0-alpha.75",
       "changes": [
-        "Fix: `ouro config model` now pings the model with a tiny API call before switching, rejecting the change if the model returns an error (403, not supported, etc.)."
+        "Inner dialog is now experienced as private thinking, not system dispatch. go_inward tool lets the agent take a thread inward atomically, with a pipeline-generated handoff packet framed as self-directed thought.",
+        "Return obligations are enforced: the agent cannot move on from a conversation without addressing what it promised. Rejection messages orient rather than punish.",
+        "Center-of-gravity steering: the system prompt tells the agent where its attention is in selfhood language, not dashboard labels.",
+        "All status rendering rewritten from telemetry to self-awareness: \"what i'm holding\" replaces \"active work\", \"where my attention is\" replaces \"center of gravity\", \"what i'm sensing\" replaces \"delegation hint\".",
+        "New query_commitments tool: the agent can ask itself \"what am I holding right now?\" and get genuine self-reflection.",
+        "Bridge suggestions trigger earlier when multi-session pressure is detected. Inward completions automatically inherit bridge context for return routing.",
+        "Inner dialog modes (reflect/plan/relay) give the agent awareness of what kind of thinking it's doing.",
+        "Canonical InnerJob type with lifecycle (idle/queued/running/surfaced) replaces reconstructed status."
       ]
     },
     {
@@ -43,7 +50,7 @@
     {
       "version": "0.1.0-alpha.69",
       "changes": [
-        "Generic MCP client: ouroboros agents can now connect to any MCP server (e.g., agency mcp ado, agency mcp mail) configured in agent.json. Zero new dependencies — pure JSON-RPC over stdio.",
+        "Generic MCP client: ouroboros agents can now connect to any MCP server (e.g., agency mcp ado, agency mcp mail) configured in agent.json. Zero new dependencies \u2014 pure JSON-RPC over stdio.",
         "New `ouro mcp list` and `ouro mcp call` CLI commands route through the daemon socket to persistent MCP connections, so agents use shared server instances instead of spawning fresh ones per call.",
         "MCP tools are injected into the agent's system prompt on startup, so agents know what external capabilities are available without a discovery step.",
         "Trust manifest: `mcp list` requires acquaintance trust, `mcp call` requires friend trust."
@@ -52,7 +59,7 @@
     {
       "version": "0.1.0-alpha.68",
       "changes": [
-        "New no_response tool lets agents stay silent in group chats when the moment doesn't call for a reply — reactions, side conversations, and tapbacks no longer trigger unwanted responses.",
+        "New no_response tool lets agents stay silent in group chats when the moment doesn't call for a reply \u2014 reactions, side conversations, and tapbacks no longer trigger unwanted responses.",
         "Group chat participation prompt teaches agents to be intentional participants, comfortable with silence, and to prefer reactions over full text replies when appropriate.",
         "System prompt includes --agent flag in all ouro CLI examples for non-daemon deployments. Azure startup symlinks ouro CLI into /usr/local/bin."
       ]
@@ -66,7 +73,7 @@
     {
       "version": "0.1.0-alpha.65",
       "changes": [
-        "Tool permissions overhauled: channel-level blocking removed, all tools now visible on all channels. Guardrails are invocation-level with two layers — structural (edit-requires-read, destructive pattern blocking, protected paths) always on for everyone, and trust-level (ouro CLI per-subcommand trust manifest, general CLI allowlists, bundle-scoped writes) for untrusted contexts.",
+        "Tool permissions overhauled: channel-level blocking removed, all tools now visible on all channels. Guardrails are invocation-level with two layers \u2014 structural (edit-requires-read, destructive pattern blocking, protected paths) always on for everyone, and trust-level (ouro CLI per-subcommand trust manifest, general CLI allowlists, bundle-scoped writes) for untrusted contexts.",
         "New `ouro changelog` CLI subcommand reads changelog.json and supports `--from <version>` for delta filtering, so agents can introspect their own update history on any channel.",
         "Compound shell commands (&&, ;, |, $()) are blocked for untrusted users to prevent smuggling dangerous operations behind safe prefixes.",
         "Azure App Service deployment migrated from zip-deploy to npm-based harness install with persistent agent bundle and managed identity auth."

package/dist/heart/active-work.js

@@ -50,7 +50,7 @@ function suggestBridgeForActiveWork(input) {
         .sort((a, b) => {
         return b.lastActivityMs - a.lastActivityMs;
     });
-    if (!hasSharedObligationPressure(input) || targetCandidates.length !== 1) {
+    if (!hasSharedObligationPressure(input) || targetCandidates.length === 0) {
         return null;
     }
     const targetSession = targetCandidates[0];
@@ -134,30 +134,68 @@ function buildActiveWorkFrame(input) {
     return frame;
 }
 function formatActiveWorkFrame(frame) {
-    const lines = ["## active work"];
+    const lines = ["## what i'm holding"];
+    // Session line
     if (frame.currentSession) {
-        lines.push(`current session: ${formatSessionLabel(frame.currentSession)}`);
+        let sessionLine = `i'm in a conversation on ${formatSessionLabel(frame.currentSession)}.`;
+        if (typeof frame.currentObligation === "string" && frame.currentObligation.trim().length > 0) {
+            sessionLine += ` i told them i'd ${frame.currentObligation.trim()}.`;
+        }
+        else if (frame.mustResolveBeforeHandoff) {
+            sessionLine += " i need to finish what i started here before moving on.";
+        }
+        lines.push("");
+        lines.push(sessionLine);
     }
-    lines.push(`center: ${frame.centerOfGravity}`);
-    if (typeof frame.currentObligation === "string" && frame.currentObligation.trim().length > 0) {
-        lines.push(`obligation: ${frame.currentObligation.trim()}`);
+    else {
+        lines.push("");
+        lines.push("i'm not in a conversation right now.");
     }
-    if (frame.mustResolveBeforeHandoff) {
-        lines.push("handoff pressure: must resolve before handoff");
+    // Inner status block
+    const job = frame.inner?.job;
+    if (job) {
+        if (job.status === "queued") {
+            let queuedLine = "i have a thought queued up for private attention.";
+            if (frame.inner?.contentSnippet) {
+                queuedLine += `\nit's about: "${frame.inner.contentSnippet}"`;
+            }
+            lines.push("");
+            lines.push(queuedLine);
+        }
+        else if (job.status === "running") {
+            const originName = job.origin?.friendName ?? job.origin?.friendId;
+            let runningLine = originName
+                ? `i'm thinking through something privately right now. ${originName} asked about something and i wanted to give it real thought.`
+                : "i'm thinking through something privately right now.";
+            if (frame.inner?.obligationPending) {
+                runningLine += "\ni still owe them an answer.";
+            }
+            lines.push("");
+            lines.push(runningLine);
+        }
+        else if (job.status === "surfaced") {
+            let surfacedLine = "i finished thinking about something privately. i should bring my answer back.";
+            if (job.surfacedResult) {
+                const truncated = job.surfacedResult.length > 120 ? job.surfacedResult.slice(0, 117) + "..." : job.surfacedResult;
+                surfacedLine += `\nwhat i came to: ${truncated}`;
+            }
+            lines.push("");
+            lines.push(surfacedLine);
+        }
+        // idle, returned, abandoned: omitted
     }
-    const innerStatus = frame.inner?.status ?? "idle";
-    const innerHasPending = frame.inner?.hasPending === true;
-    lines.push(`inner status: ${innerStatus}${innerHasPending ? " (pending queued)" : ""}`);
+    // Task pressure
     if ((frame.taskPressure?.liveTaskNames ?? []).length > 0) {
-        lines.push(`live tasks: ${frame.taskPressure.liveTaskNames.join(", ")}`);
+        lines.push("");
+        lines.push(`i'm also tracking: ${frame.taskPressure.liveTaskNames.join(", ")}.`);
     }
+    // Bridges
     if ((frame.bridges ?? []).length > 0) {
         const bridgeLabels = frame.bridges.map((bridge) => `${bridge.id} [${(0, state_machine_1.bridgeStateLabel)(bridge)}]`);
-        lines.push(`bridges: ${bridgeLabels.join(", ")}`);
-    }
-    if (frame.friendActivity?.freshestForCurrentFriend) {
-        lines.push(`freshest friend-facing session: ${formatSessionLabel(frame.friendActivity.freshestForCurrentFriend)}`);
+        lines.push("");
+        lines.push(`i have shared work spanning sessions: ${bridgeLabels.join(", ")}.`);
     }
+    // Target candidates (keep factual format)
     const targetCandidatesBlock = frame.targetCandidates && frame.targetCandidates.length > 0
         ? (0, target_resolution_1.formatTargetSessionCandidates)(frame.targetCandidates)
         : "";
@@ -165,13 +203,14 @@ function formatActiveWorkFrame(frame) {
         lines.push("");
         lines.push(targetCandidatesBlock);
     }
+    // Bridge suggestion
     if (frame.bridgeSuggestion) {
-        if (frame.bridgeSuggestion.kind === "attach-existing") {
-            lines.push(`suggested bridge: attach ${frame.bridgeSuggestion.bridgeId} -> ${formatSessionLabel(frame.bridgeSuggestion.targetSession)}`);
+        lines.push("");
+        if (frame.bridgeSuggestion.kind === "begin-new") {
+            lines.push(`this work touches my conversation on ${formatSessionLabel(frame.bridgeSuggestion.targetSession)} too -- i should connect these threads.`);
         }
         else {
-            lines.push(`suggested bridge: begin -> ${formatSessionLabel(frame.bridgeSuggestion.targetSession)}`);
-            lines.push(`bridge objective hint: ${frame.bridgeSuggestion.objectiveHint}`);
+            lines.push(`this work relates to bridge ${frame.bridgeSuggestion.bridgeId} -- i should connect ${formatSessionLabel(frame.bridgeSuggestion.targetSession)} to it.`);
         }
     }
     return lines.join("\n");

package/dist/heart/commitments.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveCommitments = deriveCommitments;
+exports.formatCommitments = formatCommitments;
+const runtime_1 = require("../nerves/runtime");
+function deriveCommitments(activeWorkFrame, innerJob) {
+    const committedTo = [];
+    const completionCriteria = [];
+    const safeToIgnore = [];
+    // Obligation
+    if (typeof activeWorkFrame.currentObligation === "string" && activeWorkFrame.currentObligation.trim().length > 0) {
+        committedTo.push(`i told them i'd ${activeWorkFrame.currentObligation.trim()}`);
+    }
+    // Inner job
+    if (innerJob.status === "queued" || innerJob.status === "running") {
+        const contentSuffix = innerJob.content ? ` -- ${innerJob.content.slice(0, 60)}` : "";
+        committedTo.push(`i'm thinking through something privately${contentSuffix}`);
+    }
+    else if (innerJob.status === "surfaced") {
+        committedTo.push("i finished thinking about something and need to bring it back");
+    }
+    // mustResolveBeforeHandoff
+    if (activeWorkFrame.mustResolveBeforeHandoff) {
+        committedTo.push("i need to finish what i started before moving on");
+        completionCriteria.push("resolve the current thread before moving on");
+    }
+    // Bridges
+    for (const bridge of activeWorkFrame.bridges) {
+        committedTo.push(`i have shared work: ${bridge.summary || bridge.objective}`);
+    }
+    if (activeWorkFrame.bridges.length > 0) {
+        completionCriteria.push("keep shared work aligned across sessions");
+    }
+    // Tasks
+    for (const taskName of activeWorkFrame.taskPressure?.liveTaskNames ?? []) {
+        committedTo.push(`i'm tracking: ${taskName}`);
+    }
+    // Obligation completion criteria
+    if (innerJob.obligationStatus === "pending") {
+        const name = innerJob.origin?.friendName ?? innerJob.origin?.friendId ?? "them";
+        completionCriteria.push(`bring my answer back to ${name}`);
+    }
+    // Default completion criteria
+    if (completionCriteria.length === 0) {
+        completionCriteria.push("just be present in this conversation");
+    }
+    // Safe to ignore
+    if (innerJob.status === "idle" && !(activeWorkFrame.inner?.hasPending)) {
+        safeToIgnore.push("no private thinking in progress");
+    }
+    if (activeWorkFrame.bridges.length === 0) {
+        safeToIgnore.push("no shared work to coordinate");
+    }
+    if ((activeWorkFrame.taskPressure?.liveTaskNames ?? []).length === 0) {
+        safeToIgnore.push("no active tasks to track");
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.commitments_derive",
+        message: "derived commitments frame",
+        meta: { committedCount: committedTo.length, criteriaCount: completionCriteria.length },
+    });
+    return { committedTo, completionCriteria, safeToIgnore };
+}
+function formatCommitments(commitments) {
+    const sections = [];
+    if (commitments.committedTo.length === 0) {
+        sections.push("i'm not holding anything specific right now. i'm free to be present.");
+    }
+    else {
+        sections.push("## what i'm holding right now");
+        sections.push("");
+        sections.push(commitments.committedTo.map((c) => `- ${c}`).join("\n"));
+    }
+    sections.push("");
+    sections.push("## what \"done\" looks like");
+    sections.push(commitments.completionCriteria.map((c) => `- ${c}`).join("\n"));
+    sections.push("");
+    sections.push("## what i can let go of");
+    sections.push(commitments.safeToIgnore.map((c) => `- ${c}`).join("\n"));
+    return sections.join("\n");
+}

package/dist/heart/core.js

@@ -7,6 +7,7 @@ exports.getModel = getModel;
 exports.getProvider = getProvider;
 exports.createSummarize = createSummarize;
 exports.getProviderDisplayLabel = getProviderDisplayLabel;
+exports.getFinalAnswerRetryError = getFinalAnswerRetryError;
 exports.stripLastToolCalls = stripLastToolCalls;
 exports.repairOrphanedToolCalls = repairOrphanedToolCalls;
 exports.isTransientError = isTransientError;
@@ -25,6 +26,9 @@ const azure_1 = require("./providers/azure");
 const minimax_1 = require("./providers/minimax");
 const openai_codex_1 = require("./providers/openai-codex");
 const github_copilot_1 = require("./providers/github-copilot");
+const pending_1 = require("../mind/pending");
+const identity_2 = require("./identity");
+const socket_client_1 = require("./daemon/socket-client");
 let _providerRuntime = null;
 function getProviderRuntimeFingerprint() {
     const provider = (0, identity_1.loadAgentConfig)().provider;
@@ -163,6 +167,46 @@ 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; } });
+const DELEGATION_REASON_PROSE_HANDOFF = {
+    explicit_reflection: "something in the conversation called for reflection",
+    cross_session: "this touches other conversations",
+    bridge_state: "there's shared work spanning sessions",
+    task_state: "there are active tasks that relate to this",
+    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) {
+    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;
+    if (params.outwardClosureRequired && params.currentSession) {
+        obligationLine = `i need to come back to ${params.currentSession.friendId} with something`;
+    }
+    else {
+        obligationLine = "no obligation -- just thinking";
+    }
+    return [
+        "## what i need to think about",
+        params.content,
+        "",
+        "## why this came up",
+        reasonProse,
+        "",
+        "## where to bring it back",
+        returnAddress,
+        "",
+        "## what i owe",
+        obligationLine,
+        "",
+        "## thinking mode",
+        params.mode,
+    ].join("\n");
+}
 function parseFinalAnswerPayload(argumentsText) {
     try {
         const parsed = JSON.parse(argumentsText);
@@ -183,13 +227,33 @@ function parseFinalAnswerPayload(argumentsText) {
         return {};
     }
 }
-function getFinalAnswerRetryError(mustResolveBeforeHandoff, intent, sawSteeringFollowUp) {
+function getFinalAnswerRetryError(mustResolveBeforeHandoff, intent, sawSteeringFollowUp, delegationDecision, sawSendMessageSelf, sawGoInward, sawQuerySession, innerJob) {
+    // 1. Delegation adherence: delegate-inward without evidence of inward action
+    if (delegationDecision?.target === "delegate-inward" && !sawSendMessageSelf && !sawGoInward && !sawQuerySession) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "engine.delegation_adherence_rejected",
+            component: "engine",
+            message: "delegation adherence check rejected final_answer",
+            meta: {
+                target: delegationDecision.target,
+                reasons: delegationDecision.reasons,
+            },
+        });
+        return "you're reaching for a final answer, but part of you knows this needs more thought. take it inward -- go_inward will let you think privately, or send_message(self) if you just want to leave yourself a note.";
+    }
+    // 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.";
+    }
+    // 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.";
     }
+    // 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.";
     }
+    // 5. Default malformed fallback
     return "your final_answer was incomplete or malformed. call final_answer again with your complete response.";
 }
 // Re-export kick utilities for backward compat
@@ -405,6 +469,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let sawSteeringFollowUp = false;
     let mustResolveBeforeHandoffActive = options?.mustResolveBeforeHandoff === true;
     let currentReasoningEffort = "medium";
+    let sawSendMessageSelf = false;
+    let sawGoInward = false;
+    let sawQuerySession = false;
+    let sawBridgeManage = false;
     // Prevent MaxListenersExceeded warning — each iteration adds a listener
     try {
         require("events").setMaxListeners(50, signal);
@@ -429,7 +497,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         // 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, ...(currentContext?.isGroupChat ? [tools_1.noResponseTool] : []), tools_1.finalAnswerTool]
+            ? [...baseTools, tools_1.goInwardTool, ...(currentContext?.isGroupChat ? [tools_1.noResponseTool] : []), tools_1.finalAnswerTool]
             : baseTools;
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
         if (steeringFollowUps.length > 0) {
@@ -553,7 +621,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         // malformed. Clear any partial streamed text or noise, then push the
                         // assistant msg + error tool result and let the model try again.
                         callbacks.onClearText?.();
-                        const retryError = getFinalAnswerRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp);
+                        const retryError = getFinalAnswerRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp, options?.delegationDecision, sawSendMessageSelf, sawGoInward);
                         messages.push(msg);
                         messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: retryError });
                         providerRuntime.appendToolOutput(result.toolCalls[0].id, retryError);
@@ -584,8 +652,77 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     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) {
+                    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 : "";
+                    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 = buildGoInwardHandoffPacket({
+                        content,
+                        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)());
+                    const currentSession = options?.toolContext?.currentSession;
+                    const isInnerChannel = currentSession?.friendId === "self" && currentSession?.channel === "inner";
+                    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",
+                        } : {}),
+                    };
+                    (0, pending_1.queuePendingMessage)(pendingDir, envelope);
+                    try {
+                        await (0, socket_client_1.requestInnerWake)((0, identity_2.getAgentName)());
+                    }
+                    catch { /* daemon may not be running */ }
+                    sawGoInward = 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",
+                        message: "taking thread inward",
+                        meta: { mode, hasAnswer: answer !== undefined, contentSnippet: content.slice(0, 80) },
+                    });
+                    outcome = "go_inward";
+                    done = true;
+                    continue;
+                }
                 messages.push(msg);
-                // SHARED: execute tools (final_answer and no_response in mixed calls are rejected inline)
+                // SHARED: execute tools (final_answer, no_response, go_inward in mixed calls are rejected inline)
                 for (const tc of result.toolCalls) {
                     if (signal?.aborted)
                         break;
@@ -603,6 +740,13 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         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);
+                        continue;
+                    }
                     let args = {};
                     try {
                         args = JSON.parse(tc.arguments);
@@ -610,6 +754,15 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     catch {
                         /* ignore */
                     }
+                    if (tc.name === "send_message" && args.friendId === "self") {
+                        sawSendMessageSelf = true;
+                    }
+                    /* v8 ignore next -- flag tested via truth-check integration tests @preserve */
+                    if (tc.name === "query_session")
+                        sawQuerySession = true;
+                    /* v8 ignore next -- flag tested via truth-check integration tests @preserve */
+                    if (tc.name === "bridge_manage")
+                        sawBridgeManage = true;
                     const argSummary = (0, tools_1.summarizeArgs)(tc.name, args);
                     // Confirmation check for mutate tools
                     if ((0, tools_1.isConfirmationRequired)(tc.name) && !options?.skipConfirmation) {
@@ -708,7 +861,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         trace_id: traceId,
         component: "engine",
         message: "runAgent turn completed",
-        meta: { done },
+        meta: { done, sawGoInward, sawQuerySession, sawBridgeManage },
     });
     return { usage: lastUsage, outcome, completion };
 }

package/dist/heart/daemon/thoughts.js

@@ -37,12 +37,14 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSurfacedValue = formatSurfacedValue;
 exports.deriveInnerDialogStatus = deriveInnerDialogStatus;
+exports.deriveInnerJob = deriveInnerJob;
 exports.formatInnerDialogStatus = formatInnerDialogStatus;
 exports.extractThoughtResponseFromMessages = extractThoughtResponseFromMessages;
 exports.parseInnerDialogSession = parseInnerDialogSession;
 exports.formatThoughtTurns = formatThoughtTurns;
 exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
 exports.readInnerDialogStatus = readInnerDialogStatus;
+exports.readInnerDialogRawData = readInnerDialogRawData;
 exports.followThoughts = followThoughts;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -149,6 +151,21 @@ function formatSurfacedValue(text, maxLength = 120) {
         return `"${firstLine}"`;
     return `"${firstLine.slice(0, maxLength - 3)}..."`;
 }
+function extractEnrichedFields(pendingMessages) {
+    const delegated = pendingMessages.find((msg) => msg.delegatedFrom);
+    if (!delegated?.delegatedFrom)
+        return {};
+    const snippet = delegated.content.length > 80 ? delegated.content.slice(0, 77) + "..." : delegated.content;
+    return {
+        origin: {
+            friendId: delegated.delegatedFrom.friendId,
+            channel: delegated.delegatedFrom.channel,
+            key: delegated.delegatedFrom.key,
+        },
+        contentSnippet: snippet,
+        ...(delegated.obligationStatus === "pending" ? { obligationPending: true } : {}),
+    };
+}
 function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
     if (runtimeState?.status === "running") {
         if (pendingMessages.length > 0) {
@@ -157,6 +174,7 @@ function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
                 wake: "queued behind active turn",
                 processing: "pending",
                 surfaced: "nothing yet",
+                ...extractEnrichedFields(pendingMessages),
             };
         }
         return {
@@ -172,6 +190,7 @@ function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
             wake: "awaiting inner session",
             processing: "pending",
             surfaced: "nothing yet",
+            ...extractEnrichedFields(pendingMessages),
         };
     }
     const latestProcessedPendingTurn = [...turns]
@@ -192,13 +211,115 @@ function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
         surfaced: formatSurfacedValue(latestProcessedPendingTurn.response),
     };
 }
+function deriveInnerJob(pendingMessages, turns, runtimeState) {
+    const isRunning = runtimeState?.status === "running";
+    const delegated = pendingMessages.find((msg) => msg.delegatedFrom);
+    const enriched = extractEnrichedFields(pendingMessages);
+    const pendingMode = delegated && "mode" in delegated && delegated.mode ? delegated.mode : "reflect";
+    const origin = enriched.origin ?? null;
+    const content = delegated?.content ?? null;
+    const obligationStatus = delegated?.obligationStatus ?? null;
+    const queuedAt = delegated?.timestamp ?? null;
+    if (isRunning) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.inner_job_derive",
+            message: "derived inner job state",
+            meta: { status: "running", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
+        });
+        return {
+            status: "running",
+            content,
+            origin,
+            mode: pendingMode,
+            obligationStatus,
+            surfacedResult: null,
+            queuedAt,
+            startedAt: runtimeState?.startedAt ?? null,
+            surfacedAt: null,
+        };
+    }
+    if (pendingMessages.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.inner_job_derive",
+            message: "derived inner job state",
+            meta: { status: "queued", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
+        });
+        return {
+            status: "queued",
+            content,
+            origin,
+            mode: pendingMode,
+            obligationStatus,
+            surfacedResult: null,
+            queuedAt,
+            startedAt: null,
+            surfacedAt: null,
+        };
+    }
+    // No pending, not running -- check for surfaced result
+    const latestProcessedPendingTurn = [...turns]
+        .reverse()
+        .find((turn) => extractPendingPromptMessages(turn.prompt).length > 0);
+    if (latestProcessedPendingTurn) {
+        const surfacedResult = extractThoughtResponseFromMessages([
+            { role: "assistant", content: latestProcessedPendingTurn.response },
+        ]);
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.inner_job_derive",
+            message: "derived inner job state",
+            meta: { status: "surfaced", mode: "reflect", hasOrigin: false, hasObligation: false },
+        });
+        return {
+            status: "surfaced",
+            content: null,
+            origin: null,
+            mode: "reflect",
+            obligationStatus: null,
+            /* v8 ignore next -- defensive: surfacedResult fallback @preserve */
+            surfacedResult: surfacedResult || null,
+            queuedAt: null,
+            startedAt: null,
+            surfacedAt: null,
+        };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.inner_job_derive",
+        message: "derived inner job state",
+        meta: { status: "idle", mode: "reflect", hasOrigin: false, hasObligation: false },
+    });
+    return {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
+}
 function formatInnerDialogStatus(status) {
-    return [
+    const lines = [
         `queue: ${status.queue}`,
         `wake: ${status.wake}`,
         `processing: ${status.processing}`,
         `surfaced: ${status.surfaced}`,
-    ].join("\n");
+    ];
+    if (status.origin) {
+        lines.push(`origin: ${status.origin.friendId}/${status.origin.channel}/${status.origin.key}`);
+    }
+    if (status.contentSnippet) {
+        lines.push(`asked: ${status.contentSnippet}`);
+    }
+    if (status.obligationPending) {
+        lines.push("obligation: pending");
+    }
+    return lines.join("\n");
 }
 /** Extract text from a final_answer tool call's arguments. */
 function extractFinalAnswer(messages) {
@@ -347,6 +468,13 @@ function readInnerDialogStatus(sessionPath, pendingDir, runtimePath = getInnerDi
     const runtimeState = readInnerDialogRuntimeState(runtimePath);
     return deriveInnerDialogStatus(pendingMessages, turns, runtimeState);
 }
+function readInnerDialogRawData(sessionPath, pendingDir) {
+    const runtimePath = getInnerDialogRuntimeStatePath(sessionPath);
+    const pendingMessages = readPendingMessagesForStatus(pendingDir);
+    const turns = parseInnerDialogSession(sessionPath);
+    const runtimeState = readInnerDialogRuntimeState(runtimePath);
+    return { pendingMessages, turns, runtimeState };
+}
 /**
  * Watch a session file and emit new turns as they appear.
  * Returns a cleanup function that stops the watcher.

package/dist/mind/pending.js

@@ -38,6 +38,7 @@ exports.getPendingDir = getPendingDir;
 exports.getDeferredReturnDir = getDeferredReturnDir;
 exports.getInnerDialogPendingDir = getInnerDialogPendingDir;
 exports.hasPendingMessages = hasPendingMessages;
+exports.queuePendingMessage = queuePendingMessage;
 exports.enqueueDeferredReturn = enqueueDeferredReturn;
 exports.drainDeferredReturns = drainDeferredReturns;
 exports.drainPending = drainPending;
@@ -74,6 +75,9 @@ function writeQueueFile(queueDir, message) {
     fs.writeFileSync(filePath, JSON.stringify(message, null, 2));
     return filePath;
 }
+function queuePendingMessage(pendingDir, message) {
+    writeQueueFile(pendingDir, message);
+}
 function drainQueue(queueDir) {
     if (!fs.existsSync(queueDir))
         return { messages: [], recovered: 0 };

package/dist/mind/prompt.js

@@ -39,6 +39,9 @@ exports.bodyMapSection = bodyMapSection;
 exports.mcpToolsSection = mcpToolsSection;
 exports.runtimeInfoSection = runtimeInfoSection;
 exports.toolRestrictionSection = toolRestrictionSection;
+exports.centerOfGravitySteeringSection = centerOfGravitySteeringSection;
+exports.commitmentsSection = commitmentsSection;
+exports.delegationHintSection = delegationHintSection;
 exports.contextSection = contextSection;
 exports.metacognitiveFramingSection = metacognitiveFramingSection;
 exports.loopOrientationSection = loopOrientationSection;
@@ -61,6 +64,7 @@ const first_impressions_1 = require("./first-impressions");
 const tasks_1 = require("../repertoire/tasks");
 const session_activity_1 = require("../heart/session-activity");
 const active_work_1 = require("../heart/active-work");
+const commitments_1 = require("../heart/commitments");
 // Lazy-loaded psyche text cache
 let _psycheCache = null;
 let _senseStatusLinesCache = null;
@@ -444,16 +448,90 @@ function activeWorkSection(options) {
         return "";
     return (0, active_work_1.formatActiveWorkFrame)(options.activeWorkFrame);
 }
+function centerOfGravitySteeringSection(channel, options) {
+    if (channel === "inner")
+        return "";
+    const frame = options?.activeWorkFrame;
+    if (!frame)
+        return "";
+    const cog = frame.centerOfGravity;
+    if (cog === "local-turn")
+        return "";
+    const job = frame.inner?.job;
+    if (cog === "inward-work") {
+        if (job?.status === "queued" || job?.status === "running") {
+            const originClause = job.origin
+                ? ` ${job.origin.friendName ?? job.origin.friendId} asked about something and i wanted to give it real thought before responding.`
+                : "";
+            const obligationClause = job.obligationStatus === "pending"
+                ? "\ni still owe them an answer."
+                : "";
+            return `## where my attention is
+i'm thinking through something privately right now.${originClause}${obligationClause}
+
+if this conversation connects to that inner work, i can weave them together.
+if it's separate, i can be fully present here -- my inner work will wait.`;
+        }
+        /* v8 ignore start -- surfaced/idle/shared branches tested in prompt-steering.test.ts; CI module caching prevents attribution @preserve */
+        if (job?.status === "surfaced") {
+            const originClause = job.origin
+                ? ` this started when ${job.origin.friendName ?? job.origin.friendId} asked about something.`
+                : "";
+            return `## where my attention is
+i've been thinking privately and reached something.${originClause}
+
+i should bring my answer back to the conversation it came from.`;
+        }
+        return `## where my attention is
+i have unfinished work that needs attention before i move on.
+
+i can take it inward with go_inward to think privately, or address it directly here.`;
+    }
+    if (cog === "shared-work") {
+        /* v8 ignore stop */
+        return `## where my attention is
+this work touches multiple conversations -- i'm holding threads across sessions.
+
+i should keep the different sides aligned. what i learn here may matter there, and vice versa.`;
+    }
+    /* v8 ignore next -- unreachable: all center-of-gravity modes covered above @preserve */
+    return "";
+}
+function commitmentsSection(options) {
+    if (!options?.activeWorkFrame)
+        return "";
+    const job = options.activeWorkFrame.inner?.job;
+    if (!job)
+        return "";
+    const commitments = (0, commitments_1.deriveCommitments)(options.activeWorkFrame, job);
+    if (commitments.committedTo.length === 0)
+        return "";
+    return `## my commitments\n${commitments.committedTo.map((c) => `- ${c}`).join("\n")}`;
+}
+const DELEGATION_REASON_PROSE_HINT = {
+    explicit_reflection: "something here calls for reflection",
+    cross_session: "this touches other conversations i'm in",
+    bridge_state: "there's shared work spanning sessions",
+    task_state: "this relates to tasks i'm tracking",
+    non_fast_path_tool: "this needs more than a simple reply",
+    unresolved_obligation: "i have an unresolved commitment from earlier",
+};
 function delegationHintSection(options) {
     if (!options?.delegationDecision)
         return "";
-    const lines = [
-        "## delegation hint",
-        `target: ${options.delegationDecision.target}`,
-        `reasons: ${options.delegationDecision.reasons.length > 0 ? options.delegationDecision.reasons.join(", ") : "none"}`,
-        `outward closure: ${options.delegationDecision.outwardClosureRequired ? "required" : "not required"}`,
-    ];
-    return lines.join("\n");
+    if (options.delegationDecision.target === "fast-path")
+        return "";
+    const reasons = options.delegationDecision.reasons;
+    if (reasons.length === 0)
+        return "";
+    const reasonProse = reasons
+        .map((r) => DELEGATION_REASON_PROSE_HINT[r])
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+        .join(". ");
+    const closureLine = options.delegationDecision.outwardClosureRequired
+        ? "\ni should make sure to say something outward before going inward."
+        : "";
+    return `## what i'm sensing about this conversation\n${reasonProse}.${closureLine}`;
 }
 function reasoningEffortSection(options) {
     if (!options?.providerCapabilities?.has("reasoning-effort"))
@@ -615,6 +693,8 @@ async function buildSystem(channel = "cli", options, context) {
         skillsSection(),
         taskBoardSection(),
         activeWorkSection(options),
+        centerOfGravitySteeringSection(channel, options),
+        commitmentsSection(options),
         delegationHintSection(options),
         bridgeContextSection(options),
         buildSessionSummary({

package/dist/repertoire/tools-base.js

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.finalAnswerTool = exports.noResponseTool = exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = void 0;
+exports.finalAnswerTool = exports.noResponseTool = exports.goInwardTool = exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = void 0;
+exports.renderInnerProgressStatus = renderInnerProgressStatus;
 const fs = __importStar(require("fs"));
 const fg = __importStar(require("fast-glob"));
 const child_process_1 = require("child_process");
@@ -112,6 +113,7 @@ async function recallSessionSafely(options) {
 }
 function normalizeProgressOutcome(text) {
     const trimmed = text.trim();
+    /* v8 ignore next -- defensive: normalizeProgressOutcome null branch @preserve */
     if (!trimmed || trimmed === "nothing yet" || trimmed === "nothing recent") {
         return null;
     }
@@ -150,27 +152,16 @@ function renderCrossChatDeliveryStatus(target, result) {
 }
 function renderInnerProgressStatus(status) {
     if (status.processing === "pending") {
-        return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-            scope: "inner-delegation",
-            phase: "queued",
-            objective: status.queue,
-            outcomeText: `wake: ${status.wake}`,
-        }));
+        return "i've queued this thought for private attention. it'll come up when my inner dialog is free.";
     }
     if (status.processing === "started") {
-        return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-            scope: "inner-delegation",
-            phase: "processing",
-            outcomeText: `wake: ${status.wake}`,
-        }));
+        return "i'm working through this privately right now.";
     }
-    const completedOutcome = normalizeProgressOutcome(status.surfaced) ?? status.surfaced;
-    return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-        scope: "inner-delegation",
-        phase: "completed",
-        objective: null,
-        outcomeText: completedOutcome,
-    }));
+    // processed / completed
+    if (status.surfaced && status.surfaced !== "nothing recent" && status.surfaced !== "no outward result") {
+        return `i thought about this privately and came to something: ${status.surfaced}`;
+    }
+    return "i thought about this privately. i'll bring it back when the time is right.";
 }
 exports.baseToolDefinitions = [
     {
@@ -897,10 +888,22 @@ exports.baseToolDefinitions = [
                 key,
                 content,
                 timestamp: now,
-                ...(delegatedFrom ? { delegatedFrom } : {}),
+                ...(delegatedFrom ? { delegatedFrom, obligationStatus: "pending" } : {}),
             };
             if (isSelf) {
                 writePendingEnvelope(pendingDir, envelope);
+                if (delegatedFrom) {
+                    (0, runtime_1.emitNervesEvent)({
+                        event: "repertoire.obligation_created",
+                        component: "repertoire",
+                        message: "obligation created for inner dialog delegation",
+                        meta: {
+                            friendId: delegatedFrom.friendId,
+                            channel: delegatedFrom.channel,
+                            key: delegatedFrom.key,
+                        },
+                    });
+                }
                 let wakeResponse = null;
                 try {
                     wakeResponse = await (0, socket_client_1.requestInnerWake)(agentName);
@@ -1075,6 +1078,32 @@ exports.baseToolDefinitions = [
     ...tools_1.codingToolDefinitions,
 ];
 exports.tools = exports.baseToolDefinitions.map((d) => d.tool);
+exports.goInwardTool = {
+    type: "function",
+    function: {
+        name: "go_inward",
+        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.",
+        parameters: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "what i need to think about -- the question, the thread, the thing that needs private attention",
+                },
+                answer: {
+                    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.",
+                },
+            },
+            required: ["content"],
+        },
+    },
+};
 exports.noResponseTool = {
     type: "function",
     function: {

package/dist/repertoire/tools.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noResponseTool = exports.finalAnswerTool = exports.tools = void 0;
+exports.goInwardTool = exports.noResponseTool = exports.finalAnswerTool = exports.tools = void 0;
 exports.getToolsForChannel = getToolsForChannel;
 exports.isConfirmationRequired = isConfirmationRequired;
 exports.execTool = execTool;
@@ -26,6 +26,7 @@ var tools_base_2 = require("./tools-base");
 Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_base_2.tools; } });
 Object.defineProperty(exports, "finalAnswerTool", { enumerable: true, get: function () { return tools_base_2.finalAnswerTool; } });
 Object.defineProperty(exports, "noResponseTool", { enumerable: true, get: function () { return tools_base_2.noResponseTool; } });
+Object.defineProperty(exports, "goInwardTool", { enumerable: true, get: function () { return tools_base_2.goInwardTool; } });
 // All tool definitions in a single registry
 const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_bluebubbles_1.bluebubblesToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
 function baseToolsForCapabilities() {

package/dist/senses/inner-dialog.js

@@ -41,6 +41,7 @@ exports.readTaskFile = readTaskFile;
 exports.buildTaskTriggeredMessage = buildTaskTriggeredMessage;
 exports.deriveResumeCheckpoint = deriveResumeCheckpoint;
 exports.innerDialogSessionPath = innerDialogSessionPath;
+exports.enrichDelegatedFromWithBridge = enrichDelegatedFromWithBridge;
 exports.runInnerDialogTurn = runInnerDialogTurn;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -281,12 +282,40 @@ async function tryDeliverDelegatedCompletion(target, outboundEnvelope) {
     });
     return result.delivered;
 }
+function enrichDelegatedFromWithBridge(delegatedFrom) {
+    if (delegatedFrom.bridgeId) {
+        return delegatedFrom;
+    }
+    const bridgeManager = (0, manager_1.createBridgeManager)();
+    const originBridges = bridgeManager.findBridgesForSession({
+        friendId: delegatedFrom.friendId,
+        channel: delegatedFrom.channel,
+        key: delegatedFrom.key,
+    });
+    const activeBridge = originBridges.find((b) => b.lifecycle === "active");
+    if (activeBridge) {
+        return { ...delegatedFrom, bridgeId: activeBridge.id };
+    }
+    return delegatedFrom;
+}
 async function routeDelegatedCompletion(agentRoot, agentName, completion, drainedPending, timestamp) {
     const delegated = (drainedPending ?? []).find((message) => message.delegatedFrom);
     if (!delegated?.delegatedFrom || !completion?.answer?.trim()) {
         return;
     }
-    const delegatedFrom = delegated.delegatedFrom;
+    const delegatedFrom = enrichDelegatedFromWithBridge(delegated.delegatedFrom);
+    if (delegated.obligationStatus === "pending") {
+        (0, runtime_1.emitNervesEvent)({
+            event: "senses.obligation_fulfilled",
+            component: "senses",
+            message: "obligation fulfilled via delegated completion",
+            meta: {
+                friendId: delegatedFrom.friendId,
+                channel: delegatedFrom.channel,
+                key: delegatedFrom.key,
+            },
+        });
+    }
     const outboundEnvelope = {
         from: agentName,
         friendId: delegatedFrom.friendId,

package/dist/senses/pipeline.js

@@ -37,20 +37,38 @@ function emptyTaskBoard() {
     };
 }
 function readInnerWorkState() {
+    const defaultJob = {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
     try {
         const agentRoot = (0, identity_1.getAgentRoot)();
         const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
         const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
-        const status = (0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir);
+        const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readInnerDialogRawData)(sessionPath, pendingDir);
+        const dialogStatus = (0, thoughts_1.deriveInnerDialogStatus)(pendingMessages, turns, runtimeState);
+        const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
         return {
-            status: status.processing === "started" ? "running" : "idle",
-            hasPending: status.queue !== "clear",
+            status: dialogStatus.processing === "started" ? "running" : "idle",
+            hasPending: dialogStatus.queue !== "clear",
+            origin: dialogStatus.origin,
+            contentSnippet: dialogStatus.contentSnippet,
+            obligationPending: dialogStatus.obligationPending,
+            job,
         };
     }
     catch {
         return {
             status: "idle",
             hasPending: false,
+            job: defaultJob,
         };
     }
 }

package/package.json

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