@ouro.bot/cli 0.1.0-alpha.724 → 0.1.0-alpha.725

package/dist/senses/cli/tui-store.js

@@ -224,6 +224,7 @@ function createTuiCallbacks(store) {
         meta: {},
     });
     return {
+        settleOutputMode: "retractable_buffer",
         onModelStart: () => { store.modelStart(); },
         onModelStreamStart: () => { },
         onClearText: () => { store.clearText(); },

package/dist/senses/cli.js

@@ -311,6 +311,7 @@ function createCliCallbacks() {
     const streamer = new MarkdownStreamer();
     const wrapper = new cli_layout_1.StreamingWordWrapper();
     return {
+        settleOutputMode: "final_only",
         onModelStart: () => {
             currentSpinner?.stop();
             setSpinner(null);

package/dist/senses/habit-lifecycle-guard.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.privateRuntimeHabitRejectionReason = privateRuntimeHabitRejectionReason;
+const runtime_1 = require("../nerves/runtime");
+function privateRuntimeHabitRejectionReason(habit, boundary) {
+    if (habit.status === "active")
+        return null;
+    const reason = `habit status ${habit.status} is non-executable before private runtime execution`;
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.habit_lifecycle_rejected",
+        message: "habit lifecycle state rejected before private runtime execution",
+        meta: {
+            boundary,
+            habitName: habit.name,
+            status: habit.status,
+            degradedReason: habit.status === "degraded" ? habit.degradedReason : null,
+            detail: habit.status === "degraded" ? habit.degradedDetail : null,
+            reason,
+        },
+    });
+    return reason;
+}

package/dist/senses/ingress-evidence.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/senses/pipeline.js

@@ -39,6 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitObligationTransitionEpisodes = emitObligationTransitionEpisodes;
+exports.selectCheckpointCurrentAsk = selectCheckpointCurrentAsk;
 exports.handleInboundTurn = handleInboundTurn;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -203,6 +204,16 @@ function latestUserAuthoredText(messages, continuityIngressTexts) {
         .filter(Boolean);
     return userMessages[userMessages.length - 1];
 }
+function selectCheckpointCurrentAsk(input) {
+    const frameSpeech = input.orientationFrame?.currentUserSpeech
+        .map((speech) => speech.trim())
+        .filter(Boolean)
+        .at(-1) ?? null;
+    if (input.orientationFrame?.speechKind === "reaction")
+        return frameSpeech;
+    const currentUtterance = input.currentUserMessage?.trim();
+    return currentUtterance || frameSpeech;
+}
 function sessionRefForFlightRecorder(session) {
     return `${session.friendId}/${session.channel}/${session.key}`;
 }
@@ -212,6 +223,22 @@ function isTerminalWithoutContinuation(outcome, hasActiveContinuation) {
         || outcome === "rested"
         || outcome === "superseded");
 }
+function selectPostTurnContinuityState(input) {
+    const continuingState = {
+        ...(input.mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
+        ...(typeof input.lastFriendActivityAt === "string" ? { lastFriendActivityAt: input.lastFriendActivityAt } : {}),
+    };
+    const clearsMustResolveBeforeHandoff = input.outcome === "settled"
+        || input.outcome === "blocked"
+        || input.outcome === "superseded"
+        || input.outcome === "observed";
+    if (!clearsMustResolveBeforeHandoff) {
+        return Object.keys(continuingState).length > 0 ? continuingState : undefined;
+    }
+    return typeof input.lastFriendActivityAt === "string"
+        ? { lastFriendActivityAt: input.lastFriendActivityAt }
+        : undefined;
+}
 function readPostTurnFlightRecorderArcSnapshot(agentRoot) {
     const latest = (0, flight_recorder_1.readFlightRecorderResume)(agentRoot);
     return {
@@ -223,7 +250,7 @@ function readPostTurnFlightRecorderArcSnapshot(agentRoot) {
         unverifiedClaimIds: latest.unverifiedClaimIds,
     };
 }
-function recordPostTurnFlightRecorderCheckpoint(input) {
+function recordTurnFlightRecorderCheckpoint(input) {
     const hasActiveContinuation = input.mustResolveBeforeHandoff
         || input.activeObligationIds.length > 0
         || input.activeReturnObligationIds.length > 0
@@ -240,9 +267,11 @@ function recordPostTurnFlightRecorderCheckpoint(input) {
             ? "inspect the latest session and wait for new input before acting"
             : "continue the current held work and update Arc/Desk with the next checkpoint");
     (0, flight_recorder_1.recordFlightRecorderEvent)(input.agentRoot, {
-        kind: "post_turn_persisted",
+        kind: input.sessionPersisted ? "post_turn_persisted" : "blocker_detected",
         sessionRef: sessionRefForFlightRecorder(input.currentSession),
-        summary: `persisted ${input.currentSession.channel}/${input.currentSession.key} turn with outcome ${input.outcome}`,
+        summary: input.sessionPersisted
+            ? `persisted ${input.currentSession.channel}/${input.currentSession.key} turn with outcome ${input.outcome}`
+            : `runAgent threw before session persistence for ${input.currentSession.channel}/${input.currentSession.key}`,
         currentAsk: input.currentAsk,
         nextSafeAction,
         blockedBecause,
@@ -255,6 +284,7 @@ function recordPostTurnFlightRecorderCheckpoint(input) {
         unverifiedClaimIds: input.unverifiedClaimIds,
         meta: {
             outcome: input.outcome,
+            sessionPersisted: input.sessionPersisted,
             mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
             sessionPath: input.currentSession.sessionPath,
         },
@@ -447,6 +477,9 @@ function prepareInboundRunLedger(input) {
     }
 }
 async function handleInboundTurn(input) {
+    // Continuity resumption is structured caller intent. Never infer it from the
+    // current message or from similarity to prior obligations.
+    const resumePriorWork = input.runAgentOptions?.resumePriorWork === true;
     // Reset session-scoped state when the session changes
     const sessionKey = `${input.channel}/${input.sessionKey ?? "session"}`;
     if (sessionKey !== _lastSessionKey) {
@@ -826,7 +859,7 @@ async function handleInboundTurn(input) {
             if (capabilities) {
                 startOfTurnPacket.capabilities = capabilities;
             }
-            renderedStartOfTurnPacket = (0, start_of_turn_packet_1.renderStartOfTurnPacket)(startOfTurnPacket);
+            renderedStartOfTurnPacket = (0, start_of_turn_packet_1.renderStartOfTurnPacket)(startOfTurnPacket, { resumePriorWork });
             if (!renderedStartOfTurnPacket)
                 renderedStartOfTurnPacket = undefined;
             // Update self-presence
@@ -854,6 +887,7 @@ async function handleInboundTurn(input) {
             ?? latestUserAuthoredText(input.messages, input.continuityIngressTexts);
         let runAgentOptions = {
             ...input.runAgentOptions,
+            resumePriorWork,
             ...(orientationFrame ? { orientationFrame } : {}),
             ...(liveLatencyMode ? { skipKeptNotes: true } : {}),
             bridgeContext,
@@ -892,6 +926,10 @@ async function handleInboundTurn(input) {
             resolvedContext,
             runAgentOptions,
         }));
+        const checkpointCurrentAsk = selectCheckpointCurrentAsk({
+            currentUserMessage: runAgentOptions.toolContext?.currentUserMessage ?? currentUserMessage,
+            orientationFrame: runAgentOptions.orientationFrame,
+        });
         const runLedger = prepareInboundRunLedger({
             channel: input.channel,
             senseType: input.capabilities.senseType,
@@ -920,6 +958,37 @@ async function handleInboundTurn(input) {
                     usage: (0, run_ledger_1.usageMetadataFromUsageData)(undefined, "reported-unavailable"),
                     errorName: error instanceof Error ? error.name : "NonErrorThrown",
                 }));
+            try {
+                const agentRoot = (0, identity_1.getAgentRoot)();
+                const postTurnArc = readPostTurnFlightRecorderArcSnapshot(agentRoot);
+                recordTurnFlightRecorderCheckpoint({
+                    agentRoot,
+                    currentSession,
+                    currentAsk: checkpointCurrentAsk,
+                    nextSafeAction: activeWorkFrame.resumeHandle?.nextAction
+                        ?? activeWorkFrame.primaryObligation?.nextAction?.trim()
+                        ?? null,
+                    outcome: "errored",
+                    sessionPersisted: false,
+                    mustResolveBeforeHandoff,
+                    activeObligationIds: postTurnArc.activeObligationIds,
+                    activeReturnObligationIds: postTurnArc.activeReturnObligationIds,
+                    activePacketIds: postTurnArc.activePacketIds,
+                    openEvolutionCaseIds: postTurnArc.openEvolutionCaseIds,
+                    recentClaimIds: postTurnArc.recentClaimIds,
+                    unverifiedClaimIds: postTurnArc.unverifiedClaimIds,
+                });
+                await refreshContextLossSentinelNonFatal({ agentName: (0, identity_1.getAgentName)(), agentRoot, trigger: "post_turn" });
+            }
+            catch (checkpointError) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.flight_recorder_checkpoint_error",
+                    message: "failed to record thrown-turn flight recorder checkpoint",
+                    meta: { error: checkpointError instanceof Error ? checkpointError.message : String(checkpointError) },
+                });
+            }
             throw error;
         }
         const runLedgerLifecycle = result.outcome === "errored" ? "error" : "completed";
@@ -946,19 +1015,22 @@ 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;
-                await input.postTurn(sessionMessages, session.sessionPath, result.usage);
+                const failoverNextState = selectPostTurnContinuityState({
+                    outcome: "errored",
+                    mustResolveBeforeHandoff,
+                    lastFriendActivityAt,
+                });
+                await input.postTurn(sessionMessages, session.sessionPath, result.usage, undefined, failoverNextState);
                 try {
                     const agentRoot = (0, identity_1.getAgentRoot)();
                     const postTurnArc = readPostTurnFlightRecorderArcSnapshot(agentRoot);
-                    recordPostTurnFlightRecorderCheckpoint({
+                    recordTurnFlightRecorderCheckpoint({
                         agentRoot,
                         currentSession,
-                        currentAsk: currentObligation
-                            ?? activeWorkFrame.primaryObligation?.content?.trim()
-                            ?? currentUserMessage
-                            ?? null,
+                        currentAsk: checkpointCurrentAsk,
                         nextSafeAction: failoverContext.userMessage,
                         outcome: "errored",
+                        sessionPersisted: true,
                         mustResolveBeforeHandoff,
                         activeObligationIds: postTurnArc.activeObligationIds,
                         activeReturnObligationIds: postTurnArc.activeReturnObligationIds,
@@ -1012,30 +1084,24 @@ async function handleInboundTurn(input) {
             // Episode emission is non-fatal
         }
         // Step 6: postTurn
-        const continuingState = {
-            ...(mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
-            ...(typeof lastFriendActivityAt === "string" ? { lastFriendActivityAt } : {}),
-        };
-        const nextState = result.outcome === "settled" || result.outcome === "blocked" || result.outcome === "superseded" || result.outcome === "observed"
-            ? (typeof lastFriendActivityAt === "string"
-                ? { lastFriendActivityAt }
-                : undefined)
-            : (Object.keys(continuingState).length > 0 ? continuingState : undefined);
+        const nextState = selectPostTurnContinuityState({
+            outcome: result.outcome,
+            mustResolveBeforeHandoff,
+            lastFriendActivityAt,
+        });
         await input.postTurn(sessionMessages, session.sessionPath, result.usage, undefined, nextState);
         try {
             const agentRoot = (0, identity_1.getAgentRoot)();
             const postTurnArc = readPostTurnFlightRecorderArcSnapshot(agentRoot);
-            recordPostTurnFlightRecorderCheckpoint({
+            recordTurnFlightRecorderCheckpoint({
                 agentRoot,
                 currentSession,
-                currentAsk: currentObligation
-                    ?? activeWorkFrame.primaryObligation?.content?.trim()
-                    ?? currentUserMessage
-                    ?? null,
+                currentAsk: checkpointCurrentAsk,
                 nextSafeAction: activeWorkFrame.resumeHandle?.nextAction
                     ?? activeWorkFrame.primaryObligation?.nextAction?.trim()
                     ?? null,
                 outcome: result.outcome ?? "observed",
+                sessionPersisted: true,
                 mustResolveBeforeHandoff,
                 activeObligationIds: postTurnArc.activeObligationIds,
                 activeReturnObligationIds: postTurnArc.activeReturnObligationIds,

package/dist/senses/private-runtime-worker.js

@@ -55,6 +55,7 @@ const habit_policy_1 = require("../rsvp/habit-policy");
 const spend_ledger_1 = require("../rsvp/spend-ledger");
 const run_ledger_1 = require("../heart/run-ledger");
 const autonomy_budget_1 = require("../heart/autonomy-budget");
+const habit_lifecycle_guard_1 = require("./habit-lifecycle-guard");
 function isUsageData(value) {
     const usage = value;
     return !!usage
@@ -275,21 +276,6 @@ function deriveHabitSummarySnapshot(habitRun) {
         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 {
@@ -305,16 +291,20 @@ function readHabitForRun(agentRoot, habitName, errors) {
             message: "habit file could not be read for habit session",
             meta: { habitName, habitPath, reason },
         });
-        return fallbackHabitFile(habitName);
+        return (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error");
     }
 }
 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));
+    if (habit.status === "degraded" && habit.degradedDetail !== null) {
+        errors.push(habit.degradedDetail);
+    }
+    const lifecycleBlockedReason = (0, habit_lifecycle_guard_1.privateRuntimeHabitRejectionReason)(habit, "private-runtime-worker");
     const blockedReason = (0, habit_policy_1.isRsvpHabitName)(habitName) && !habit.rsvp
         ? "RSVP habit metadata is required before private runtime execution"
-        : null;
+        : lifecycleBlockedReason;
     if (blockedReason && !errors.includes(blockedReason))
         errors.push(blockedReason);
     const runId = (0, flight_recorder_1.createHabitRunId)(habitName, new Date(startedAt));
@@ -422,6 +412,11 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
     async function reuseHeartbeatOkRest(habitName) {
         const nowIso = new Date(nowSource()).toISOString();
         const habitRun = await prepareHabitRun(habitName, "overdue", nowIso);
+        if (habitRun.blockedReason) {
+            clearHeartbeatRestShield();
+            recordHabitCompletion(habitRun, nowIso);
+            return;
+        }
         habitRun.results.push({ turnOutcome: "rested", restStatus: "HEARTBEAT_OK" });
         recordHabitCompletion(habitRun, nowIso);
         (0, runtime_1.emitNervesEvent)({
@@ -475,9 +470,9 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
             });
         }
     }
-    async function run(reason, taskId, habitName, awaitName, trigger, privateTurnDecision) {
+    async function run(reason, taskId, habitName, awaitName, trigger, privateTurnDecision, noSend) {
         if (running) {
-            queue.push({ reason, taskId, habitName, awaitName, trigger, privateTurnDecision });
+            queue.push({ reason, taskId, habitName, awaitName, trigger, privateTurnDecision, noSend });
             return;
         }
         running = true;
@@ -488,12 +483,14 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
             let nextAwaitName = awaitName;
             let nextTrigger = trigger;
             let nextPrivateTurnDecision = privateTurnDecision;
+            let nextNoSend = reason === "habit" ? noSend : undefined;
             let nextHabitRun = null;
             let consecutiveInstinctTurns = reason === "instinct" ? 1 : 0;
             runLoop: do {
                 const currentReason = nextReason;
                 const currentHabitName = nextHabitName;
                 const currentTrigger = nextTrigger ?? "overdue";
+                const currentNoSend = nextNoSend;
                 const currentHabitRun = currentReason === "habit" && currentHabitName
                     ? nextHabitRun && nextHabitRun.habit.name === currentHabitName
                         ? nextHabitRun
@@ -545,6 +542,7 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                             taskId: nextTaskId,
                             habitName: nextHabitName,
                             awaitName: nextAwaitName,
+                            ...(currentNoSend ? { noSend: true } : {}),
                             ...(nextPrivateTurnDecision ? { privateTurnDecision: nextPrivateTurnDecision } : {}),
                             ...(currentHabitRun
                                 ? {
@@ -614,6 +612,7 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                     nextAwaitName = next.awaitName;
                     nextTrigger = next.trigger;
                     nextPrivateTurnDecision = next.privateTurnDecision;
+                    nextNoSend = next.reason === "habit" ? next.noSend : undefined;
                     consecutiveInstinctTurns = nextReason === "instinct" ? consecutiveInstinctTurns + 1 : 0;
                     continue runLoop;
                 }
@@ -650,6 +649,7 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                         nextAwaitName = undefined;
                         nextTrigger = currentTrigger;
                         nextPrivateTurnDecision = undefined;
+                        nextNoSend = currentNoSend;
                         nextHabitRun = currentHabitRun;
                     }
                     else {
@@ -661,6 +661,7 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                         nextAwaitName = undefined;
                         nextTrigger = undefined;
                         nextPrivateTurnDecision = undefined;
+                        nextNoSend = undefined;
                     }
                     continue;
                 }
@@ -684,7 +685,7 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                 return;
             }
             recordHabitFireForRecursion(habitName);
-            await run("habit", undefined, maybeMessage.habitName, undefined, maybeMessage.trigger ?? "overdue", maybeMessage.privateTurnDecision);
+            await run("habit", undefined, maybeMessage.habitName, undefined, maybeMessage.trigger ?? "overdue", maybeMessage.privateTurnDecision, maybeMessage.noSend);
             return;
         }
         if (maybeMessage.type === "await") {

package/dist/senses/private-runtime.js

@@ -76,6 +76,7 @@ const await_parser_1 = require("../heart/awaiting/await-parser");
 const await_runtime_state_1 = require("../heart/awaiting/await-runtime-state");
 const habit_parser_1 = require("../heart/habits/habit-parser");
 const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
+const habit_lifecycle_guard_1 = require("./habit-lifecycle-guard");
 const cadence_1 = require("../heart/daemon/cadence");
 const habit_policy_1 = require("../rsvp/habit-policy");
 const daemon_health_1 = require("../heart/daemon/daemon-health");
@@ -344,6 +345,14 @@ function assertPayloadBinding(decision, kind, id) {
         return;
     throw new Error(`private-runtime decision payload mismatch: missing ${kind} origin ref ${id}`);
 }
+function assertNoSendBinding(decision, noSend) {
+    const refs = decision.originRefs.filter((ref) => ref.kind === "capability" && ref.id === "no-send");
+    if (noSend === true && refs.length === 1)
+        return;
+    if (noSend === undefined && refs.length === 0)
+        return;
+    throw new Error("private-runtime decision payload mismatch: no-send capability binding does not match the turn");
+}
 function ledgerDecisionFor(decision) {
     const ledgerPath = decision.ledgerLocator?.path;
     if (!ledgerPath) {
@@ -389,6 +398,7 @@ function assertPrivateTurnDecisionAllowed(input) {
     assertPayloadBinding(decision, "task", options?.taskId);
     assertPayloadBinding(decision, "habit", options?.habitName);
     assertPayloadBinding(decision, "await", options?.awaitName);
+    assertNoSendBinding(decision, options?.noSend);
     const ledgerRow = ledgerDecisionFor(decision);
     const decidedAtMs = Date.parse(ledgerRow.decidedAt);
     if (!Number.isFinite(decidedAtMs)) {
@@ -489,6 +499,7 @@ function extractToolCallNames(messages) {
 }
 function createPrivateRuntimeCallbacks() {
     return {
+        settleOutputMode: "final_only",
         onModelStart: () => { },
         onModelStreamStart: () => { },
         onTextChunk: () => { },
@@ -795,6 +806,32 @@ function buildHabitSurfacePolicy(origin, surface) {
     lines.push("- use send_message for intentional contact; use surface only for a held return tied to an existing return obligation.");
     return lines.join("\n");
 }
+function reduceHabitSessionToNoSend(habitSession) {
+    const deniedTools = new Set([
+        ...(habitSession?.permissionEnvelope.deniedTools ?? []),
+        ...(habitSession?.toolPolicy.grantedTools ?? []),
+        ...(habitSession?.toolPolicy.deniedTools ?? []),
+        "send_message",
+        "surface",
+    ]);
+    return {
+        ...habitSession,
+        noSend: true,
+        permissionEnvelope: {
+            schemaVersion: 1,
+            canMessageOutward: false,
+            returnRoutes: [],
+            deniedTools: [...deniedTools],
+            warnings: [...(habitSession?.permissionEnvelope.warnings ?? [])],
+        },
+        toolPolicy: {
+            requestedTools: habitSession?.toolPolicy.requestedTools ?? null,
+            grantedTools: [],
+            deniedTools: [...deniedTools],
+            outwardMessagingAllowed: false,
+        },
+    };
+}
 async function runPrivateRuntimeTurn(options) {
     const now = options?.now ?? (() => new Date());
     const reason = options?.reason ?? "instinct";
@@ -873,37 +910,43 @@ async function runPrivateRuntimeTurn(options) {
                 let habitSurface = { family: true, originator: true, extra: [] };
                 if (preparedHabit) {
                     if (rsvpHabit && !preparedHabit.rsvp) {
-                        throw new Error(`RSVP habit metadata is required before private runtime execution: ${habitName}`);
+                        const detail = preparedHabit.status === "degraded"
+                            ? preparedHabit.degradedDetail
+                            : null;
+                        throw new Error(`RSVP habit metadata is required before private runtime execution: ${detail ?? habitName}`);
                     }
-                    habitBody = preparedHabit.body || undefined;
-                    habitTitle = preparedHabit.title || habitName;
-                    habitLastRun = preparedHabit.lastRun;
-                    habitTools = preparedHabit.tools;
-                    habitOrigin = preparedHabit.origin;
-                    habitSurface = preparedHabit.surface;
+                    const blockedReason = (0, habit_lifecycle_guard_1.privateRuntimeHabitRejectionReason)(preparedHabit, "private-runtime");
+                    if (blockedReason)
+                        throw new Error(blockedReason);
                 }
-                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));
-                        if (rsvpHabit && !parsed.rsvp) {
-                            throw new Error(`RSVP habit metadata is required before private runtime execution: ${habitName}`);
-                        }
-                        habitBody = parsed.body || undefined;
-                        habitTitle = parsed.title || habitName;
-                        habitLastRun = parsed.lastRun;
-                        habitTools = parsed.tools;
-                        habitOrigin = parsed.origin;
-                        habitSurface = parsed.surface;
-                    }
-                    catch (error) {
-                        if (rsvpHabit) {
-                            const reason = error instanceof Error ? error.message : String(error);
-                            throw new Error(`RSVP habit metadata is required before private runtime execution: ${reason}`);
-                        }
-                        // Habit file missing or unreadable
+                let currentHabit;
+                try {
+                    const habitContent = fs.readFileSync(habitFilePath, "utf-8");
+                    currentHabit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(habitContent, habitFilePath));
+                }
+                catch (error) {
+                    const readReason = error instanceof Error ? error.message : String(error);
+                    if (rsvpHabit) {
+                        throw new Error(`RSVP habit metadata is required before private runtime execution: ${readReason}`);
                     }
+                    const degraded = (0, habit_parser_1.createDegradedHabitFile)(habitFilePath, "read_error", "", readReason);
+                    const blockedReason = (0, habit_lifecycle_guard_1.privateRuntimeHabitRejectionReason)(degraded, "private-runtime");
+                    throw new Error(blockedReason);
+                }
+                if (rsvpHabit && !currentHabit.rsvp) {
+                    const detail = currentHabit.status === "degraded" ? currentHabit.degradedDetail : null;
+                    throw new Error(`RSVP habit metadata is required before private runtime execution: ${detail ?? habitName}`);
                 }
+                const currentBlockedReason = (0, habit_lifecycle_guard_1.privateRuntimeHabitRejectionReason)(currentHabit, "private-runtime");
+                if (currentBlockedReason)
+                    throw new Error(currentBlockedReason);
+                const executableHabit = preparedHabit ?? currentHabit;
+                habitBody = executableHabit.body || undefined;
+                habitTitle = executableHabit.title || habitName;
+                habitLastRun = executableHabit.lastRun;
+                habitTools = executableHabit.tools;
+                habitOrigin = executableHabit.origin;
+                habitSurface = executableHabit.surface;
                 // 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.`;
@@ -1027,6 +1070,12 @@ async function runPrivateRuntimeTurn(options) {
                 meta: { habitName: options.habitName },
             });
         }
+        if (options?.noSend === true) {
+            habitToolsResolved = [];
+        }
+        const effectiveHabitSession = options?.noSend === true
+            ? reduceHabitSessionToNoSend(options.habitSession)
+            : options?.habitSession;
         const sessionLoader = {
             loadOrCreate: async () => {
                 if (existingMessages.length > 0) {
@@ -1111,9 +1160,10 @@ async function runPrivateRuntimeTurn(options) {
                 toolContext: {
                     signin: async () => undefined,
                     delegatedOrigins: attentionQueue,
-                    ...(options?.habitSession ? { habitSession: options.habitSession } : {}),
+                    ...(options?.noSend ? { noSend: true } : {}),
+                    ...(effectiveHabitSession ? { habitSession: effectiveHabitSession } : {}),
                 },
-                ...(options?.habitSession ? { habitSession: options.habitSession } : {}),
+                ...(effectiveHabitSession ? { habitSession: effectiveHabitSession } : {}),
             },
         });
         // Post-turn routeDelegatedCompletion removed: delivery is now inline via surface tool.

package/dist/senses/shared-turn.js

@@ -288,6 +288,7 @@ async function runSenseTurn(options) {
     };
     /* v8 ignore start — no-op callback stubs; only onTextChunk does real work (covered via mock) */
     const callbacks = {
+        settleOutputMode: "retractable_buffer",
         onModelStart: () => { },
         onModelStreamStart: () => { },
         onTextChunk: (chunk) => { pendingResponseText += chunk; },

package/dist/senses/teams.js

@@ -409,6 +409,7 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         }
     }
     return {
+        settleOutputMode: "final_only",
         onModelStart: () => {
             if (hadRealOutput)
                 return; // real output already shown; don't overwrite with phrases

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.724",
+  "version": "0.1.0-alpha.725",
+  "engines": {
+    "node": ">=22"
+  },
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",
@@ -61,6 +64,7 @@
     "@ouro.bot/friends": "0.1.0-alpha.7",
     "@types/react": "^17.0.91",
     "@types/ws": "^8.18.1",
+    "better-sqlite3": "13.0.2",
     "fast-glob": "^3.3.3",
     "ink": "^3.2.0",
     "mailparser": "^3.9.8",
@@ -77,6 +81,7 @@
   },
   "devDependencies": {
     "@testing-library/react": "^16.3.2",
+    "@types/better-sqlite3": "7.6.13",
     "@types/mailparser": "^3.4.6",
     "@types/semver": "^7.7.1",
     "@types/smtp-server": "^3.5.13",