@ouro.bot/cli 0.1.0-alpha.723 → 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/mail.js

@@ -50,6 +50,125 @@ const smtp_ingress_1 = require("../mailroom/smtp-ingress");
 function readRegistry(registryPath) {
     return JSON.parse(fs.readFileSync(registryPath, "utf-8"));
 }
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function unverifiableCoverage(checkedAt, reason) {
+    return { status: "could-not-verify", declaredKeyIds: [], absentKeyIds: [], reason, checkedAt };
+}
+/**
+ * Key ids the registry says mail can currently be encrypted to for this agent.
+ *
+ * Filtered to this agent because the hosted registry is domain-wide: counting
+ * every agent's records would report another agent's keys as absent on every
+ * cycle, and a check that always fails is a check operators learn to ignore.
+ *
+ * The match is case-insensitive. The harness sends `agentId: agent` verbatim to
+ * hosted Mail Control while this repo's own hosted ensure-response fixture
+ * returns the lowercased form for that same request, so a registry record's
+ * agent id can differ from the sense's agent name by case alone. Case-sensitive
+ * matching would then declare nothing and report `could-not-verify` forever —
+ * the same silence this probe exists to end. Widening the match cannot produce
+ * a false `absent` unless two agents differ only by case, which the store and
+ * address resolvers could not tell apart either.
+ *
+ * Disabled source grants are excluded because `resolveMailAddress`
+ * (`mailroom/core.ts`) refuses their alias outright, so no new mail can be
+ * encrypted to their key and a missing private half is not a live gap.
+ */
+function registryDeclaredKeyIds(registry, agentName) {
+    const wanted = agentName.toLowerCase();
+    const isThisAgent = (agentId) => agentId.toLowerCase() === wanted;
+    const declared = [
+        ...registry.mailboxes.filter((mailbox) => isThisAgent(mailbox.agentId)).map((mailbox) => mailbox.keyId),
+        ...registry.sourceGrants.filter((grant) => isThisAgent(grant.agentId) && grant.enabled).map((grant) => grant.keyId),
+    ];
+    return [...new Set(declared.filter((keyId) => keyId.trim().length > 0))];
+}
+/**
+ * Mail key ids the vault can actually decrypt with, read fresh rather than
+ * taken from the reader resolution captured at sense startup — a sense that has
+ * been up for days would otherwise measure a key set the vault has since
+ * changed, and report a rotation as a loss.
+ *
+ * Throws rather than returning empty when the read is untrustworthy, so the
+ * caller classifies it `could-not-verify` instead of `absent`. An empty-but-
+ * present `privateKeys` record is a real observation and is not a throw.
+ */
+function vaultMailKeyIds(agentName) {
+    const runtime = (0, runtime_credentials_1.readRuntimeCredentialConfig)(agentName);
+    if (!runtime.ok)
+        throw new Error(`vault ${runtime.itemPath} read is ${runtime.reason}`);
+    const mailroom = runtime.config.mailroom;
+    const privateKeys = isRecord(mailroom) ? mailroom.privateKeys : undefined;
+    if (!isRecord(privateKeys))
+        throw new Error(`vault ${runtime.itemPath} has no mailroom.privateKeys record`);
+    return Object.entries(privateKeys)
+        .filter((entry) => typeof entry[1] === "string" && entry[1].trim().length > 0)
+        .map((entry) => entry[0]);
+}
+/**
+ * Never throws: every failure degrades to `could-not-verify`. `scan()` is
+ * awaited during sense startup, so a throw here would stop the mail sense from
+ * starting — an integrity probe must not be able to take mail down.
+ */
+async function computeMailKeyCoverage(input) {
+    try {
+        const registry = await input.readRegistry(input.config);
+        const declaredKeyIds = registryDeclaredKeyIds(registry, input.agentName);
+        if (declaredKeyIds.length === 0) {
+            // Nothing to check against is not the same as nothing wrong: reporting
+            // `covered` for an empty declaration would turn an unprovisioned or
+            // wrong registry into a green light.
+            return unverifiableCoverage(input.checkedAt, `mailroom registry declares no mail keys for ${input.agentName}`);
+        }
+        const present = new Set(vaultMailKeyIds(input.agentName));
+        const absentKeyIds = declaredKeyIds.filter((keyId) => !present.has(keyId));
+        return {
+            status: absentKeyIds.length === 0 ? "covered" : "absent",
+            declaredKeyIds,
+            absentKeyIds,
+            reason: null,
+            checkedAt: input.checkedAt,
+        };
+    }
+    catch (error) {
+        return unverifiableCoverage(input.checkedAt, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Coverage has to push, not wait to be asked. `ouro doctor` is on-demand — it
+ * has no scheduled invocation — so a doctor line alone leaves a gap invisible
+ * until someone happens to run it, which is how `mail_slugger-hey_6e7b4bfa34c0b826`
+ * stayed unnoticed for 23 hours while mail encrypted to it piled up unreadable.
+ */
+function emitMailKeyCoverageEvents(agentName, coverage) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_key_coverage_recorded",
+        message: "mail key coverage recorded",
+        meta: {
+            agentName,
+            status: coverage.status,
+            declaredCount: coverage.declaredKeyIds.length,
+            absentCount: coverage.absentKeyIds.length,
+            reason: coverage.reason,
+        },
+    });
+    if (coverage.status !== "absent")
+        return;
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "senses",
+        event: "senses.mail_key_coverage_absent",
+        message: `mailroom registry declares mail keys with no private half in ${agentName}'s vault: ${coverage.absentKeyIds.join(", ")}`,
+        meta: {
+            agentName,
+            absentKeyIds: coverage.absentKeyIds,
+            declaredKeyIds: coverage.declaredKeyIds,
+        },
+    });
+}
 function validPort(value) {
     return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 65535 ? value : 0;
 }
@@ -280,6 +399,7 @@ async function startMailSenseApp(options) {
     const importDiscoveryPath = importDiscoveryStatePath(options.agentName);
     let lastScanAt = null;
     let lastQueuedCount = 0;
+    let lastKeyCoverage = unverifiableCoverage(new Date(now()).toISOString(), "mail key coverage not probed yet");
     const scan = async () => {
         const scanStartedAt = new Date(now()).toISOString();
         let queuedCount = 0;
@@ -322,6 +442,13 @@ async function startMailSenseApp(options) {
                 meta: { agentName: options.agentName, error: error instanceof Error ? error.message : String(error) },
             });
         }
+        lastKeyCoverage = await computeMailKeyCoverage({
+            agentName: options.agentName,
+            config: resolved.config,
+            readRegistry: options.readRegistry ?? reader_1.readMailroomRegistry,
+            checkedAt: scanStartedAt,
+        });
+        emitMailKeyCoverageEvents(options.agentName, lastKeyCoverage);
         lastScanAt = scanStartedAt;
         lastQueuedCount = queuedCount;
         writeRuntimeState(runtimePath, {
@@ -336,6 +463,7 @@ async function startMailSenseApp(options) {
             storeLabel: resolved.storeLabel,
             lastScanAt,
             lastQueuedCount,
+            keyCoverage: lastKeyCoverage,
             updatedAt: new Date(now()).toISOString(),
         });
     };
@@ -382,6 +510,7 @@ async function startMailSenseApp(options) {
                 storeLabel: resolved.storeLabel,
                 lastScanAt,
                 lastQueuedCount,
+                keyCoverage: lastKeyCoverage,
                 updatedAt: new Date(now()).toISOString(),
             });
             (0, runtime_1.emitNervesEvent)({

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") {