@ouro.bot/cli 0.1.0-alpha.665 → 0.1.0-alpha.667

package/dist/senses/inner-dialog-worker.js

@@ -36,13 +36,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HEARTBEAT_OK_REST_SUPPRESSION_MS = exports.HABIT_RECURSION_BURST_THRESHOLD = exports.HABIT_RECURSION_BURST_WINDOW_MS = exports.HABIT_RECURSION_MIN_INTERVAL_MS = exports.MAX_CONSECUTIVE_INSTINCT_TURNS = void 0;
 exports.createInnerDialogWorker = createInnerDialogWorker;
 exports.startInnerDialogWorker = startInnerDialogWorker;
+const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const inner_dialog_1 = require("./inner-dialog");
 const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
 const pending_1 = require("../mind/pending");
+const habit_parser_1 = require("../heart/habits/habit-parser");
 const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
+const habit_session_1 = require("../heart/habits/habit-session");
 const flight_recorder_1 = require("../arc/flight-recorder");
+const habit_session_summary_1 = require("../heart/habits/habit-session-summary");
+const store_file_1 = require("../mind/friends/store-file");
+const tools_base_1 = require("../repertoire/tools-base");
+const tools_surface_1 = require("../repertoire/tools-surface");
+const tools_1 = require("../repertoire/tools");
 /**
  * Cap on consecutive `instinct` follow-on turns triggered by `hasPendingWork()`
  * with no externally-queued work in between. Without this cap, a turn that
@@ -83,62 +91,190 @@ function isHeartbeatOkRestResult(result) {
     const maybeResult = result;
     return maybeResult.turnOutcome === "rested" && maybeResult.restStatus === "HEARTBEAT_OK";
 }
-function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options), hasPendingWork = () => (0, pending_1.hasPendingMessages)((0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)())), nowSource = () => Date.now()) {
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content.trim();
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => isRecord(part) && typeof part.text === "string" ? part.text : "")
+        .filter((text) => text.trim().length > 0)
+        .join("\n")
+        .trim();
+}
+function resultMessages(result) {
+    if (Array.isArray(result))
+        return result.flatMap((entry) => resultMessages(entry));
+    return isRecord(result) && Array.isArray(result.messages) ? result.messages : [];
+}
+function latestAssistantText(results) {
+    for (let resultIndex = results.length - 1; resultIndex >= 0; resultIndex--) {
+        const messages = resultMessages(results[resultIndex]);
+        for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex--) {
+            const message = messages[messageIndex];
+            if (!isRecord(message) || message.role !== "assistant")
+                continue;
+            const text = contentToText(message.content);
+            if (text.length > 0)
+                return text.replace(/^checkpoint\s*:\s*/i, "").trim() || text;
+        }
+    }
+    return null;
+}
+function deriveHabitSummarySnapshot(habitRun) {
+    const assistant = latestAssistantText(habitRun.results);
+    if (assistant)
+        return { summary: assistant, decisions: [], nextLikelyStep: null };
+    if (habitRun.errors.length > 0) {
+        return {
+            summary: `Habit ${habitRun.habit.name} finished with errors: ${habitRun.errors.join("; ")}`,
+            decisions: [],
+            nextLikelyStep: null,
+        };
+    }
+    const surfaced = habitRun.surfaceAttempts.find((attempt) => attempt.result !== "blocked" && attempt.result !== "failed" && attempt.result !== "unavailable");
+    if (surfaced) {
+        return {
+            summary: `Habit ${habitRun.habit.name} surfaced via ${surfaced.recipient}/${surfaced.channel}.`,
+            decisions: [],
+            nextLikelyStep: null,
+        };
+    }
+    const produced = habitRun.producedRefs.find((ref) => ref.kind !== "none");
+    if (produced) {
+        return {
+            summary: `Habit ${habitRun.habit.name} produced ${produced.kind}: ${produced.locator}.`,
+            decisions: [],
+            nextLikelyStep: null,
+        };
+    }
+    if (habitRun.results.some(isHeartbeatOkRestResult)) {
+        return {
+            summary: `Habit ${habitRun.habit.name} rested with HEARTBEAT_OK.`,
+            decisions: [],
+            nextLikelyStep: null,
+        };
+    }
+    return {
+        summary: `Habit ${habitRun.habit.name} completed without additional surfaced output.`,
+        decisions: [],
+        nextLikelyStep: null,
+    };
+}
+function fallbackHabitFile(habitName) {
+    return {
+        name: habitName,
+        title: habitName,
+        cadence: null,
+        status: "active",
+        lastRun: null,
+        created: null,
+        tools: [],
+        origin: null,
+        surface: { family: false, originator: false, extra: [] },
+        continuity: { mode: "fresh" },
+        body: "",
+    };
+}
+function readHabitForRun(agentRoot, habitName, errors) {
+    const habitPath = path.join(agentRoot, "habits", `${habitName}.md`);
+    try {
+        return (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        errors.push(`habit file could not be read: ${reason}`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.habit_file_read_error",
+            message: "habit file could not be read for habit session",
+            meta: { habitName, habitPath, reason },
+        });
+        return fallbackHabitFile(habitName);
+    }
+}
+async function prepareHabitRun(habitName, trigger, startedAt) {
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const errors = [];
+    const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, readHabitForRun(agentRoot, habitName, errors));
+    const runId = (0, flight_recorder_1.createHabitRunId)(habitName, new Date(startedAt));
+    const operationId = habit.continuity.mode === "stateful" ? `habit:${habit.name}` : null;
+    const priorSessionSummary = readPriorSessionSummary(agentRoot, operationId);
+    const paths = (0, habit_session_1.createHabitSessionPaths)(agentRoot, runId, habit.name);
+    const friendStore = new store_file_1.FileFriendStore(path.join(agentRoot, "friends"));
+    const permissionEnvelope = await (0, habit_session_1.normalizeHabitPermissionEnvelope)(habit, { agentRoot, friendStore });
+    const toolPolicy = (0, habit_session_1.filterHabitToolsForEnvelope)([...tools_base_1.baseToolDefinitions, tools_surface_1.surfaceToolDefinition], habit.tools ?? null, permissionEnvelope, riskProfileForHabitPolicy);
+    return {
+        agentRoot,
+        habit,
+        runId,
+        operationId,
+        trigger,
+        startedAt,
+        priorSessionSummary,
+        paths,
+        permissionEnvelope,
+        toolPolicy,
+        friendStore,
+        results: [],
+        errors,
+        producedRefs: [],
+        surfaceAttempts: [],
+    };
+}
+function riskProfileForHabitPolicy(definition, name) {
+    const probeArgs = name === "shell" ? { command: "touch /tmp/habit-policy-probe" } : {};
+    return (0, tools_1.riskProfileForTool)(definition, name, probeArgs);
+}
+function readPriorSessionSummary(agentRoot, operationId) {
+    if (operationId === null)
+        return undefined;
+    try {
+        const summary = (0, habit_session_summary_1.readHabitSessionSummary)(agentRoot, { operationId, which: "latest" });
+        if (!summary)
+            return { mode: "stateful", summary: null, sources: {}, warnings: [] };
+        return {
+            mode: "stateful",
+            summary: summary.summary,
+            sources: summary.sources,
+            warnings: summary.warnings,
+        };
+    }
+    catch (error) {
+        return {
+            mode: "stateful",
+            summary: null,
+            sources: {},
+            warnings: [`prior summary read failed: ${String(error)}`],
+        };
+    }
+}
+function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options), hasPendingWork = (pendingDir) => (0, pending_1.hasPendingMessages)(pendingDir ?? (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)())), nowSource = () => Date.now()) {
     let running = false;
     const queue = [];
     const lastFireByHabit = new Map();
     const recentHabitFires = [];
     let heartbeatOkRestedAt = null;
-    function habitOutcomeForTurn(result, errors) {
-        if (errors.length > 0)
-            return { outcome: "error", producedRefs: [] };
-        const toolNames = new Set();
-        if (result && typeof result === "object" && Array.isArray(result.messages)) {
-            for (const message of result.messages) {
-                const toolCalls = message.tool_calls;
-                if (!Array.isArray(toolCalls))
-                    continue;
-                for (const call of toolCalls) {
-                    const functionName = call.function?.name;
-                    if (typeof functionName === "string")
-                        toolNames.add(functionName);
-                }
-            }
-        }
-        if (toolNames.has("send_message") || toolNames.has("surface")) {
-            return { outcome: "surfaced", producedRefs: [{ kind: "surface", locator: "tool:send_message_or_surface" }] };
-        }
-        if (toolNames.has("diary_write") || toolNames.has("note")) {
-            return { outcome: "wrote_record", producedRefs: [{ kind: "desk_record", locator: "desk/_record" }] };
-        }
-        if ([...toolNames].some((name) => name.startsWith("mcp__desk__"))) {
-            return { outcome: "updated_desk", producedRefs: [{ kind: "desk_task", locator: "desk/" }] };
-        }
-        return { outcome: "no_change", producedRefs: [] };
-    }
-    function recordHabitCompletion(habitName, startedAt = new Date(nowSource()).toISOString(), endedAt = startedAt, trigger = "overdue", result, errors = []) {
-        try {
-            const agentRoot = (0, identity_1.getAgentRoot)();
-            (0, habit_runtime_state_1.recordHabitRun)(agentRoot, habitName, endedAt, {
-                definitionPath: path.join(agentRoot, "habits", `${habitName}.md`),
-            });
-            const { outcome, producedRefs } = habitOutcomeForTurn(result, errors);
-            (0, flight_recorder_1.writeHabitRunReceipt)(agentRoot, {
-                schemaVersion: 1,
-                runId: (0, flight_recorder_1.createHabitRunId)(habitName, new Date(startedAt)),
-                habitName,
-                trigger,
-                startedAt,
-                endedAt,
-                outcome,
-                producedRefs,
-                surfaceAttempts: [],
-                errors,
-            });
-        }
-        catch {
-            // Habit file/state may be unavailable during the turn — skip gracefully
-        }
+    function recordHabitCompletion(habitRun, endedAt = habitRun.startedAt) {
+        (0, habit_session_1.completeHabitRun)({
+            agentRoot: habitRun.agentRoot,
+            habit: habitRun.habit,
+            runId: habitRun.runId,
+            trigger: habitRun.trigger,
+            startedAt: habitRun.startedAt,
+            endedAt,
+            operationId: habitRun.operationId,
+            permissionEnvelope: habitRun.permissionEnvelope,
+            toolPolicy: habitRun.toolPolicy,
+            producedRefs: habitRun.producedRefs,
+            surfaceAttempts: habitRun.surfaceAttempts,
+            errors: habitRun.errors,
+            summarySnapshot: deriveHabitSummarySnapshot(habitRun),
+        });
     }
     function clearHeartbeatRestShield() {
         heartbeatOkRestedAt = null;
@@ -154,9 +290,11 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
         }
         return true;
     }
-    function reuseHeartbeatOkRest(habitName) {
+    async function reuseHeartbeatOkRest(habitName) {
         const nowIso = new Date(nowSource()).toISOString();
-        recordHabitCompletion(habitName, nowIso, nowIso, "overdue", { turnOutcome: "rested", restStatus: "HEARTBEAT_OK" });
+        const habitRun = await prepareHabitRun(habitName, "overdue", nowIso);
+        habitRun.results.push({ turnOutcome: "rested", restStatus: "HEARTBEAT_OK" });
+        recordHabitCompletion(habitRun, nowIso);
         (0, runtime_1.emitNervesEvent)({
             level: "info",
             component: "senses",
@@ -220,19 +358,61 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
             let nextHabitName = habitName;
             let nextAwaitName = awaitName;
             let nextTrigger = trigger;
+            let nextHabitRun = null;
             let consecutiveInstinctTurns = reason === "instinct" ? 1 : 0;
             runLoop: do {
                 const currentReason = nextReason;
                 const currentHabitName = nextHabitName;
                 const currentTrigger = nextTrigger ?? "overdue";
-                const habitStartedAt = currentReason === "habit" && currentHabitName ? new Date(nowSource()).toISOString() : null;
+                const currentHabitRun = currentReason === "habit" && currentHabitName
+                    ? nextHabitRun && nextHabitRun.habit.name === currentHabitName
+                        ? nextHabitRun
+                        : await prepareHabitRun(currentHabitName, currentTrigger, new Date(nowSource()).toISOString())
+                    : null;
+                nextHabitRun = null;
+                let currentHabitRunFinalized = false;
+                const finalizeCurrentHabitRun = () => {
+                    if (!currentHabitRun || currentHabitRunFinalized)
+                        return;
+                    recordHabitCompletion(currentHabitRun, new Date(nowSource()).toISOString());
+                    currentHabitRunFinalized = true;
+                };
                 const turnErrors = [];
                 if (!(currentReason === "habit" && currentHabitName === "heartbeat")) {
                     clearHeartbeatRestShield();
                 }
                 let turnResult;
                 try {
-                    turnResult = await runTurn({ reason: nextReason, taskId: nextTaskId, habitName: nextHabitName, awaitName: nextAwaitName });
+                    const turnOptions = {
+                        reason: nextReason,
+                        taskId: nextTaskId,
+                        habitName: nextHabitName,
+                        awaitName: nextAwaitName,
+                        ...(currentHabitRun
+                            ? {
+                                trigger: currentHabitRun.trigger,
+                                preparedHabit: {
+                                    runId: currentHabitRun.runId,
+                                    trigger: currentHabitRun.trigger,
+                                    operationId: currentHabitRun.operationId,
+                                    habit: currentHabitRun.habit,
+                                    priorSessionSummary: currentHabitRun.priorSessionSummary,
+                                },
+                                habitSession: {
+                                    runId: currentHabitRun.runId,
+                                    sessionPath: currentHabitRun.paths.sessionPath,
+                                    pendingDir: currentHabitRun.paths.pendingDir,
+                                    permissionEnvelope: currentHabitRun.permissionEnvelope,
+                                    toolPolicy: currentHabitRun.toolPolicy,
+                                    friendStore: currentHabitRun.friendStore,
+                                    recordProducedRef: (ref) => { currentHabitRun.producedRefs.push(ref); },
+                                    recordSurfaceAttempt: (attempt) => { currentHabitRun.surfaceAttempts.push(attempt); },
+                                    recordError: (error) => { currentHabitRun.errors.push(error); },
+                                },
+                            }
+                            : {}),
+                    };
+                    turnResult = await runTurn(turnOptions);
                 }
                 catch (error) {
                     clearHeartbeatRestShield();
@@ -251,21 +431,23 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                 if (currentReason === "habit" && currentHabitName === "heartbeat") {
                     heartbeatOkRestedAt = isHeartbeatOkRestResult(turnResult) ? nowSource() : null;
                 }
-                // Record lastRun after a habit turn without dirtying the tracked habit file.
-                if (currentReason === "habit" && currentHabitName && habitStartedAt) {
-                    recordHabitCompletion(currentHabitName, habitStartedAt, new Date(nowSource()).toISOString(), currentTrigger, turnResult, turnErrors);
+                if (currentHabitRun) {
+                    currentHabitRun.results.push(turnResult);
+                    currentHabitRun.errors.push(...turnErrors);
                 }
                 // Drain queue first. Externally-queued work resets the instinct cap
                 // because a real outside trigger arrived between turns.
                 while (queue.length > 0) {
                     const next = queue.shift();
                     if (next.reason === "habit" && next.habitName === "heartbeat" && shouldReuseHeartbeatOkRest(next.habitName)) {
-                        reuseHeartbeatOkRest(next.habitName);
+                        finalizeCurrentHabitRun();
+                        await reuseHeartbeatOkRest(next.habitName);
                         continue;
                     }
                     if (!(next.reason === "habit" && next.habitName === "heartbeat")) {
                         clearHeartbeatRestShield();
                     }
+                    finalizeCurrentHabitRun();
                     nextReason = next.reason;
                     nextTaskId = next.taskId;
                     nextHabitName = next.habitName;
@@ -278,7 +460,7 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                 // tool that writes to the inner-dialog pending dir during a turn
                 // would cause hasPendingWork() to be true here, producing a
                 // self-sustaining "instinct" loop with no external input. Cap it.
-                if (hasPendingWork()) {
+                if (hasPendingWork(currentHabitRun?.paths.pendingDir)) {
                     clearHeartbeatRestShield();
                     if (consecutiveInstinctTurns >= exports.MAX_CONSECUTIVE_INSTINCT_TURNS) {
                         (0, runtime_1.emitNervesEvent)({
@@ -292,16 +474,30 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                                 lastReason: nextReason,
                             },
                         });
+                        finalizeCurrentHabitRun();
                         break;
                     }
-                    consecutiveInstinctTurns += 1;
-                    nextReason = "instinct";
-                    nextTaskId = undefined;
-                    nextHabitName = undefined;
-                    nextAwaitName = undefined;
-                    nextTrigger = undefined;
+                    if (currentReason === "habit" && currentHabitName && currentHabitRun) {
+                        consecutiveInstinctTurns += 1;
+                        nextReason = "habit";
+                        nextTaskId = undefined;
+                        nextHabitName = currentHabitName;
+                        nextAwaitName = undefined;
+                        nextTrigger = currentTrigger;
+                        nextHabitRun = currentHabitRun;
+                    }
+                    else {
+                        finalizeCurrentHabitRun();
+                        consecutiveInstinctTurns += 1;
+                        nextReason = "instinct";
+                        nextTaskId = undefined;
+                        nextHabitName = undefined;
+                        nextAwaitName = undefined;
+                        nextTrigger = undefined;
+                    }
                     continue;
                 }
+                finalizeCurrentHabitRun();
                 break;
             } while (true);
         }
@@ -317,7 +513,7 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
             /* v8 ignore next -- defensive fallback: live habit dispatch always sets habitName @preserve */
             const habitName = maybeMessage.habitName ?? "(unnamed)";
             if (shouldReuseHeartbeatOkRest(habitName)) {
-                reuseHeartbeatOkRest(habitName);
+                await reuseHeartbeatOkRest(habitName);
                 return;
             }
             recordHabitFireForRecursion(habitName);
@@ -335,7 +531,7 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
         if (maybeMessage.type === "heartbeat") {
             // Backward compatibility: heartbeat -> habit/heartbeat
             if (shouldReuseHeartbeatOkRest("heartbeat")) {
-                reuseHeartbeatOkRest("heartbeat");
+                await reuseHeartbeatOkRest("heartbeat");
                 return;
             }
             recordHabitFireForRecursion("heartbeat");

package/dist/senses/inner-dialog.js

@@ -645,7 +645,7 @@ function buildHabitSurfacePolicy(origin, surface) {
 async function runInnerDialogTurn(options) {
     const now = options?.now ?? (() => new Date());
     const reason = options?.reason ?? "instinct";
-    const sessionFilePath = innerDialogSessionPath();
+    const sessionFilePath = options?.habitSession?.sessionPath ?? innerDialogSessionPath();
     const agentName = (0, identity_1.getAgentName)();
     writeInnerDialogRuntimeState(sessionFilePath, {
         status: "running",
@@ -661,7 +661,7 @@ async function runInnerDialogTurn(options) {
             resting: false,
             lastHeartbeatAt: now().toISOString(),
         };
-        const pendingDir = (0, pending_1.getInnerDialogPendingDir)(agentName);
+        const pendingDir = options?.habitSession?.pendingDir ?? (0, pending_1.getInnerDialogPendingDir)(agentName);
         const shouldUseHeldReturnWake = !options?.taskId && reason !== "habit" && reason !== "await"
             ? (0, obligations_1.listActiveReturnObligations)(agentName).length > 0
             : false;
@@ -669,7 +669,7 @@ async function runInnerDialogTurn(options) {
         let userContent;
         let habitTools;
         let habitParsedSuccessfully = false;
-        if (existingMessages.length === 0) {
+        if (existingMessages.length === 0 && !(reason === "habit" && options?.habitName)) {
             // Fresh session: bootstrap message with non-canonical cleanup nudge
             const aspirations = readAspirations((0, identity_1.getAgentRoot)());
             const nonCanonical = (0, bundle_manifest_1.findNonCanonicalBundlePaths)((0, identity_1.getAgentRoot)());
@@ -692,24 +692,35 @@ async function runInnerDialogTurn(options) {
                 const agentRoot = (0, identity_1.getAgentRoot)();
                 const habitName = options.habitName;
                 const habitFilePath = path.join(agentRoot, "habits", `${habitName}.md`);
+                const preparedHabit = options.preparedHabit?.habit.name === habitName ? options.preparedHabit.habit : null;
                 // Read and parse the habit file
                 let habitBody;
                 let habitTitle = habitName;
                 let habitLastRun = null;
                 let habitOrigin = null;
                 let habitSurface = { family: true, originator: true, extra: [] };
-                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;
-                    habitOrigin = parsed.origin;
-                    habitSurface = parsed.surface;
+                if (preparedHabit) {
+                    habitBody = preparedHabit.body || undefined;
+                    habitTitle = preparedHabit.title || habitName;
+                    habitLastRun = preparedHabit.lastRun;
+                    habitTools = preparedHabit.tools;
+                    habitOrigin = preparedHabit.origin;
+                    habitSurface = preparedHabit.surface;
                 }
-                catch {
-                    // Habit file missing or unreadable
+                else {
+                    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;
+                        habitOrigin = parsed.origin;
+                        habitSurface = parsed.surface;
+                    }
+                    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) {
@@ -753,6 +764,7 @@ async function runInnerDialogTurn(options) {
                         arcResume,
                         deskOrientation,
                         surfacePolicy,
+                        priorSessionSummary: options.preparedHabit?.habit.name === habitName ? options.preparedHabit.priorSessionSummary : undefined,
                         now,
                     });
                 }
@@ -875,7 +887,7 @@ async function runInnerDialogTurn(options) {
             runAgent: core_1.runAgent,
             postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
                 const prepared = (0, context_1.postTurnTrim)(turnMessages, usage, hooks);
-                (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
+                return (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
             },
             accumulateFriendTokens: tokens_1.accumulateFriendTokens,
             signal: options?.signal,
@@ -917,7 +929,9 @@ async function runInnerDialogTurn(options) {
                 toolContext: {
                     signin: async () => undefined,
                     delegatedOrigins: attentionQueue,
+                    ...(options?.habitSession ? { habitSession: options.habitSession } : {}),
                 },
+                ...(options?.habitSession ? { habitSession: options.habitSession } : {}),
             },
         });
         // Post-turn routeDelegatedCompletion removed: delivery is now inline via surface tool.

package/dist/senses/pipeline.js

@@ -48,7 +48,6 @@ const continuity_1 = require("./continuity");
 const manager_1 = require("../heart/bridges/manager");
 const identity_1 = require("../heart/identity");
 const auth_flow_1 = require("../heart/auth/auth-flow");
-const socket_client_1 = require("../heart/daemon/socket-client");
 const active_work_1 = require("../heart/active-work");
 const delegation_1 = require("../heart/delegation");
 const obligations_1 = require("../arc/obligations");
@@ -828,7 +827,7 @@ async function handleInboundTurn(input) {
                 /* v8 ignore next -- defensive: error always set when errored @preserve */
                 result.error?.message ?? "unknown error", classification, currentProvider, currentBinding.model, agentName, inventory, {}, { currentLane });
                 input.failoverState.pending = failoverContext;
-                input.postTurn(sessionMessages, session.sessionPath, result.usage);
+                await input.postTurn(sessionMessages, session.sessionPath, result.usage);
                 try {
                     const agentRoot = (0, identity_1.getAgentRoot)();
                     const postTurnArc = readPostTurnFlightRecorderArcSnapshot(agentRoot);
@@ -903,7 +902,7 @@ async function handleInboundTurn(input) {
                 ? { lastFriendActivityAt }
                 : undefined)
             : (Object.keys(continuingState).length > 0 ? continuingState : undefined);
-        input.postTurn(sessionMessages, session.sessionPath, result.usage, undefined, nextState);
+        await input.postTurn(sessionMessages, session.sessionPath, result.usage, undefined, nextState);
         try {
             const agentRoot = (0, identity_1.getAgentRoot)();
             const postTurnArc = readPostTurnFlightRecorderArcSnapshot(agentRoot);
@@ -949,14 +948,6 @@ async function handleInboundTurn(input) {
                 friendId: resolvedContext.friend.id,
             },
         });
-        // DRY cross-session awareness: notify inner dialog that activity happened on another channel
-        // Inner dialog's next checkpoint will include this session's state
-        if (input.channel !== "inner") {
-            try {
-                (0, socket_client_1.requestInnerWake)((0, identity_1.getAgentName)(), existingToolContext?.daemonSocketPath).catch(/* v8 ignore next */ () => { });
-            }
-            catch { /* getAgentName may fail in test environments */ }
-        }
         return {
             resolvedContext,
             gateResult,

package/dist/senses/surface-tool.js

@@ -4,7 +4,7 @@ exports.handleSurface = handleSurface;
 const attention_queue_1 = require("./attention-queue");
 const runtime_1 = require("../nerves/runtime");
 async function handleSurface(input) {
-    const { content, delegationId, friendId, deliveryHint, queue, routeToFriend, advanceObligation, completePonderPacket, fulfillHeartObligation, } = input;
+    const { content, delegationId, friendId, deliveryHint, queue, routeToFriend, advanceObligation, completePonderPacket, fulfillHeartObligation, onRouteResult, } = input;
     // Resolve target friend
     let targetFriendId;
     let queueItem;
@@ -68,6 +68,7 @@ async function handleSurface(input) {
             ...(result.detail ? { detail: result.detail } : {}),
         },
     });
+    onRouteResult?.({ targetFriendId, queueItem, result });
     // On successful routing with delegationId:
     // 1. Advance obligation to "returned" (disk FIRST — crash safety)
     // 2. Dequeue from process-local queue (AFTER obligation advance)

package/package.json

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