@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/rsvp/cutover.js

@@ -0,0 +1,433 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRsvpCutover = checkRsvpCutover;
+exports.runRsvpCutover = runRsvpCutover;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const machine_identity_1 = require("../heart/machine-identity");
+const runtime_credentials_1 = require("../heart/runtime-credentials");
+const runtime_1 = require("../nerves/runtime");
+const LEGACY_LAUNCH_AGENT_LABEL = "com.arimendelow.rsvp-tracker";
+const EMPTY_ROLLBACK = {
+    configBackupPath: "",
+    launchAgentBackupPath: "",
+    manifestPath: "",
+};
+function normalizeDeps(deps = {}) {
+    return {
+        existsSync: deps.existsSync ?? fs.existsSync,
+        readFileSync: deps.readFileSync ?? ((filePath) => fs.readFileSync(filePath, "utf-8")),
+        writeFileSync: deps.writeFileSync ?? ((filePath, contents) => fs.writeFileSync(filePath, contents, "utf-8")),
+        mkdirSync: deps.mkdirSync ?? ((dirPath) => fs.mkdirSync(dirPath, { recursive: true })),
+        renameSync: deps.renameSync ?? fs.renameSync,
+        copyFileSync: deps.copyFileSync ?? fs.copyFileSync,
+        now: deps.now ?? (() => new Date()),
+        spawnSync: deps.spawnSync ?? node_child_process_1.spawnSync,
+        platform: deps.platform ?? process.platform,
+        getUid: deps.getUid ?? (() => process.getuid()),
+        homeDir: deps.homeDir ?? os.homedir,
+        fetchImpl: deps.fetchImpl ?? fetch,
+        getLaunchAgentState: deps.getLaunchAgentState,
+        getLegacyProcessState: deps.getLegacyProcessState,
+        checkNativeBlueBubblesCredential: deps.checkNativeBlueBubblesCredential,
+        unloadLaunchAgent: deps.unloadLaunchAgent,
+    };
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function text(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function safeStamp(now) {
+    return now.toISOString().replace(/[:.]/g, "-");
+}
+function rollbackDir(legacyRoot, now) {
+    return path.join(legacyRoot, ".ouro-cutover", safeStamp(now));
+}
+function buildBlueBubblesHealthUrl(baseUrl, password) {
+    const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const url = new URL("api/v1/message/count", root);
+    url.searchParams.set("password", password);
+    return url.toString();
+}
+function readLegacyConfig(legacyRoot, deps) {
+    const configPath = path.join(legacyRoot, "config.json");
+    if (!deps.existsSync(configPath))
+        return { status: "missing" };
+    try {
+        const parsed = JSON.parse(deps.readFileSync(configPath));
+        const config = asRecord(parsed);
+        return config ? { status: "ok", config } : { status: "malformed" };
+    }
+    catch {
+        return { status: "malformed" };
+    }
+}
+function legacyConfigSendInactive(legacyRoot, deps) {
+    const legacy = readLegacyConfig(legacyRoot, deps);
+    if (legacy.status === "missing")
+        return true;
+    if (legacy.status !== "ok")
+        return false;
+    const bluebubbles = asRecord(legacy.config?.bluebubbles);
+    if (!bluebubbles)
+        return true;
+    if (bluebubbles.disabled === true || bluebubbles.enabled === false || bluebubbles.send_enabled === false || bluebubbles.sendEnabled === false)
+        return true;
+    const hasLiveCoordinates = !!text(bluebubbles.server_url ?? bluebubbles.serverUrl)
+        && !!text(bluebubbles.chat_guid ?? bluebubbles.chatGuid)
+        && !!text(bluebubbles.secrets_path ?? bluebubbles.secretsPath);
+    return !hasLiveCoordinates;
+}
+async function defaultLaunchAgentState(input, deps) {
+    if (deps.platform !== "darwin") {
+        return { label: input.label, loaded: false, source: "unavailable" };
+    }
+    const uid = deps.getUid();
+    if (uid === null)
+        return { label: input.label, loaded: false, source: "unavailable" };
+    const result = deps.spawnSync("launchctl", ["print", `gui/${uid}/${input.label}`], {
+        encoding: "utf-8",
+        timeout: 5_000,
+    });
+    return {
+        label: input.label,
+        loaded: result.status === 0,
+        plistPath: firstExistingPath([
+            path.join(input.legacyRoot, `${input.label}.plist`),
+            path.join(deps.homeDir(), "Library", "LaunchAgents", `${input.label}.plist`),
+        ], deps),
+        source: "launchctl",
+    };
+}
+async function defaultLegacyProcessState(input, deps) {
+    const result = deps.spawnSync("ps", ["-axo", "pid=,command="], {
+        encoding: "utf-8",
+        timeout: 5_000,
+    });
+    if (result.status !== 0 || typeof result.stdout !== "string") {
+        return { running: false, count: 0, source: "unavailable" };
+    }
+    const legacyRoot = input.legacyRoot;
+    const count = result.stdout
+        .split("\n")
+        .filter((line) => line.includes("rsvp_tracker.py") || line.includes(legacyRoot))
+        .filter((line) => !line.includes("vitest") && !line.includes("node "))
+        .length;
+    return { running: count > 0, count, source: "ps" };
+}
+async function defaultNativeBlueBubblesCredentialHealth(input, deps) {
+    if (!input.agent) {
+        return { ok: false, detail: "native BlueBubbles credential check requires an agent" };
+    }
+    const cachedRuntimeConfig = (0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(input.agent);
+    const runtimeConfig = cachedRuntimeConfig.ok
+        ? cachedRuntimeConfig
+        : await (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(input.agent, (0, machine_identity_1.loadOrCreateMachineIdentity)({ homeDir: deps.homeDir() }).machineId, { preserveCachedOnFailure: true });
+    if (!runtimeConfig.ok) {
+        return { ok: false, detail: "machine runtime/config unavailable" };
+    }
+    const bluebubbles = asRecord(runtimeConfig.config.bluebubbles);
+    const bluebubblesSense = asRecord(runtimeConfig.config.bluebubblesChannel);
+    const serverUrl = text(bluebubbles?.serverUrl);
+    const password = text(bluebubbles?.password);
+    if (!serverUrl || !password) {
+        return { ok: false, detail: "machine runtime/config missing bluebubbles serverUrl/password" };
+    }
+    const requestTimeoutMs = typeof bluebubblesSense?.requestTimeoutMs === "number" && Number.isFinite(bluebubblesSense.requestTimeoutMs)
+        ? bluebubblesSense.requestTimeoutMs
+        : 30_000;
+    try {
+        const response = await deps.fetchImpl(buildBlueBubblesHealthUrl(serverUrl, password), {
+            method: "GET",
+            signal: AbortSignal.timeout(requestTimeoutMs),
+        });
+        return response.ok
+            ? { ok: true, detail: "native BlueBubbles credential healthy" }
+            : { ok: false, detail: `native BlueBubbles health probe returned HTTP ${response.status}` };
+    }
+    catch {
+        return { ok: false, detail: "native BlueBubbles health probe failed" };
+    }
+}
+async function defaultUnloadLaunchAgent(input, deps) {
+    if (deps.platform !== "darwin")
+        return { ok: true, detail: "launchd not applicable on this platform" };
+    const uid = deps.getUid();
+    if (uid === null)
+        return { ok: false, detail: "current uid unavailable" };
+    const bootout = deps.spawnSync("launchctl", ["bootout", `gui/${uid}/${input.label}`], {
+        encoding: "utf-8",
+        timeout: 5_000,
+    });
+    if (bootout.status === 0)
+        return { ok: true };
+    if (input.plistPath) {
+        const unload = deps.spawnSync("launchctl", ["unload", "-w", input.plistPath], {
+            encoding: "utf-8",
+            timeout: 5_000,
+        });
+        if (unload.status === 0)
+            return { ok: true };
+    }
+    return { ok: true, detail: "legacy LaunchAgent was not loaded or launchctl did not report it as loaded" };
+}
+function firstExistingPath(candidates, deps) {
+    return candidates.find((candidate) => !!candidate && deps.existsSync(candidate));
+}
+function launchAgentPlistCandidates(legacyRoot, state, deps) {
+    const candidates = [
+        state.plistPath,
+        path.join(legacyRoot, `${LEGACY_LAUNCH_AGENT_LABEL}.plist`),
+        path.join(deps.homeDir(), "Library", "LaunchAgents", `${LEGACY_LAUNCH_AGENT_LABEL}.plist`),
+    ];
+    return [...new Set(candidates.filter((candidate) => !!candidate && deps.existsSync(candidate)))];
+}
+function denialReasons(checks) {
+    const reasons = [];
+    if (!checks.launchAgentInactive)
+        reasons.push("legacy LaunchAgent is still loaded");
+    if (!checks.legacyProcessInactive)
+        reasons.push("legacy RSVP process is still running");
+    if (!checks.legacyConfigSendInactive)
+        reasons.push("legacy RSVP config can still send BlueBubbles messages");
+    if (!checks.legacyLiveSendInactive)
+        reasons.push("legacy live-send path is still active");
+    if (!checks.nativeBlueBubblesCredentialHealthy)
+        reasons.push("native BlueBubbles credential is not healthy");
+    return reasons;
+}
+function report(input) {
+    const reasons = denialReasons(input.checks);
+    const sendAllowed = reasons.length === 0;
+    return {
+        ok: input.ok ?? true,
+        action: input.action,
+        sideEffect: input.sideEffect,
+        ...(input.agent ? { agent: input.agent } : {}),
+        legacyRoot: input.legacyRoot,
+        checks: input.checks,
+        sendAllowed,
+        denialReasons: reasons,
+        message: sendAllowed
+            ? "native RSVP live send is allowed"
+            : "native RSVP live send is blocked until cutover gates pass",
+        ...(input.requires ? { requires: input.requires } : {}),
+        rollback: {
+            ...EMPTY_ROLLBACK,
+            ...input.rollback,
+        },
+    };
+}
+async function buildChecks(input, deps) {
+    if (!deps.existsSync(input.legacyRoot)) {
+        return {
+            launchAgentInactive: true,
+            legacyProcessInactive: true,
+            legacyConfigSendInactive: true,
+            legacyLiveSendInactive: true,
+            nativeBlueBubblesCredentialHealthy: false,
+        };
+    }
+    const launchAgentState = deps.getLaunchAgentState
+        ? await deps.getLaunchAgentState({
+            label: LEGACY_LAUNCH_AGENT_LABEL,
+            legacyRoot: input.legacyRoot,
+        })
+        : await defaultLaunchAgentState({
+            label: LEGACY_LAUNCH_AGENT_LABEL,
+            legacyRoot: input.legacyRoot,
+        }, deps);
+    const processState = deps.getLegacyProcessState
+        ? await deps.getLegacyProcessState({ legacyRoot: input.legacyRoot })
+        : await defaultLegacyProcessState({ legacyRoot: input.legacyRoot }, deps);
+    const configInactive = legacyConfigSendInactive(input.legacyRoot, deps);
+    const liveInactive = !launchAgentState.loaded && !processState.running && configInactive;
+    const nativeCredential = deps.checkNativeBlueBubblesCredential
+        ? await deps.checkNativeBlueBubblesCredential({ agent: input.agent })
+        : await defaultNativeBlueBubblesCredentialHealth({ agent: input.agent }, deps);
+    return {
+        launchAgentInactive: !launchAgentState.loaded,
+        legacyProcessInactive: !processState.running,
+        legacyConfigSendInactive: configInactive,
+        legacyLiveSendInactive: liveInactive,
+        nativeBlueBubblesCredentialHealthy: nativeCredential.ok,
+    };
+}
+async function checkRsvpCutover(input) {
+    const deps = normalizeDeps(input.deps);
+    const checks = await buildChecks(input, deps);
+    const result = report({
+        action: "check",
+        sideEffect: false,
+        agent: input.agent,
+        legacyRoot: input.legacyRoot,
+        checks,
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.cutover_checked",
+        message: "checked RSVP legacy cutover gates",
+        meta: {
+            agent: input.agent,
+            sendAllowed: result.sendAllowed,
+            denialCount: result.denialReasons.length,
+        },
+    });
+    return result;
+}
+function writeRollbackManifest(input) {
+    const manifestPath = path.join(rollbackDir(input.legacyRoot, input.deps.now()), `${input.action}-rollback.json`);
+    input.deps.mkdirSync(path.dirname(manifestPath));
+    const rollback = {
+        ...EMPTY_ROLLBACK,
+        ...input.rollback,
+        manifestPath,
+    };
+    input.deps.writeFileSync(manifestPath, `${JSON.stringify({
+        action: input.action,
+        createdAt: input.deps.now().toISOString(),
+        label: LEGACY_LAUNCH_AGENT_LABEL,
+        rollback,
+    }, null, 2)}\n`);
+    return rollback;
+}
+async function retireLegacySendConfig(input, deps) {
+    const configPath = path.join(input.legacyRoot, "config.json");
+    const backupPath = path.join(rollbackDir(input.legacyRoot, deps.now()), "config.json");
+    deps.mkdirSync(path.dirname(backupPath));
+    deps.copyFileSync(configPath, backupPath);
+    const legacy = readLegacyConfig(input.legacyRoot, deps);
+    const config = legacy.status === "ok" ? { ...legacy.config } : {};
+    config.bluebubbles = {
+        send_enabled: false,
+        enabled: false,
+        disabled: true,
+        disabled_by: "ouro rsvp cutover",
+        disabled_at: deps.now().toISOString(),
+    };
+    deps.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+    return writeRollbackManifest({
+        legacyRoot: input.legacyRoot,
+        action: "retire-legacy-send-config",
+        deps,
+        rollback: { configBackupPath: backupPath },
+    });
+}
+async function quarantineLaunchAgent(input, deps) {
+    const state = deps.getLaunchAgentState
+        ? await deps.getLaunchAgentState({
+            label: LEGACY_LAUNCH_AGENT_LABEL,
+            legacyRoot: input.legacyRoot,
+        })
+        : await defaultLaunchAgentState({
+            label: LEGACY_LAUNCH_AGENT_LABEL,
+            legacyRoot: input.legacyRoot,
+        }, deps);
+    const candidates = launchAgentPlistCandidates(input.legacyRoot, state, deps);
+    const plistPath = candidates[0];
+    if (deps.unloadLaunchAgent) {
+        await deps.unloadLaunchAgent({
+            label: LEGACY_LAUNCH_AGENT_LABEL,
+            legacyRoot: input.legacyRoot,
+            ...(plistPath ? { plistPath } : {}),
+        });
+    }
+    else {
+        await defaultUnloadLaunchAgent({
+            label: LEGACY_LAUNCH_AGENT_LABEL,
+            ...(plistPath ? { plistPath } : {}),
+        }, deps);
+    }
+    let backupPath = "";
+    if (plistPath) {
+        backupPath = path.join(rollbackDir(input.legacyRoot, deps.now()), path.basename(plistPath));
+        deps.mkdirSync(path.dirname(backupPath));
+        deps.renameSync(plistPath, backupPath);
+    }
+    return writeRollbackManifest({
+        legacyRoot: input.legacyRoot,
+        action: "quarantine-launchd",
+        deps,
+        rollback: { launchAgentBackupPath: backupPath },
+    });
+}
+async function runRsvpCutover(input) {
+    const deps = normalizeDeps(input.deps);
+    if (input.action !== "check" && !input.yes) {
+        const checks = await buildChecks(input, deps);
+        return report({
+            action: input.action,
+            sideEffect: false,
+            agent: input.agent,
+            legacyRoot: input.legacyRoot,
+            checks,
+            ok: false,
+            requires: "--yes",
+        });
+    }
+    if (input.action === "check") {
+        return checkRsvpCutover(input);
+    }
+    const rollback = input.action === "retire-legacy-send-config"
+        ? await retireLegacySendConfig(input, deps)
+        : await quarantineLaunchAgent(input, deps);
+    const checks = await buildChecks(input, deps);
+    const result = report({
+        action: input.action,
+        sideEffect: true,
+        agent: input.agent,
+        legacyRoot: input.legacyRoot,
+        checks,
+        rollback,
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.cutover_action_executed",
+        message: "executed RSVP cutover action",
+        meta: {
+            agent: input.agent,
+            action: input.action,
+            sendAllowed: result.sendAllowed,
+        },
+    });
+    return result;
+}

package/dist/rsvp/diagnostics.js

@@ -0,0 +1,232 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectRsvpDiagnostics = collectRsvpDiagnostics;
+const path = __importStar(require("node:path"));
+const habit_parser_1 = require("../heart/habits/habit-parser");
+const runtime_1 = require("../nerves/runtime");
+const habit_policy_1 = require("./habit-policy");
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readJson(filePath, deps) {
+    try {
+        return JSON.parse(deps.readFileSync(filePath));
+    }
+    catch {
+        return null;
+    }
+}
+function numberField(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function countsFrom(value) {
+    if (!isRecord(value))
+        return null;
+    const attending = numberField(value, "attending");
+    const declined = numberField(value, "declined");
+    const pending = numberField(value, "pending");
+    return attending === null || declined === null || pending === null
+        ? null
+        : { attending, declined, pending };
+}
+function readLedgerRows(filePath, deps) {
+    if (!deps.existsSync(filePath))
+        return [];
+    const lines = deps.readFileSync(filePath).split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const rows = [];
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (isRecord(parsed))
+                rows.push(parsed);
+        }
+        catch {
+            // Ignore malformed rows in this high-level health summary.
+        }
+    }
+    return rows;
+}
+function rowTimestamp(row) {
+    const raw = stringField(row, "createdAt") ?? stringField(row, "anchorTimestamp") ?? "";
+    const parsed = Date.parse(raw);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function contextPacketLedgerHealth(agentRoot, deps) {
+    const candidates = [
+        path.join(agentRoot, "state", "senses", "context-packets", "bluebubbles", "ledger.jsonl"),
+        path.join(agentRoot, "state", "senses", "context-packets", "ledger.jsonl"),
+    ];
+    const rowsByPath = candidates
+        .map((ledgerPath) => ({ ledgerPath, rows: readLedgerRows(ledgerPath, deps) }))
+        .filter((entry) => entry.rows.length > 0);
+    if (rowsByPath.length === 0) {
+        return { status: "warn", detail: "no context packet ledger rows found", rows: 0 };
+    }
+    const selected = rowsByPath[0];
+    const latest = [...selected.rows].sort((left, right) => rowTimestamp(right) - rowTimestamp(left))[0];
+    const latestPacketId = stringField(latest, "packetId") ?? stringField(latest, "id") ?? undefined;
+    return {
+        status: latestPacketId ? "pass" : "warn",
+        detail: latestPacketId ? `latestPacketId=${latestPacketId}; rows=${selected.rows.length}` : `rows=${selected.rows.length}; latest packet id missing`,
+        ...(latestPacketId ? { latestPacketId } : {}),
+        ledgerPath: selected.ledgerPath,
+        rows: selected.rows.length,
+    };
+}
+function habitScheduleHealth(agentRoot, deps) {
+    const habitsDir = path.join(agentRoot, "habits");
+    if (!deps.existsSync(habitsDir))
+        return { status: "warn", detail: "habits directory missing" };
+    try {
+        const rsvpHabits = deps.readdirSync(habitsDir)
+            .filter((name) => name.endsWith(".md") && (0, habit_policy_1.isRsvpHabitName)(name.replace(/\.md$/, "")))
+            .sort((left, right) => left.localeCompare(right))
+            .map((name) => {
+            const filePath = path.join(habitsDir, name);
+            return (0, habit_parser_1.parseHabitFile)(deps.readFileSync(filePath), filePath);
+        });
+        const habitStates = rsvpHabits.map((habit) => ({
+            name: habit.name,
+            status: habit.status,
+            degradedReason: habit.status === "degraded" ? habit.degradedReason : null,
+        }));
+        if (rsvpHabits.some((habit) => habit.status === "degraded")) {
+            return { status: "fail", detail: "RSVP habit definitions degraded", habitStates };
+        }
+        const active = rsvpHabits.find((habit) => habit.status === "active");
+        if (!active)
+            return { status: "warn", detail: "no active RSVP habit found", habitStates };
+        if (!active.rsvp)
+            return { status: "fail", detail: `activeHabit=${active.name}; typed RSVP habit metadata missing`, habitStates };
+        const cadence = active.cadence ?? "unspecified";
+        return {
+            status: "pass",
+            detail: [
+                `activeHabit=${active.name}`,
+                `cadence=${cadence}`,
+                `sense=${active.rsvp.sense}`,
+                `source=${active.rsvp.source}`,
+                `snapshotRef=${active.rsvp.snapshotRef}`,
+            ].join("; "),
+            activeHabit: active.name,
+            cadence,
+            policyVersion: active.rsvp.policyVersion,
+            sense: active.rsvp.sense,
+            source: active.rsvp.source,
+            routeRef: active.rsvp.routeRef,
+            snapshotRef: active.rsvp.snapshotRef,
+            outboundStateRef: active.rsvp.outboundStateRef,
+            budgetRef: active.rsvp.budgetRef,
+            idempotencyRef: active.rsvp.idempotencyRef,
+            habitStates,
+        };
+    }
+    catch (error) {
+        return { status: "fail", detail: `habit schedule unreadable: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
+function latestFetchHealth(agentRoot, deps) {
+    const latestPath = path.join(agentRoot, "state", "rsvp", "snapshots", "latest.json");
+    if (!deps.existsSync(latestPath))
+        return { status: "warn", detail: "latest RSVP snapshot missing" };
+    const parsed = readJson(latestPath, deps);
+    if (!isRecord(parsed))
+        return { status: "fail", detail: "latest RSVP snapshot is malformed" };
+    const snapshotId = stringField(parsed, "snapshotId");
+    const counts = countsFrom(parsed.counts) ?? countsFrom(parsed.summary);
+    if (!snapshotId || !counts)
+        return { status: "fail", detail: "latest RSVP snapshot missing id or counts" };
+    return {
+        status: "pass",
+        detail: `snapshotId=${snapshotId}; pending=${counts.pending}`,
+        snapshotId,
+        counts,
+    };
+}
+function deliveryReconciliationHealth(agentRoot, deps) {
+    const legacyLedgerPath = path.join(agentRoot, "state", "rsvp", "outbound", "ledger.json");
+    if (deps.existsSync(legacyLedgerPath)) {
+        const parsed = readJson(legacyLedgerPath, deps);
+        const reservations = isRecord(parsed) && Array.isArray(parsed.reservations) ? parsed.reservations : [];
+        const accepted = reservations.filter((entry) => isRecord(entry) && entry.status === "accepted").length;
+        return { status: "pass", detail: `accepted=${accepted}`, accepted };
+    }
+    const statePath = path.join(agentRoot, "state", "rsvp", "outbound-state.json");
+    if (!deps.existsSync(statePath))
+        return { status: "warn", detail: "RSVP outbound state missing", accepted: 0 };
+    const parsed = readJson(statePath, deps);
+    if (!isRecord(parsed))
+        return { status: "fail", detail: "RSVP outbound state is malformed", accepted: 0 };
+    const accepted = isRecord(parsed.baseline) ? 1 : 0;
+    return { status: "pass", detail: `accepted=${accepted}`, accepted };
+}
+function spendTimelineHealth(agentRoot, deps) {
+    const spendPath = path.join(agentRoot, "state", "rsvp", "spend-ledger.json");
+    if (!deps.existsSync(spendPath))
+        return { status: "warn", detail: "RSVP spend ledger missing", runs: 0 };
+    const parsed = readJson(spendPath, deps);
+    if (!isRecord(parsed) || !Array.isArray(parsed.runs)) {
+        return { status: "fail", detail: "RSVP spend ledger is malformed", runs: 0 };
+    }
+    return { status: "pass", detail: `runs=${parsed.runs.length}`, runs: parsed.runs.length };
+}
+function collectRsvpDiagnostics(agentRoot, deps) {
+    const diagnostics = {
+        contextPacketLedger: contextPacketLedgerHealth(agentRoot, deps),
+        habitSchedule: habitScheduleHealth(agentRoot, deps),
+        latestFetch: latestFetchHealth(agentRoot, deps),
+        deliveryReconciliation: deliveryReconciliationHealth(agentRoot, deps),
+        spendTimeline: spendTimelineHealth(agentRoot, deps),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.diagnostics_collected",
+        message: "collected RSVP diagnostics",
+        meta: {
+            contextPacketLedger: diagnostics.contextPacketLedger.status,
+            habitSchedule: diagnostics.habitSchedule.status,
+            latestFetch: diagnostics.latestFetch.status,
+            deliveryReconciliation: diagnostics.deliveryReconciliation.status,
+            spendTimeline: diagnostics.spendTimeline.status,
+        },
+    });
+    return diagnostics;
+}