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

package/dist/heart/daemon/daemon.js

@@ -488,6 +488,13 @@ function isValidHabitPokeCommand(command) {
         && typeof command.habitName === "string"
         && command.habitName.trim().length > 0;
 }
+function isValidHabitProbeCommand(command) {
+    return typeof command.agent === "string"
+        && command.agent.trim().length > 0
+        && typeof command.habitName === "string"
+        && command.habitName.trim().length > 0
+        && (command.noSend === undefined || command.noSend === true);
+}
 function taskIdFromTaskPokePrivateWakeCommand(command) {
     if (command.kind !== "private.wake" || command.triggerSource !== "task-poke")
         return null;
@@ -1162,6 +1169,10 @@ class OuroDaemon {
                 originRefs: [{ kind: "daemon-command", id: "inner.wake" }],
             };
         }
+        const hasNoSendCapability = command.originRefs?.some((ref) => ref.kind === "capability" && ref.id === "no-send") ?? false;
+        if ((command.noSend === true) !== hasNoSendCapability) {
+            throw new Error("private-runtime no-send capability does not match its bound origin reference");
+        }
         return {
             agent: command.agent,
             origin: "daemon.private.wake",
@@ -1210,37 +1221,110 @@ class OuroDaemon {
             ],
         };
     }
-    resolveHabitPokeOccurrenceId(command, trigger) {
-        const agentRoot = path.join(this.bundlesRoot, `${command.agent}.ouro`);
-        const habitPath = path.join(agentRoot, "habits", `${command.habitName}.md`);
-        let parsedHabit = null;
-        if ((0, habit_policy_1.isRsvpHabitName)(command.habitName)) {
-            if (!fs.existsSync(habitPath))
-                return { skipReason: "RSVP habit file not found" };
+    resolveHabitDispatch(options) {
+        const agentRoot = path.join(this.bundlesRoot, `${options.agent}.ouro`);
+        const habitPath = path.join(agentRoot, "habits", `${options.habitName}.md`);
+        const isRsvp = (0, habit_policy_1.isRsvpHabitName)(options.habitName);
+        let readFailure = null;
+        let habit;
+        if (!fs.existsSync(habitPath)) {
+            readFailure = "missing";
+            habit = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error", "", "habit file not found");
+        }
+        else {
             try {
-                parsedHabit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
+                habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
             }
             catch (error) {
-                return { skipReason: `RSVP habit metadata invalid: ${messageFromHabitPokeError(error)}` };
+                readFailure = "read";
+                habit = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error", "", messageFromHabitPokeError(error));
             }
-            if (!parsedHabit.rsvp)
-                return { skipReason: "RSVP habit metadata is required before private runtime wake" };
         }
-        if (trigger === "poke" || trigger === "manual")
-            return undefined;
-        if (typeof command.occurrenceId === "string" && command.occurrenceId.trim().length > 0)
-            return command.occurrenceId.trim();
-        if (!fs.existsSync(habitPath))
-            return { skipReason: "habit file not found" };
-        const habit = parsedHabit ?? (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
-        if (habit.cadence === null)
-            return { skipReason: "habit has no cadence" };
-        const cadence = habit.cadence;
-        if (habit.lastRun === null)
-            return `${trigger}:first-run:${cadence}`;
-        return `${trigger}:last-run:${habit.lastRun}:cadence:${cadence}`;
+        if (habit.status !== "active") {
+            let skipReason = `habit status ${habit.status} is non-executable`;
+            if (isRsvp && habit.status === "degraded") {
+                if (readFailure === "missing") {
+                    skipReason = "RSVP habit file not found";
+                }
+                else {
+                    skipReason = `RSVP habit metadata invalid: ${habit.degradedDetail ?? habit.degradedReason}`;
+                }
+            }
+            else if (readFailure === "missing"
+                && options.source === "habit-poke"
+                && options.trigger !== "manual"
+                && options.trigger !== "poke") {
+                skipReason = "habit file not found";
+            }
+            return { kind: "skipped", habit, skipReason };
+        }
+        if (isRsvp && !habit.rsvp) {
+            return {
+                kind: "skipped",
+                habit,
+                skipReason: "RSVP habit metadata is required before private runtime wake",
+            };
+        }
+        if (options.trigger === "poke" || options.trigger === "manual") {
+            return { kind: "ready", habit };
+        }
+        if (typeof options.occurrenceId === "string" && options.occurrenceId.trim().length > 0) {
+            return { kind: "ready", habit, occurrenceId: options.occurrenceId.trim() };
+        }
+        if (habit.cadence === null) {
+            return { kind: "skipped", habit, skipReason: "habit has no cadence" };
+        }
+        if (habit.lastRun === null) {
+            return { kind: "ready", habit, occurrenceId: `${options.trigger}:first-run:${habit.cadence}` };
+        }
+        return {
+            kind: "ready",
+            habit,
+            occurrenceId: `${options.trigger}:last-run:${habit.lastRun}:cadence:${habit.cadence}`,
+        };
+    }
+    emitHabitDispatchSkipped(options) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.habit_dispatch_skipped",
+            message: "habit dispatch rejected by current lifecycle state",
+            meta: {
+                agent: options.agent,
+                habitName: options.habitName,
+                trigger: options.trigger,
+                status: options.resolution.habit.status,
+                degradedReason: options.resolution.habit.status === "degraded"
+                    ? options.resolution.habit.degradedReason
+                    : null,
+                detail: options.resolution.habit.status === "degraded"
+                    ? options.resolution.habit.degradedDetail
+                    : null,
+                reason: options.resolution.skipReason,
+            },
+        });
     }
-    async runNativeRsvpHabit(command, trigger, occurrenceId) {
+    emitHabitDispatchReady(options) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_dispatch_ready",
+            message: "habit dispatch accepted by current lifecycle state",
+            meta: {
+                agent: options.agent,
+                habitName: options.habitName,
+                trigger: options.trigger,
+                status: options.resolution.habit.status,
+                occurrenceId: options.resolution.occurrenceId ?? null,
+            },
+        });
+    }
+    skippedHabitDispatchResponse(options) {
+        return {
+            ok: true,
+            message: `skipped scheduled habit ${options.habitName} for ${options.agent}: ${options.skipReason}`,
+        };
+    }
+    async runNativeRsvpHabit(command, trigger, occurrenceId, noSend = false) {
         const runner = this.rsvpHabitRunner ?? (async (input) => {
             const { runNativeRsvpHabit } = await Promise.resolve().then(() => __importStar(require("../../rsvp/native-habit-runner")));
             return runNativeRsvpHabit(input);
@@ -1251,7 +1335,48 @@ class OuroDaemon {
             habitName: command.habitName,
             trigger,
             ...(occurrenceId ? { occurrenceId } : {}),
+            ...(noSend ? { noSend: true } : {}),
         });
+        if (noSend) {
+            const payload = result.payload;
+            const status = payload?.status;
+            const transportInvocationCount = payload?.transportInvocationCount;
+            const contractError = "native RSVP habit probe violated the immutable no-send result contract";
+            if (!result.ok) {
+                return {
+                    ok: false,
+                    error: result.message,
+                    data: {
+                        ok: false,
+                        noSend: true,
+                        status: typeof status === "string" ? status : "degraded",
+                        transportInvocationCount: null,
+                        error: result.message,
+                    },
+                };
+            }
+            if (payload?.noSend !== true
+                || typeof status !== "string"
+                || typeof transportInvocationCount !== "number"
+                || transportInvocationCount !== 0) {
+                return {
+                    ok: false,
+                    error: contractError,
+                    data: {
+                        ok: false,
+                        noSend: true,
+                        status: typeof status === "string" ? status : "degraded",
+                        transportInvocationCount: null,
+                        error: contractError,
+                    },
+                };
+            }
+            return {
+                ok: true,
+                message: result.message,
+                data: { noSend: true, status, transportInvocationCount: 0 },
+            };
+        }
         return {
             ok: result.ok,
             message: result.message,
@@ -1281,6 +1406,7 @@ class OuroDaemon {
                 type: "habit",
                 habitName: habitMessage.habitName,
                 trigger: habitMessage.trigger,
+                ...(habitMessage.noSend ? { noSend: true } : {}),
                 privateTurnDecision: decision,
             };
         }
@@ -1616,8 +1742,43 @@ class OuroDaemon {
             }
             case "inner.wake":
                 return this.handlePrivateRuntimeWake(command);
-            case "private.wake":
+            case "private.wake": {
+                const scheduledHabit = (0, habit_private_wake_1.habitMessageFromPrivateWakeCommand)(command);
+                if (!scheduledHabit || !this.hasManagedPrivateRuntime(command.agent)) {
+                    return this.handlePrivateRuntimeWake(command);
+                }
+                const occurrenceRef = command.originRefs?.find((ref) => ref.kind === "habit-occurrence");
+                const occurrenceId = typeof occurrenceRef?.id === "string" && occurrenceRef.id.trim().length > 0
+                    ? occurrenceRef.id.trim()
+                    : undefined;
+                const resolution = this.resolveHabitDispatch({
+                    agent: command.agent,
+                    habitName: scheduledHabit.habitName,
+                    trigger: scheduledHabit.trigger,
+                    source: "private-wake",
+                    ...(occurrenceId ? { occurrenceId } : {}),
+                });
+                if (resolution.kind === "skipped") {
+                    this.emitHabitDispatchSkipped({
+                        agent: command.agent,
+                        habitName: scheduledHabit.habitName,
+                        trigger: scheduledHabit.trigger,
+                        resolution,
+                    });
+                    return this.skippedHabitDispatchResponse({
+                        agent: command.agent,
+                        habitName: scheduledHabit.habitName,
+                        skipReason: resolution.skipReason,
+                    });
+                }
+                this.emitHabitDispatchReady({
+                    agent: command.agent,
+                    habitName: scheduledHabit.habitName,
+                    trigger: scheduledHabit.trigger,
+                    resolution,
+                });
                 return this.handlePrivateRuntimeWake(command);
+            }
             case "chat.connect":
                 await this.processManager.startAgent(command.agent);
                 return {
@@ -1663,23 +1824,115 @@ class OuroDaemon {
                         error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
                     };
                 }
-                const occurrenceId = this.resolveHabitPokeOccurrenceId(command, trigger);
-                if (typeof occurrenceId === "object") {
+                const resolution = this.resolveHabitDispatch({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    source: "habit-poke",
+                    ...(command.occurrenceId ? { occurrenceId: command.occurrenceId } : {}),
+                });
+                if (resolution.kind === "skipped") {
+                    this.emitHabitDispatchSkipped({
+                        agent: command.agent,
+                        habitName: command.habitName,
+                        trigger,
+                        resolution,
+                    });
+                    return this.skippedHabitDispatchResponse({
+                        agent: command.agent,
+                        habitName: command.habitName,
+                        skipReason: resolution.skipReason,
+                    });
+                }
+                this.emitHabitDispatchReady({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    resolution,
+                });
+                if ((0, habit_policy_1.isRsvpHabitName)(command.habitName)) {
+                    return this.runNativeRsvpHabit(command, trigger, resolution.occurrenceId);
+                }
+                return this.handlePrivateRuntimeWake((0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    sourceRef: { kind: "daemon-command", id: "habit.poke" },
+                    occurrenceId: resolution.occurrenceId,
+                }));
+            }
+            case "habit.probe": {
+                if (!isValidHabitProbeCommand(command)) {
+                    return {
+                        ok: false,
+                        error: "Invalid habit.probe payload: expected non-empty agent/habitName and noSend=true.",
+                    };
+                }
+                const trigger = "manual";
+                if (!(0, habit_policy_1.isRsvpHabitName)(command.habitName) && !this.hasManagedPrivateRuntime(command.agent)) {
+                    return {
+                        ok: false,
+                        error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
+                    };
+                }
+                const resolution = this.resolveHabitDispatch({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    source: "habit-probe",
+                });
+                if (resolution.kind === "skipped") {
+                    this.emitHabitDispatchSkipped({
+                        agent: command.agent,
+                        habitName: command.habitName,
+                        trigger,
+                        resolution,
+                    });
                     return {
                         ok: true,
-                        message: `skipped scheduled habit ${command.habitName} for ${command.agent}: ${occurrenceId.skipReason}`,
+                        message: `habit probe rejected by lifecycle: status=${resolution.habit.status}`,
+                        data: {
+                            noSend: true,
+                            status: resolution.habit.status,
+                            transportInvocationCount: 0,
+                        },
                     };
                 }
+                this.emitHabitDispatchReady({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    resolution,
+                });
                 if ((0, habit_policy_1.isRsvpHabitName)(command.habitName)) {
-                    return this.runNativeRsvpHabit(command, trigger, occurrenceId);
+                    return this.runNativeRsvpHabit(command, trigger, resolution.occurrenceId, true);
                 }
-                return this.handlePrivateRuntimeWake((0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
+                const wake = await this.handlePrivateRuntimeWake((0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
                     agent: command.agent,
                     habitName: command.habitName,
                     trigger,
-                    sourceRef: { kind: "daemon-command", id: "habit.poke" },
-                    occurrenceId,
+                    sourceRef: { kind: "daemon-command", id: "habit.probe" },
+                    occurrenceId: resolution.occurrenceId,
+                    noSend: true,
                 }));
+                if (!wake.ok)
+                    return wake;
+                const denied = wake.data
+                    ?.decision?.executable === false;
+                const error = denied
+                    ? "non-RSVP habit probe was not executed because private-runtime policy denied execution"
+                    : "non-RSVP habit probe completion is asynchronous; zero-transport evidence is unverified";
+                return {
+                    ok: false,
+                    error,
+                    data: {
+                        ok: false,
+                        noSend: true,
+                        status: resolution.habit.status,
+                        transportInvocationCount: null,
+                        error,
+                    },
+                };
             }
             case "await.poke": {
                 return this.handlePrivateRuntimeWake(this.buildAwaitPrivateWakeCommand(command));

package/dist/heart/daemon/doctor.js

@@ -99,6 +99,10 @@ function textField(record, key) {
     const value = record?.[key];
     return typeof value === "string" ? value.trim() : "";
 }
+function stringArrayField(record, key) {
+    const value = record?.[key];
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
 function numberField(record, key, fallback) {
     const value = record?.[key];
     return typeof value === "number" && Number.isFinite(value) ? value : fallback;
@@ -271,6 +275,59 @@ function checkAgents(deps) {
     }
     return { name: "Agents", checks };
 }
+/**
+ * Mail key coverage, as recorded by the mail sense.
+ *
+ * Doctor reads the sense's own per-cycle verdict rather than re-deriving it:
+ * a health check must need neither network access nor Azure credentials, and
+ * the registry that declares the key ids lives in a Blob container in hosted
+ * mode. The mail sense already fetches it every cycle, so its record is both
+ * the cheapest and the only honest source here.
+ *
+ * Absent is a `fail` because mail encrypted to a key with no private half is
+ * permanently unreadable — unlike an API key, ciphertext cannot be reissued.
+ * Anything the sense could not verify is a `warn`, never a `fail`: a locked or
+ * unavailable vault must not read as key loss.
+ */
+function mailKeyCoverageCheck(deps, agentDir) {
+    const id = "mail.key_coverage";
+    const label = `${agentDir} mail key coverage`;
+    const statePath = `${deps.bundlesRoot}/${agentDir}/state/senses/mail/runtime.json`;
+    const unverified = (detail) => ({ id, label, status: "warn", detail });
+    if (!deps.existsSync(statePath)) {
+        return unverified(`no mail sense runtime state at ${statePath} — coverage is unverified until the mail sense runs a scan`);
+    }
+    let coverage;
+    try {
+        coverage = asRecord(JSON.parse(deps.readFileSync(statePath)).keyCoverage) ?? {};
+    }
+    catch {
+        return unverified(`mail sense runtime state at ${statePath} could not be read`);
+    }
+    const declaredKeyIds = stringArrayField(coverage, "declaredKeyIds");
+    const absentKeyIds = stringArrayField(coverage, "absentKeyIds");
+    const checkedAt = textField(coverage, "checkedAt");
+    const provenance = checkedAt ? ` (recorded ${checkedAt})` : "";
+    if (coverage.status === "covered") {
+        return {
+            id,
+            label,
+            status: "pass",
+            detail: declaredKeyIds.length === 1
+                ? `the 1 registry-declared mail key has a private half in the vault${provenance}`
+                : `all ${declaredKeyIds.length} registry-declared mail keys have a private half in the vault${provenance}`,
+        };
+    }
+    if (coverage.status === "absent") {
+        return {
+            id,
+            label,
+            status: "fail",
+            detail: `the mailroom registry declares mail key${absentKeyIds.length === 1 ? "" : "s"} with no private half in this agent's vault — mail encrypted to ${absentKeyIds.join(", ")} cannot be decrypted and cannot be recovered${provenance}; run \`ouro connect mail --agent ${agentDir.replace(/\.ouro$/, "")}\` and, if Mail Control no longer holds the one-time key, rerun it with --rotate-missing-mail-keys to mint a replacement for future mail`,
+        };
+    }
+    return unverified(`mail sense could not verify key coverage${provenance}: ${textField(coverage, "reason") || "no reason recorded"}`);
+}
 async function checkSenses(deps) {
     const checks = [];
     const agents = discoverAgents(deps);
@@ -422,6 +479,10 @@ async function checkSenses(deps) {
                         mailAutonomyDetail(mailroom),
                     ].join("; "),
                 });
+                // Config being well-formed says nothing about whether the vault can
+                // still decrypt what the registry points mail at — the 2026-07-24 gap
+                // sat behind a passing mail config check for 23 hours.
+                checks.push(mailKeyCoverageCheck(deps, agentDir));
             }
         }
     }
@@ -442,19 +503,34 @@ function checkHabits(deps) {
         }
         checks.push({ label: `${agentDir} habits dir`, status: "pass", detail: habitsDir });
         const activeScheduledHabits = [];
+        const habitLifecycleRows = [];
         let unreadableHabits = 0;
-        for (const file of deps.readdirSync(habitsDir).filter((entry) => entry.endsWith(".md"))) {
+        for (const file of deps.readdirSync(habitsDir).filter((entry) => entry.endsWith(".md") && entry !== "README.md").sort()) {
             const filePath = `${habitsDir}/${file}`;
+            let habit;
             try {
-                const habit = (0, habit_parser_1.parseHabitFile)(deps.readFileSync(filePath), filePath);
-                if (habit.status === "active" && habit.cadence && (0, cadence_1.parseCadenceToCron)(habit.cadence) !== null) {
-                    activeScheduledHabits.push(habit.name);
-                }
+                habit = (0, habit_parser_1.parseHabitFile)(deps.readFileSync(filePath), filePath);
             }
-            catch {
+            catch (error) {
                 unreadableHabits += 1;
+                habit = (0, habit_parser_1.createDegradedHabitFile)(filePath, "read_error", "", error instanceof Error ? error.message : String(error));
+            }
+            habitLifecycleRows.push(habit);
+            if (habit.status === "active" && habit.cadence && (0, cadence_1.parseCadenceToCron)(habit.cadence) !== null) {
+                activeScheduledHabits.push(habit.name);
             }
         }
+        if (habitLifecycleRows.length > 0) {
+            const hasDegradedHabit = habitLifecycleRows.some((habit) => habit.status === "degraded");
+            checks.push({
+                id: "habits.lifecycle",
+                label: `${agentDir} habit lifecycle`,
+                status: hasDegradedHabit ? "fail" : "pass",
+                detail: habitLifecycleRows.map((habit) => habit.status === "degraded"
+                    ? `${habit.name}=degraded(${habit.degradedReason})`
+                    : `${habit.name}=${habit.status}`).join(", "),
+            });
+        }
         if (unreadableHabits > 0) {
             checks.push({
                 label: `${agentDir} habit files`,

package/dist/heart/daemon/habit-private-wake.js

@@ -32,7 +32,9 @@ function buildHabitPrivateWakeCommand(options) {
             { kind: "habit-trigger", id: options.trigger },
             { kind: "habit-occurrence", id: occurrenceId },
             options.sourceRef,
+            ...(options.noSend ? [{ kind: "capability", id: "no-send" }] : []),
         ],
+        ...(options.noSend ? { noSend: true } : {}),
     };
 }
 function habitMessageFromPrivateWakeCommand(command) {
@@ -42,8 +44,11 @@ function habitMessageFromPrivateWakeCommand(command) {
         return null;
     const habitRef = command.originRefs?.find((ref) => ref.kind === "habit" && typeof ref.id === "string");
     const triggerRef = command.originRefs?.find((ref) => ref.kind === "habit-trigger" && typeof ref.id === "string");
+    const noSendRef = command.originRefs?.some((ref) => ref.kind === "capability" && ref.id === "no-send") ?? false;
     if (!habitRef || typeof habitRef.id !== "string" || !triggerRef || typeof triggerRef.id !== "string")
         return null;
+    if ((command.noSend === true) !== noSendRef)
+        return null;
     const habitName = habitRef.id.trim();
     const trigger = triggerRef.id.trim();
     if (habitName.length === 0)
@@ -52,5 +57,5 @@ function habitMessageFromPrivateWakeCommand(command) {
         return null;
     if (command.triggerSource !== `habit-${trigger}`)
         return null;
-    return { habitName, trigger };
+    return { habitName, trigger, ...(noSendRef ? { noSend: true } : {}) };
 }