@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.637

package/dist/senses/inner-dialog.js

@@ -41,6 +41,10 @@ exports.readTaskFile = readTaskFile;
 exports.buildTaskTriggeredMessage = buildTaskTriggeredMessage;
 exports.deriveResumeCheckpoint = deriveResumeCheckpoint;
 exports.innerDialogSessionPath = innerDialogSessionPath;
+exports.enrichDelegatedFromWithBridge = enrichDelegatedFromWithBridge;
+exports.routeDelegatedCompletion = routeDelegatedCompletion;
+exports.buildParseErrorNudge = buildParseErrorNudge;
+exports.buildHeldReturnWakeMessage = buildHeldReturnWakeMessage;
 exports.runInnerDialogTurn = runInnerDialogTurn;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -49,8 +53,13 @@ const core_1 = require("../heart/core");
 const identity_1 = require("../heart/identity");
 const context_1 = require("../mind/context");
 const prompt_1 = require("../mind/prompt");
+const mcp_manager_1 = require("../repertoire/mcp-manager");
+const tools_1 = require("../repertoire/tools");
 const bundle_manifest_1 = require("../mind/bundle-manifest");
 const pending_1 = require("../mind/pending");
+const obligations_1 = require("../arc/obligations");
+const attention_queue_1 = require("./attention-queue");
+const packets_1 = require("../arc/packets");
 const channel_1 = require("../mind/friends/channel");
 const trust_gate_1 = require("./trust-gate");
 const tokens_1 = require("../mind/friends/tokens");
@@ -60,6 +69,15 @@ const runtime_1 = require("../nerves/runtime");
 const manager_1 = require("../heart/bridges/manager");
 const session_activity_1 = require("../heart/session-activity");
 const bluebubbles_1 = require("./bluebubbles");
+const habit_turn_message_1 = require("./habit-turn-message");
+const await_turn_message_1 = require("./await-turn-message");
+const await_parser_1 = require("../heart/awaiting/await-parser");
+const await_runtime_state_1 = require("../heart/awaiting/await-runtime-state");
+const journal_index_1 = require("../mind/journal-index");
+const habit_parser_1 = require("../heart/habits/habit-parser");
+const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
+const cadence_1 = require("../heart/daemon/cadence");
+const daemon_health_1 = require("../heart/daemon/daemon-health");
 const DEFAULT_INNER_DIALOG_INSTINCTS = [
     {
         id: "heartbeat_checkin",
@@ -98,23 +116,31 @@ function buildNonCanonicalCleanupNudge(nonCanonicalPaths) {
     }
     return [
         "## canonical cleanup nudge",
-        "I found non-canonical files in my bundle. I should distill anything valuable into your memory system and remove these files.",
+        "I found non-canonical files in my bundle. I should distill anything valuable into my diary and remove these files.",
         ...listed,
     ].join("\n");
 }
+function displayCheckpoint(checkpoint) {
+    const trimmed = checkpoint?.trim();
+    if (!trimmed || trimmed === "no prior checkpoint recorded") {
+        return undefined;
+    }
+    return trimmed;
+}
 function buildInstinctUserMessage(instincts, _reason, state) {
     const active = instincts.find((instinct) => instinct.enabled !== false) ?? DEFAULT_INNER_DIALOG_INSTINCTS[0];
-    const checkpoint = state.checkpoint?.trim();
+    const checkpoint = displayCheckpoint(state.checkpoint);
     const lines = [active.prompt];
     if (checkpoint) {
-        lines.push(`\nlast i remember: ${checkpoint}`);
+        lines.push(`\nlast checkpoint: ${checkpoint}`);
     }
     return lines.join("\n");
 }
 function readTaskFile(agentRoot, taskId) {
-    // Task files live in collection subdirectories (one-shots, ongoing, habits).
+    // Task files live in collection subdirectories (one-shots, ongoing).
     // Try each collection, then fall back to root tasks/ for legacy layout.
-    const collections = ["one-shots", "ongoing", "habits", ""];
+    // Habits are no longer in tasks/ — they live at bundle root habits/.
+    const collections = ["one-shots", "ongoing", ""];
     for (const collection of collections) {
         try {
             return fs.readFileSync(path.join(agentRoot, "tasks", collection, `${taskId}.md`), "utf8").trim();
@@ -133,8 +159,9 @@ function buildTaskTriggeredMessage(taskId, taskContent, checkpoint) {
     else {
         lines.push("", `## task: ${taskId}`, "(task file not found)");
     }
-    if (checkpoint) {
-        lines.push("", `last i remember: ${checkpoint}`);
+    const renderedCheckpoint = displayCheckpoint(checkpoint);
+    if (renderedCheckpoint) {
+        lines.push("", `last checkpoint: ${renderedCheckpoint}`);
     }
     return lines.join("\n");
 }
@@ -157,31 +184,129 @@ function contentToText(content) {
         .join("\n");
     return text.trim();
 }
-function deriveResumeCheckpoint(messages) {
-    const lastAssistant = [...messages].reverse().find((message) => message.role === "assistant");
-    if (!lastAssistant)
-        return "no prior checkpoint recorded";
-    const assistantText = contentToText(lastAssistant.content);
+function checkpointTextFromAssistantContent(content) {
+    const assistantText = contentToText(content);
     if (!assistantText)
-        return "no prior checkpoint recorded";
-    const explicitCheckpoint = assistantText
+        return null;
+    const cleanedLines = assistantText
         .split("\n")
-        .map((line) => line.trim())
+        .map((line) => line.replace(/<\/?think>/gi, "").trim())
+        .filter((line) => line.length > 0);
+    const explicitCheckpoint = cleanedLines
         .find((line) => /^checkpoint\s*:/i.test(line));
     if (explicitCheckpoint) {
         const parsed = explicitCheckpoint.replace(/^checkpoint\s*:\s*/i, "").trim();
-        return parsed || "no prior checkpoint recorded";
+        return parsed || null;
     }
-    const firstLine = assistantText
-        .split("\n")
-        .map((line) => line.trim())
-        .find((line) => line.length > 0);
-    /* v8 ignore next -- unreachable: contentToText().trim() guarantees a non-empty line @preserve */
-    if (!firstLine)
-        return "no prior checkpoint recorded";
-    if (firstLine.length <= 220)
-        return firstLine;
-    return `${firstLine.slice(0, 217)}...`;
+    const firstLine = cleanedLines[0];
+    return firstLine ?? null;
+}
+function truncateCheckpointText(text) {
+    if (text.length <= 220)
+        return text;
+    return `${text.slice(0, 217)}...`;
+}
+function parseToolArguments(argumentsValue) {
+    if (!argumentsValue)
+        return {};
+    try {
+        const parsed = JSON.parse(argumentsValue);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function toolArgumentText(args, keys) {
+    for (const key of keys) {
+        const value = args[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return "";
+}
+function summarizeToolAction(name, argumentsValue) {
+    if (!name)
+        return null;
+    const args = parseToolArguments(argumentsValue);
+    if (name === "surface") {
+        const message = toolArgumentText(args, ["message", "text", "content"]);
+        return message ? `surfaced: ${message}` : null;
+    }
+    if (name === "ponder") {
+        const thought = toolArgumentText(args, ["summary", "question", "topic", "prompt"]);
+        return thought ? `pondered: ${thought}` : null;
+    }
+    if (name === "diary_write") {
+        const note = toolArgumentText(args, ["text", "content", "note", "entry"]);
+        return note ? `diary: ${note}` : null;
+    }
+    if (name === "let_go") {
+        const reason = toolArgumentText(args, ["reason", "note", "status"]);
+        return reason ? `let go: ${reason}` : null;
+    }
+    if (name === "rest") {
+        const note = toolArgumentText(args, ["note", "status"]);
+        return note ? `rested: ${note}` : null;
+    }
+    return null;
+}
+function extractToolFunction(toolCall) {
+    if (!toolCall || typeof toolCall !== "object" || !("function" in toolCall))
+        return null;
+    const maybeFunction = toolCall.function;
+    if (!maybeFunction || typeof maybeFunction !== "object")
+        return null;
+    const name = "name" in maybeFunction && typeof maybeFunction.name === "string"
+        ? maybeFunction.name
+        : undefined;
+    const argumentsValue = "arguments" in maybeFunction && typeof maybeFunction.arguments === "string"
+        ? maybeFunction.arguments
+        : undefined;
+    return { name, arguments: argumentsValue };
+}
+function checkpointTextFromAssistantToolCalls(message) {
+    if (message.role !== "assistant" || !Array.isArray(message.tool_calls))
+        return null;
+    for (let i = message.tool_calls.length - 1; i >= 0; i--) {
+        const toolFunction = extractToolFunction(message.tool_calls[i]);
+        const summary = summarizeToolAction(toolFunction?.name, toolFunction?.arguments);
+        if (summary)
+            return summary;
+    }
+    return null;
+}
+function latestRestStatus(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "assistant" || !Array.isArray(message.tool_calls))
+            continue;
+        for (let j = message.tool_calls.length - 1; j >= 0; j--) {
+            const toolFunction = extractToolFunction(message.tool_calls[j]);
+            if (toolFunction?.name !== "rest")
+                continue;
+            const status = parseToolArguments(toolFunction.arguments).status;
+            return typeof status === "string" && status.trim() ? status.trim() : undefined;
+        }
+    }
+    return undefined;
+}
+function deriveResumeCheckpoint(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "assistant")
+            continue;
+        const textCheckpoint = checkpointTextFromAssistantContent(message.content);
+        if (textCheckpoint)
+            return truncateCheckpointText(textCheckpoint);
+        const toolCheckpoint = checkpointTextFromAssistantToolCalls(message);
+        if (toolCheckpoint)
+            return truncateCheckpointText(toolCheckpoint);
+    }
+    return "no prior checkpoint recorded";
 }
 function extractAssistantPreview(messages, maxLength = 120) {
     const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
@@ -247,6 +372,7 @@ function writeInnerDialogRuntimeState(sessionFilePath, state) {
         });
     }
 }
+/* v8 ignore start -- routing helpers: called from routing functions which are integration paths @preserve */
 function writePendingEnvelope(pendingDir, message) {
     fs.mkdirSync(pendingDir, { recursive: true });
     const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
@@ -258,6 +384,8 @@ function sessionMatchesActivity(activity, session) {
         && activity.channel === session.channel
         && activity.key === session.key;
 }
+/* v8 ignore stop */
+/* v8 ignore start -- routing: delivery now inline via surface tool; routing functions preserved for reuse @preserve */
 function resolveBridgePreferredSession(delegatedFrom, sessionActivity) {
     if (!delegatedFrom.bridgeId)
         return null;
@@ -277,15 +405,82 @@ async function tryDeliverDelegatedCompletion(target, outboundEnvelope) {
         friendId: target.friendId,
         sessionKey: target.key,
         text: outboundEnvelope.content,
+        intent: "explicit_cross_chat",
     });
     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;
+}
+function advanceObligationQuietly(agentName, obligationId, update) {
+    if (!obligationId)
+        return;
+    try {
+        (0, obligations_1.advanceReturnObligation)(agentName, obligationId, update);
+        /* v8 ignore start -- best-effort: obligation fs errors must never block return routing @preserve */
+    }
+    catch {
+        // swallowed
+    }
+    /* v8 ignore stop */
+}
 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);
+    const obligationId = delegated.obligationId;
+    // Advance any inner return obligations from queued -> running (they were drained this turn).
+    // drainedPending is guaranteed non-null here (we found delegated above).
+    for (const msg of drainedPending) {
+        if (msg.obligationId) {
+            advanceObligationQuietly(agentName, msg.obligationId, {
+                status: "running",
+                startedAt: timestamp,
+            });
+        }
+    }
+    if (delegated.obligationStatus === "pending") {
+        // Fulfill the persistent obligation in the store
+        try {
+            const pending = (0, obligations_1.findPendingObligationForOrigin)(agentRoot, {
+                friendId: delegatedFrom.friendId,
+                channel: delegatedFrom.channel,
+                key: delegatedFrom.key,
+            });
+            /* v8 ignore next 2 -- obligation fulfillment tested via obligations.test.ts; integration requires real disk state @preserve */
+            if (pending) {
+                (0, obligations_1.fulfillObligation)(agentRoot, pending.id);
+            }
+        }
+        catch {
+            /* v8 ignore next -- defensive: obligation store read failure should not break delivery @preserve */
+        }
+        (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,
@@ -294,36 +489,62 @@ async function routeDelegatedCompletion(agentRoot, agentName, completion, draine
         content: completion.answer.trim(),
         timestamp,
         delegatedFrom,
+        ...(obligationId ? { obligationId } : {}),
     };
     const sessionActivity = (0, session_activity_1.listSessionActivity)({
         sessionsDir: path.join(agentRoot, "state", "sessions"),
         friendsDir: path.join(agentRoot, "friends"),
         agentName,
     });
+    // Priority 1: Bridge-preferred session (if delegation was within a bridge).
     const bridgeTarget = resolveBridgePreferredSession(delegatedFrom, sessionActivity);
     if (bridgeTarget) {
         if (await tryDeliverDelegatedCompletion(bridgeTarget, outboundEnvelope)) {
+            advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "bridge-session" });
             return;
         }
         writePendingEnvelope((0, pending_1.getPendingDir)(agentName, bridgeTarget.friendId, bridgeTarget.channel, bridgeTarget.key), outboundEnvelope);
+        advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "bridge-session" });
+        return;
+    }
+    // Priority 1.5: Direct return to originating session (ponder without bridge).
+    // When delegatedFrom has specific channel+key, route directly there instead of searching for freshest.
+    if (delegatedFrom.channel && delegatedFrom.key && delegatedFrom.channel !== "inner") {
+        const directTarget = sessionActivity.find((a) => a.friendId === delegatedFrom.friendId && a.channel === delegatedFrom.channel && a.key === delegatedFrom.key);
+        if (directTarget) {
+            if (await tryDeliverDelegatedCompletion(directTarget, outboundEnvelope)) {
+                advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "direct-originator" });
+                return;
+            }
+        }
+        // Even if session isn't in activity list (might have ended), queue to its pending dir
+        writePendingEnvelope((0, pending_1.getPendingDir)(agentName, delegatedFrom.friendId, delegatedFrom.channel, delegatedFrom.key), outboundEnvelope);
+        advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "direct-originator" });
         return;
     }
-    const freshest = (0, session_activity_1.findFreshestFriendSession)({
+    // Priority 2: Freshest active friend session.
+    // For BB, prefer DM sessions (;-;) over group chats (;+;) — proactive outreach should never land in groups.
+    const allFriendSessions = (0, session_activity_1.listSessionActivity)({
         sessionsDir: path.join(agentRoot, "state", "sessions"),
         friendsDir: path.join(agentRoot, "friends"),
         agentName,
-        friendId: delegatedFrom.friendId,
-        activeOnly: true,
-    });
-    if (freshest && freshest.channel !== "inner") {
+    }).filter((s) => s.friendId === delegatedFrom.friendId && s.channel !== "inner");
+    const bbDm = allFriendSessions.find((s) => s.channel === "bluebubbles" && s.key.includes(";-;"));
+    const freshest = bbDm ?? allFriendSessions.find((s) => s.channel !== "bluebubbles" || s.key.includes(";-;")) ?? allFriendSessions[0];
+    if (freshest) {
         if (await tryDeliverDelegatedCompletion(freshest, outboundEnvelope)) {
+            advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "freshest-session" });
             return;
         }
         writePendingEnvelope((0, pending_1.getPendingDir)(agentName, freshest.friendId, freshest.channel, freshest.key), outboundEnvelope);
+        advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "freshest-session" });
         return;
     }
+    // Priority 3: Deferred return queue.
     writePendingEnvelope((0, pending_1.getDeferredReturnDir)(agentName, delegatedFrom.friendId), outboundEnvelope);
+    advanceObligationQuietly(agentName, obligationId, { status: "deferred", returnedAt: timestamp, returnTarget: "deferred" });
 }
+/* v8 ignore stop */
 // Self-referencing friend record for inner dialog (agent talking to itself).
 // No real friend to resolve -- this satisfies the pipeline's friend resolver contract.
 function createSelfFriend(agentName) {
@@ -350,12 +571,67 @@ function createNoOpFriendStore() {
         findByExternalId: async () => null,
     };
 }
+function buildParseErrorNudge(parseErrors) {
+    if (parseErrors.length === 0)
+        return "";
+    const lines = parseErrors.map((e) => `I noticed my habit file \`${e.file}\` has invalid frontmatter — I should fix it. (${e.error})`);
+    return lines.join("\n");
+}
+function buildHeldReturnWakeMessage() {
+    return [
+        "held return work arrived; use the current held-work frame above as the authority for this turn.",
+        "Older checkpoints, rest summaries, transcript memories, completed returns, and repeated probes are historical context, not evidence about what is waiting now.",
+        "Return only the requested result; do not add commentary about prior attempts, old loops, or completed probes.",
+        "Return each listed item with surface(delegationId=...) before resting or settling.",
+    ].join("\n");
+}
+function buildAlsoDueLine(agentRoot, currentHabitName, now) {
+    const habitsDir = path.join(agentRoot, "habits");
+    let files;
+    try {
+        files = fs.readdirSync(habitsDir);
+    }
+    catch {
+        return "";
+    }
+    const nowMs = now().getTime();
+    const alsoDue = [];
+    for (const file of files) {
+        if (!file.endsWith(".md"))
+            continue;
+        const stem = file.replace(/\.md$/, "");
+        if (stem === currentHabitName)
+            continue;
+        try {
+            const content = fs.readFileSync(path.join(habitsDir, file), "utf-8");
+            const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(content, path.join(habitsDir, file)));
+            if (habit.status !== "active" || !habit.cadence)
+                continue;
+            const cadenceMs = (0, cadence_1.parseCadenceToMs)(habit.cadence);
+            if (cadenceMs === null)
+                continue;
+            if (habit.lastRun === null) {
+                alsoDue.push(stem);
+                continue;
+            }
+            const lastRunMs = new Date(habit.lastRun).getTime();
+            if (nowMs - lastRunMs >= cadenceMs) {
+                alsoDue.push(stem);
+            }
+        }
+        catch {
+            // skip unreadable habits
+        }
+    }
+    if (alsoDue.length === 0)
+        return "";
+    return `also due: ${alsoDue.join(", ")}`;
+}
 async function runInnerDialogTurn(options) {
     const now = options?.now ?? (() => new Date());
-    const reason = options?.reason ?? "heartbeat";
+    const reason = options?.reason ?? "instinct";
     const sessionFilePath = innerDialogSessionPath();
     const agentName = (0, identity_1.getAgentName)();
-    const agentRoot = (0, identity_1.getAgentRoot)();
     writeInnerDialogRuntimeState(sessionFilePath, {
         status: "running",
         reason,
@@ -370,8 +646,14 @@ async function runInnerDialogTurn(options) {
             resting: false,
             lastHeartbeatAt: now().toISOString(),
         };
+        const pendingDir = (0, pending_1.getInnerDialogPendingDir)(agentName);
+        const shouldUseHeldReturnWake = !options?.taskId && reason !== "habit" && reason !== "await"
+            ? (0, obligations_1.listActiveReturnObligations)(agentName).length > 0
+            : false;
         // ── Adapter concern: build user message ──────────────────────────
         let userContent;
+        let habitTools;
+        let habitParsedSuccessfully = false;
         if (existingMessages.length === 0) {
             // Fresh session: bootstrap message with non-canonical cleanup nudge
             const aspirations = readAspirations((0, identity_1.getAgentRoot)());
@@ -391,32 +673,173 @@ async function runInnerDialogTurn(options) {
                 const taskContent = readTaskFile((0, identity_1.getAgentRoot)(), options.taskId);
                 userContent = buildTaskTriggeredMessage(options.taskId, taskContent, state.checkpoint);
             }
+            else if (reason === "habit" && options?.habitName) {
+                const agentRoot = (0, identity_1.getAgentRoot)();
+                const habitName = options.habitName;
+                const habitFilePath = path.join(agentRoot, "habits", `${habitName}.md`);
+                // Read and parse the habit file
+                let habitBody;
+                let habitTitle = habitName;
+                let habitLastRun = null;
+                try {
+                    const habitContent = fs.readFileSync(habitFilePath, "utf-8");
+                    const parsed = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(habitContent, habitFilePath));
+                    habitBody = parsed.body || undefined;
+                    habitTitle = parsed.title || habitName;
+                    habitLastRun = parsed.lastRun;
+                    habitTools = parsed.tools;
+                }
+                catch {
+                    // Habit file missing or unreadable
+                }
+                // If the habit file couldn't be read at all (no body, no title parsed), error message
+                if (habitBody === undefined && habitTitle === habitName) {
+                    userContent = `habit "${habitName}" could not be read (file not found or unreadable). check habits/${habitName}.md exists.`;
+                }
+                else {
+                    habitParsedSuccessfully = true;
+                    // Unified path: gather context for ALL habits (heartbeat included)
+                    const obligations = (0, obligations_1.listActiveReturnObligations)(agentName);
+                    const nowMs = now().getTime();
+                    const staleObligations = obligations.map((o) => ({
+                        friendName: o.origin.friendId,
+                        content: o.delegatedContent,
+                        stalenessMs: nowMs - o.createdAt,
+                    }));
+                    const alsoDue = buildAlsoDueLine(agentRoot, habitName, now);
+                    // Degraded state (best-effort: never crash)
+                    let degradedComponents = [];
+                    try {
+                        const health = (0, daemon_health_1.readHealth)((0, daemon_health_1.getDefaultHealthPath)());
+                        if (health && health.degraded.length > 0) {
+                            degradedComponents = health.degraded.map((d) => ({ component: d.component, reason: d.reason }));
+                        }
+                    }
+                    catch {
+                        // Best-effort: missing file or parse error -> empty array, no crash
+                    }
+                    userContent = (0, habit_turn_message_1.buildHabitTurnMessage)({
+                        habitName,
+                        habitTitle,
+                        habitBody,
+                        lastRun: habitLastRun,
+                        checkpoint: displayCheckpoint(state.checkpoint),
+                        alsoDue: alsoDue || undefined,
+                        staleObligations,
+                        parseErrors: options?.parseErrors ?? [],
+                        degradedComponents,
+                        now,
+                    });
+                    // Piggyback journal embedding indexing (best-effort, fire-and-forget)
+                    const journalDir = path.join(agentRoot, "journal");
+                    /* v8 ignore start -- journal indexing piggyback: embedding provider may not be available; tested via journal-index unit tests @preserve */
+                    void (0, journal_index_1.indexJournalFiles)(journalDir, path.join(journalDir, ".index.json"), {
+                        embed: async () => [],
+                    }).catch(() => {
+                        // swallowed: indexing failure must never block habit turn
+                    });
+                    /* v8 ignore stop */
+                }
+            }
+            else if (reason === "await" && options?.awaitName) {
+                const agentRoot = (0, identity_1.getAgentRoot)();
+                const awaitName = options.awaitName;
+                const awaitFilePath = path.join(agentRoot, "awaiting", `${awaitName}.md`);
+                let awaitBody;
+                let condition = null;
+                let lastCheckedAt = null;
+                let lastObservation = null;
+                let checkedCount = 0;
+                let awaitFound = false;
+                try {
+                    const awaitContent = fs.readFileSync(awaitFilePath, "utf-8");
+                    const parsed = (0, await_runtime_state_1.applyAwaitRuntimeState)(agentRoot, (0, await_parser_1.parseAwaitFile)(awaitContent, awaitFilePath));
+                    awaitFound = true;
+                    awaitBody = parsed.body || undefined;
+                    condition = parsed.condition;
+                    lastCheckedAt = parsed.last_checked ?? null;
+                    lastObservation = parsed.last_observation ?? null;
+                    checkedCount = parsed.checked_count ?? 0;
+                }
+                catch {
+                    // file missing — fall through to error message
+                }
+                if (!awaitFound || !condition) {
+                    userContent = `await "${awaitName}" could not be read (file not found or no condition). check awaiting/${awaitName}.md.`;
+                }
+                else {
+                    userContent = (0, await_turn_message_1.buildAwaitTurnMessage)({
+                        awaitName,
+                        condition,
+                        body: awaitBody,
+                        lastCheckedAt,
+                        lastObservation,
+                        checkedCount,
+                        checkpoint: displayCheckpoint(state.checkpoint),
+                        now,
+                    });
+                }
+            }
             else {
                 userContent = buildInstinctUserMessage(instincts, reason, state);
             }
         }
+        if (shouldUseHeldReturnWake) {
+            userContent = buildHeldReturnWakeMessage();
+        }
         const userMessage = { role: "user", content: userContent };
         // ── Session loader: wraps existing session logic ──────────────────
         const innerCapabilities = (0, channel_1.getChannelCapabilities)("inner");
-        const pendingDir = (0, pending_1.getInnerDialogPendingDir)(agentName);
         const selfFriend = createSelfFriend(agentName);
         const selfContext = { friend: selfFriend, channel: innerCapabilities };
+        const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
+        // ── Habit tool enforcement ───────────────────────────────────────
+        let habitToolsResolved;
+        if (habitTools !== undefined) {
+            const fullTools = (0, tools_1.getToolsForChannel)(innerCapabilities);
+            habitToolsResolved = fullTools.filter((t) => habitTools.includes(t.function.name));
+            (0, runtime_1.emitNervesEvent)({
+                event: "habit.tools_restricted",
+                component: "senses",
+                message: "habit running with restricted tools",
+                meta: {
+                    habitName: options?.habitName,
+                    declared: habitTools,
+                    resolved: habitToolsResolved.map((t) => t.function.name),
+                },
+            });
+        }
+        else if (reason === "habit" && options?.habitName && habitParsedSuccessfully) {
+            (0, runtime_1.emitNervesEvent)({
+                event: "habit.tools_unrestricted",
+                component: "senses",
+                message: "habit running with full tool repertoire",
+                meta: { habitName: options.habitName },
+            });
+        }
         const sessionLoader = {
             loadOrCreate: async () => {
                 if (existingMessages.length > 0) {
-                    return { messages: existingMessages, sessionPath: sessionFilePath };
+                    return {
+                        messages: existingMessages,
+                        sessionPath: sessionFilePath,
+                        structuredOutputs: loaded?.structuredOutputs,
+                    };
                 }
                 // Fresh session: build system prompt
                 const systemPrompt = await (0, prompt_1.buildSystem)("inner", { toolChoiceRequired: true });
                 return {
-                    messages: [{ role: "system", content: systemPrompt }],
+                    messages: [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(systemPrompt) }],
                     sessionPath: sessionFilePath,
+                    structuredOutputs: [],
                 };
             },
         };
         // ── Call shared pipeline ──────────────────────────────────────────
         const callbacks = createInnerDialogCallbacks();
         const traceId = (0, nerves_1.createTraceId)();
+        // Attention queue: built when pending messages are drained, shared with tool context
+        let attentionQueue = [];
         const result = await (0, pipeline_1.handleInboundTurn)({
             channel: "inner",
             sessionKey: "dialog",
@@ -431,16 +854,56 @@ async function runInnerDialogTurn(options) {
             enforceTrustGate: trust_gate_1.enforceTrustGate,
             drainPending: pending_1.drainPending,
             runAgent: core_1.runAgent,
-            postTurn: context_1.postTurn,
+            postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+                const prepared = (0, context_1.postTurnTrim)(turnMessages, usage, hooks);
+                (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
+            },
             accumulateFriendTokens: tokens_1.accumulateFriendTokens,
             signal: options?.signal,
+            /* v8 ignore start -- attention queue: callback invoked by pipeline during pending drain; tested via attention-queue unit tests @preserve */
+            onPendingDrained: (drained) => {
+                const outstandingObligations = (0, obligations_1.listActiveReturnObligations)(agentName);
+                const builtAttentionQueue = (0, attention_queue_1.buildAttentionQueue)({
+                    drainedPending: drained,
+                    outstandingObligations,
+                    friendNameResolver: (friendId) => {
+                        try {
+                            const raw = fs.readFileSync(path.join((0, identity_1.getAgentRoot)(agentName), "friends", friendId + ".json"), "utf-8");
+                            const parsed = JSON.parse(raw);
+                            return typeof parsed.name === "string" ? parsed.name : null;
+                        }
+                        catch {
+                            return null;
+                        }
+                    },
+                    packetResolver: (packetId) => {
+                        try {
+                            return (0, packets_1.readPonderPacket)((0, identity_1.getAgentRoot)(agentName), packetId);
+                        }
+                        catch {
+                            return null;
+                        }
+                    },
+                });
+                attentionQueue.splice(0, attentionQueue.length, ...builtAttentionQueue);
+                const attentionFrame = (0, attention_queue_1.buildAttentionQueueStatusFrame)(attentionQueue);
+                return attentionFrame ? [attentionFrame] : [];
+            },
+            /* v8 ignore stop */
             runAgentOptions: {
                 traceId,
                 toolChoiceRequired: true,
-                skipConfirmation: true,
+                mcpManager,
+                ...(habitToolsResolved !== undefined && { tools: habitToolsResolved }),
+                toolContext: {
+                    signin: async () => undefined,
+                    delegatedOrigins: attentionQueue,
+                },
             },
         });
-        await routeDelegatedCompletion(agentRoot, agentName, result.completion, result.drainedPending, now().getTime());
+        // Post-turn routeDelegatedCompletion removed: delivery is now inline via surface tool.
+        // settle in inner dialog produces no CompletionMetadata, so routeDelegatedCompletion
+        // would be a no-op. The routing infrastructure is reused by the surface handler.
         const resultMessages = result.messages ?? [];
         const assistantPreview = extractAssistantPreview(resultMessages);
         const toolCalls = extractToolCallNames(resultMessages);
@@ -466,6 +929,8 @@ async function runInnerDialogTurn(options) {
             usage: result.usage,
             sessionPath: result.sessionPath ?? sessionFilePath,
             completion: result.completion,
+            turnOutcome: result.turnOutcome,
+            restStatus: latestRestStatus(resultMessages),
         };
     }
     finally {