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

package/dist/rsvp/cli.js

@@ -0,0 +1,926 @@
+"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.runRsvpCliCommand = runRsvpCliCommand;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const doctor_1 = require("../heart/daemon/doctor");
+const habit_parser_1 = require("../heart/habits/habit-parser");
+const identity_1 = require("../heart/identity");
+const machine_identity_1 = require("../heart/machine-identity");
+const runtime_credentials_1 = require("../heart/runtime-credentials");
+const runtime_1 = require("../nerves/runtime");
+const client_1 = require("../senses/bluebubbles/client");
+const aisleplanner_client_1 = require("./aisleplanner-client");
+const config_1 = require("./config");
+const cutover_1 = require("./cutover");
+const diff_renderer_1 = require("./diff-renderer");
+const habit_policy_1 = require("./habit-policy");
+const habit_stage_1 = require("./habit-stage");
+const incident_bundle_1 = require("./incident-bundle");
+const migration_1 = require("./migration");
+const outbound_state_1 = require("./outbound-state");
+const query_1 = require("./query");
+const replay_1 = require("./replay");
+const snapshot_1 = require("./snapshot");
+function commandJson(command) {
+    return "json" in command && command.json === true;
+}
+function commandOutputPath(command) {
+    return "outputPath" in command ? command.outputPath : undefined;
+}
+function commandAgent(command) {
+    return "agent" in command ? command.agent : undefined;
+}
+function commandMode(command) {
+    return "mode" in command ? command.mode : undefined;
+}
+function maybeAgentRoot(command, deps) {
+    const agent = commandAgent(command);
+    if (!agent)
+        return undefined;
+    return deps.agentBundleRoot ?? path.join(deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(), `${agent}.ouro`);
+}
+function writeJsonFile(filePath, payload) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+}
+function readJsonFile(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function fallbackReadRsvpConfig(agentRoot) {
+    const configPath = path.join(agentRoot, "rsvp", "config.json");
+    if (!fs.existsSync(configPath)) {
+        return { ok: false, reason: "missing", path: configPath, message: "missing native RSVP config" };
+    }
+    try {
+        return { ok: true, config: readJsonFile(configPath), path: configPath };
+    }
+    catch {
+        return { ok: false, reason: "malformed", path: configPath, message: "native RSVP config is not valid JSON" };
+    }
+}
+function resolveRsvpConfig(agentRoot) {
+    return (0, config_1.readRsvpConfig)(agentRoot) ?? fallbackReadRsvpConfig(agentRoot);
+}
+function localText(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function defaultLegacyRoot(deps) {
+    return path.join(deps.homeDir ?? os.homedir(), "Projects", "rsvp-tracker");
+}
+function resolveCutoverLegacyRoot(config, deps) {
+    const configured = localText(config.cutover?.legacyRoot);
+    if (configured)
+        return configured;
+    const fallback = defaultLegacyRoot(deps);
+    return fs.existsSync(path.join(fallback, "config.json")) ? fallback : null;
+}
+async function checkLiveSendCutover(input) {
+    const legacyRoot = resolveCutoverLegacyRoot(input.config, input.deps);
+    if (!legacyRoot)
+        return null;
+    return (0, cutover_1.checkRsvpCutover)({
+        agent: input.agent,
+        legacyRoot,
+        ...(input.deps.rsvpCutoverDeps ? { deps: input.deps.rsvpCutoverDeps } : {}),
+    });
+}
+function blockedLiveSendPayload(command, message, extra = {}) {
+    return basePayload(command, false, message, {
+        ok: false,
+        allowSend: command.allowSend === true,
+        sendAllowed: false,
+        requires: "passing RSVP cutover check",
+        ...extra,
+    });
+}
+function cutoverPayload(cutover) {
+    if (!cutover) {
+        return {
+            cutover: {
+                ok: false,
+                sendAllowed: false,
+                denialReasons: ["no RSVP legacy root found for live-send cutover proof"],
+            },
+        };
+    }
+    return {
+        legacyRoot: cutover.legacyRoot,
+        cutover: {
+            ok: cutover.ok,
+            sendAllowed: cutover.sendAllowed,
+            checks: cutover.checks,
+            denialReasons: cutover.denialReasons,
+        },
+    };
+}
+function rsvpStateRoot(agentRoot) {
+    return path.join(agentRoot, "state", "rsvp");
+}
+function latestSnapshotPath(agentRoot) {
+    return path.join(rsvpStateRoot(agentRoot), "snapshots", "latest.json");
+}
+function snapshotFilePath(agentRoot, snapshotId) {
+    return path.join(rsvpStateRoot(agentRoot), "snapshots", `${snapshotId}.json`);
+}
+function writeSnapshotFiles(agentRoot, snapshot) {
+    fs.mkdirSync(path.join(rsvpStateRoot(agentRoot), "snapshots"), { recursive: true });
+    fs.writeFileSync(snapshotFilePath(agentRoot, snapshot.snapshotId), `${JSON.stringify(snapshot, null, 2)}\n`, "utf-8");
+    fs.writeFileSync(latestSnapshotPath(agentRoot), `${JSON.stringify(snapshot, null, 2)}\n`, "utf-8");
+}
+const RSVP_HABIT_REPORT_LABEL_KEYS = [
+    "firstRunLabel",
+    "noChangesLabel",
+    "newRsvpsLabel",
+    "statusChangesLabel",
+    "newGuestsLabel",
+    "removedGuestsLabel",
+];
+function reportCopyFromHabit(title, rsvp) {
+    const copy = { title: rsvp.reportTitle ?? title };
+    for (const key of RSVP_HABIT_REPORT_LABEL_KEYS) {
+        const value = rsvp[key];
+        if (value)
+            copy[key] = value;
+    }
+    return copy;
+}
+function explicitHabitLifecycleError(habitName, habit, prefix) {
+    const degradedReason = habit.status === "degraded" ? habit.degradedReason : null;
+    const degradedDetail = habit.status === "degraded" ? habit.degradedDetail : null;
+    const reasonText = degradedReason ? ` reason=${degradedReason}` : "";
+    const detailText = degradedDetail ? ` detail=${degradedDetail}` : "";
+    const message = prefix
+        ? `${prefix}; status=${habit.status}${reasonText}${detailText}`
+        : `RSVP habit ${habitName} lifecycle rejected: status=${habit.status}${reasonText}${detailText}`;
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "rsvp",
+        event: "rsvp.habit_lifecycle_rejected",
+        message,
+        meta: {
+            entryPoint: "explicit_refresh",
+            habitName,
+            status: habit.status,
+            degradedReason,
+            degradedDetail,
+        },
+    });
+    return new Error(message);
+}
+function requireRsvpHabitReportCopy(agentRoot, habitName) {
+    const habitPath = path.join(agentRoot, "habits", `${habitName}.md`);
+    if (!fs.existsSync(habitPath)) {
+        const missing = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error", "", "habit file not found");
+        throw explicitHabitLifecycleError(habitName, missing, `RSVP habit ${habitName} not found at ${habitPath}`);
+    }
+    let habit;
+    try {
+        habit = (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath);
+    }
+    catch (error) {
+        const unreadable = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error", "", String(error));
+        throw explicitHabitLifecycleError(habitName, unreadable);
+    }
+    if (habit.status !== "active")
+        throw explicitHabitLifecycleError(habitName, habit);
+    if (!habit.rsvp) {
+        const untyped = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "invalid_metadata", habit.body, "RSVP habit metadata is required");
+        throw explicitHabitLifecycleError(habitName, untyped, `RSVP habit ${habitName} metadata is required before explicit refresh`);
+    }
+    return reportCopyFromHabit(habit.title, habit.rsvp);
+}
+function activeRsvpHabitReportCopy(agentRoot) {
+    const habitsDir = path.join(agentRoot, "habits");
+    if (!fs.existsSync(habitsDir))
+        return null;
+    for (const entry of fs.readdirSync(habitsDir).filter((name) => name.endsWith(".md")).sort()) {
+        const habitPath = path.join(habitsDir, entry);
+        try {
+            const habit = (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath);
+            if (habit.status === "active" && habit.rsvp && (0, habit_policy_1.isRsvpHabitName)(habit.name)) {
+                return reportCopyFromHabit(habit.title, habit.rsvp);
+            }
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "rsvp",
+                event: "rsvp.habit_report_copy_error",
+                message: "failed to read RSVP habit report copy",
+                meta: { habitPath, error: String(error) },
+            });
+        }
+    }
+    return null;
+}
+function resolveRsvpReportCopy(agentRoot, habitName) {
+    if (habitName)
+        return requireRsvpHabitReportCopy(agentRoot, habitName);
+    return activeRsvpHabitReportCopy(agentRoot) ?? {};
+}
+function parseSnapshotFromFile(filePath) {
+    const result = (0, snapshot_1.parseRsvpSnapshot)(readJsonFile(filePath));
+    if (!result.ok)
+        throw new Error(`invalid RSVP snapshot at ${filePath}: ${result.reason}`);
+    return result.snapshot;
+}
+function readBaselineSnapshot(agentRoot) {
+    const rsvpRoot = rsvpStateRoot(agentRoot);
+    const baselinePath = path.join(rsvpRoot, "baseline.json");
+    const legacyBaseline = fs.existsSync(baselinePath) ? readJsonFile(baselinePath) : null;
+    const legacySnapshotId = legacyBaseline && typeof legacyBaseline === "object" && !Array.isArray(legacyBaseline)
+        ? legacyBaseline.nativeSnapshotId
+        : null;
+    const outboundSnapshotId = (0, outbound_state_1.readRsvpOutboundState)(agentRoot).baseline?.snapshotId;
+    const snapshotId = outboundSnapshotId ?? (typeof legacySnapshotId === "string" ? legacySnapshotId : undefined);
+    return typeof snapshotId === "string" && fs.existsSync(snapshotFilePath(agentRoot, snapshotId))
+        ? parseSnapshotFromFile(snapshotFilePath(agentRoot, snapshotId))
+        : null;
+}
+function resolveLatestSnapshot(agentRoot) {
+    const filePath = latestSnapshotPath(agentRoot);
+    if (!fs.existsSync(filePath)) {
+        return { ok: false, path: filePath, message: "latest RSVP snapshot missing; run `ouro rsvp refresh --mode shadow --no-send` first" };
+    }
+    try {
+        return { ok: true, snapshot: parseSnapshotFromFile(filePath) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            path: filePath,
+            message: error instanceof Error ? error.message : /* v8 ignore next -- fs and snapshot parsing failures are Error instances. @preserve */ String(error),
+        };
+    }
+}
+function machineIdForCli() {
+    return (0, machine_identity_1.loadOrCreateMachineIdentity)().machineId;
+}
+async function resolveRsvpRuntimeCredentialConfig(agent) {
+    const cached = (0, runtime_credentials_1.readRuntimeCredentialConfig)(agent);
+    return cached.ok ? cached : (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(agent, { preserveCachedOnFailure: true });
+}
+async function resolveRsvpMachineRuntimeCredentialConfig(agent) {
+    const cached = (0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(agent);
+    return cached.ok ? cached : (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(agent, machineIdForCli(), { preserveCachedOnFailure: true });
+}
+function blueBubblesChatFor(config) {
+    const sendTarget = config.bluebubblesRoute.chatIdentifier
+        ? { kind: "chat_identifier", value: config.bluebubblesRoute.chatIdentifier }
+        : { kind: "chat_guid", value: config.bluebubblesRoute.chatGuid };
+    return {
+        chatGuid: config.bluebubblesRoute.chatGuid,
+        ...(config.bluebubblesRoute.chatIdentifier ? { chatIdentifier: config.bluebubblesRoute.chatIdentifier } : {}),
+        displayName: "RSVP",
+        isGroup: true,
+        sessionKey: `bluebubbles:rsvp:${config.bluebubblesRoute.chatIdentifier ?? config.bluebubblesRoute.chatGuid}`,
+        sendTarget,
+        participantHandles: [],
+    };
+}
+function numberField(record, key, fallback) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function stringArrayField(record, key) {
+    const value = record?.[key];
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
+}
+function recordField(record, key) {
+    const value = record[key];
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function rsvpBlueBubblesClientConfig(nativeConfig, machineRuntimeConfig) {
+    if (!machineRuntimeConfig.ok) {
+        throw new Error(`BlueBubbles runtime config unavailable at ${machineRuntimeConfig.itemPath}: ${machineRuntimeConfig.error}`);
+    }
+    const bluebubbles = recordField(machineRuntimeConfig.config, "bluebubbles");
+    const bluebubblesChannel = recordField(machineRuntimeConfig.config, "bluebubblesChannel");
+    const serverUrl = localText(bluebubbles?.serverUrl);
+    const password = localText(bluebubbles?.password);
+    if (!serverUrl) {
+        throw new Error("bluebubbles.serverUrl is required in this machine's agent-vault runtime config. Run `ouro connect bluebubbles --agent <agent>`.");
+    }
+    if (!password) {
+        throw new Error("bluebubbles.password is required in this machine's agent-vault runtime config. Run `ouro connect bluebubbles --agent <agent>`.");
+    }
+    return {
+        config: {
+            serverUrl,
+            password,
+            accountId: localText(bluebubbles?.accountId) || localText(nativeConfig.bluebubblesRoute.accountId) || "default",
+            ownHandles: stringArrayField(bluebubbles, "ownHandles"),
+        },
+        channelConfig: {
+            port: numberField(bluebubblesChannel, "port", 18790),
+            webhookPath: localText(bluebubblesChannel?.webhookPath) || "/bluebubbles-webhook",
+            requestTimeoutMs: numberField(bluebubblesChannel, "requestTimeoutMs", 30_000),
+        },
+    };
+}
+function normalizeDelivery(value) {
+    const record = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    return {
+        ...(typeof record.guid === "string" ? { guid: record.guid } : {}),
+        ...(typeof record.messageGuid === "string" ? { guid: record.messageGuid, messageGuid: record.messageGuid } : {}),
+    };
+}
+function textSummary(payload) {
+    const effect = payload.sideEffect ? "explicit side effects enabled" : "dry run";
+    const agent = payload.agent ? ` agent=${payload.agent}` : "";
+    const requires = payload.requires ? ` requires=${payload.requires}` : "";
+    return `${payload.command}: ${effect}${agent}${requires}`;
+}
+function writePayload(command, deps, payload) {
+    const outputPath = commandOutputPath(command);
+    if (outputPath)
+        writeJsonFile(outputPath, payload);
+    const text = commandJson(command) ? JSON.stringify(payload, null, 2) : textSummary(payload);
+    deps.writeStdout(text);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.cli_command_executed",
+        message: "executed RSVP CLI command",
+        meta: {
+            command: payload.command,
+            sideEffect: payload.sideEffect,
+            outputPath,
+            agent: payload.agent,
+        },
+    });
+    return text;
+}
+function writeIncidentText(deps, command, agent, bundle, outputPath) {
+    const text = command.json === true
+        ? JSON.stringify({
+            ok: bundle.doctor.summary.failed === 0,
+            command: command.kind,
+            agent,
+            sideEffect: false,
+            incidentBundle: bundle,
+        }, null, 2)
+        : `rsvp.incident: wrote side-effect-free bundle agent=${agent}${outputPath ? ` output=${outputPath}` : ""}`;
+    deps.writeStdout(text);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.cli_command_executed",
+        message: "executed RSVP CLI command",
+        meta: {
+            command: command.kind,
+            sideEffect: false,
+            outputPath,
+            agent,
+        },
+    });
+    return text;
+}
+function basePayload(command, sideEffect, message, extra = {}) {
+    return {
+        ok: true,
+        command: command.kind,
+        sideEffect,
+        ...(commandAgent(command) ? { agent: commandAgent(command) } : {}),
+        ...(commandMode(command) ? { mode: commandMode(command) } : {}),
+        message,
+        ...extra,
+    };
+}
+async function executeImportLegacy(command, deps) {
+    if (!command.yes) {
+        return basePayload(command, false, "legacy RSVP import preview only; pass --yes to write native config and runtime/config", {
+            requires: "--yes",
+            inputs: {
+                legacyRoot: command.legacyRoot,
+                mode: command.mode,
+            },
+        });
+    }
+    const agentRoot = maybeAgentRoot(command, deps);
+    if (!command.agent || !agentRoot) {
+        return {
+            ok: false,
+            command: command.kind,
+            sideEffect: false,
+            message: "legacy RSVP import requires --agent <name>",
+            requires: "--agent",
+        };
+    }
+    if (command.kind === "rsvp.import-legacy") {
+        const configResult = resolveRsvpConfig(agentRoot);
+        if (!configResult.ok) {
+            return {
+                ok: false,
+                command: command.kind,
+                sideEffect: false,
+                agent: command.agent,
+                message: configResult.message,
+                requires: "native RSVP config",
+            };
+        }
+        const result = (0, migration_1.importLegacyRsvpState)({
+            agent: command.agent,
+            agentRoot,
+            legacyRoot: command.legacyRoot,
+            weddingId: configResult.config.source.weddingId,
+            eventId: configResult.config.source.eventId,
+            importedAt: new Date().toISOString(),
+        });
+        return basePayload(command, true, result.ok ? "legacy RSVP state imported" : result.message, {
+            migration: result,
+        });
+    }
+    const result = await (0, config_1.importLegacyRsvpConfig)({
+        agent: command.agent,
+        agentRoot,
+        legacyRoot: command.legacyRoot,
+        mode: command.mode,
+        confirm: true,
+    });
+    return basePayload(command, true, result.ok ? "legacy RSVP config imported" : result.message, {
+        result: result,
+    });
+}
+async function executeCutover(command, deps) {
+    const result = await (0, cutover_1.runRsvpCutover)({
+        ...(command.agent ? { agent: command.agent } : {}),
+        legacyRoot: command.legacyRoot,
+        action: command.action,
+        yes: command.yes === true,
+        ...(deps.rsvpCutoverDeps ? { deps: deps.rsvpCutoverDeps } : {}),
+    });
+    return {
+        ok: result.ok,
+        command: command.kind,
+        sideEffect: result.sideEffect,
+        ...(command.agent ? { agent: command.agent } : {}),
+        action: result.action,
+        legacyRoot: result.legacyRoot,
+        message: result.message,
+        ...(result.requires ? { requires: result.requires } : {}),
+        checks: result.checks,
+        sendAllowed: result.sendAllowed,
+        denialReasons: result.denialReasons,
+        rollback: result.rollback,
+    };
+}
+function doctorDepsFor(deps) {
+    const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    return {
+        existsSync: (filePath) => fs.existsSync(filePath),
+        readFileSync: (filePath) => fs.readFileSync(filePath, "utf-8"),
+        readdirSync: (dirPath) => fs.readdirSync(dirPath),
+        statSync: fs.statSync,
+        checkSocketAlive: deps.checkSocketAlive,
+        fetchImpl: deps.fetchImpl ?? fetch,
+        socketPath: deps.socketPath,
+        bundlesRoot,
+        daemonLogsDir: path.join(deps.homeDir ?? os.homedir(), ".ouro-cli", "daemon", "logs"),
+        homedir: deps.homeDir ?? os.homedir(),
+        envPath: process.env.PATH ?? "",
+        platform: process.platform,
+        ...(deps.rsvpCutoverDeps ? { rsvpCutoverDeps: deps.rsvpCutoverDeps } : {}),
+    };
+}
+async function executeDoctor(command, deps) {
+    const doctor = await (0, doctor_1.runDoctorChecks)(doctorDepsFor(deps), { category: "RSVP" });
+    const ok = doctor.summary.warnings === 0 && doctor.summary.failed === 0;
+    if (command.strict && !ok)
+        deps.setExitCode?.(1);
+    return basePayload(command, false, ok ? "RSVP doctor checks passed" : "RSVP doctor checks found issues", {
+        ok,
+        inputs: { strict: command.strict === true },
+        doctor: doctor,
+        strict: command.strict === true,
+    });
+}
+async function executeIncident(command, deps) {
+    const agentRoot = maybeAgentRoot(command, deps);
+    if (!command.agent || !agentRoot) {
+        return writePayload(command, deps, {
+            ok: false,
+            command: command.kind,
+            sideEffect: false,
+            message: "RSVP incident bundle requires --agent <name>",
+            requires: "--agent",
+        });
+    }
+    const diagnosticsDeps = {
+        existsSync: (filePath) => fs.existsSync(filePath),
+        readFileSync: (filePath) => fs.readFileSync(filePath, "utf-8"),
+        readdirSync: (dirPath) => fs.readdirSync(dirPath),
+        statSync: fs.statSync,
+        checkSocketAlive: deps.checkSocketAlive,
+        runDoctorChecks: () => (0, doctor_1.runDoctorChecks)(doctorDepsFor(deps), { category: "RSVP" }),
+    };
+    const outputPath = commandOutputPath(command);
+    const bundle = outputPath
+        ? (await (0, incident_bundle_1.writeRsvpIncidentBundle)({ agent: command.agent, agentRoot, outputPath, deps: diagnosticsDeps })).bundle
+        : await (0, incident_bundle_1.buildRsvpIncidentBundle)({ agent: command.agent, agentRoot, deps: diagnosticsDeps });
+    return writeIncidentText(deps, command, command.agent, bundle, outputPath);
+}
+async function executeLegacyRender(command, deps) {
+    const outputPath = command.outputPath ?? path.join(os.tmpdir(), `ouro-rsvp-legacy-render-${process.pid}-${Date.now()}.json`);
+    const result = await (0, replay_1.renderLegacyRsvpSnapshotOffline)({ legacyRoot: command.legacyRoot, outputPath });
+    const text = command.json
+        ? JSON.stringify({ ok: true, command: command.kind, sideEffect: false, result }, null, 2)
+        : `rsvp.legacy-render: wrote side-effect-free render output=${outputPath}`;
+    deps.writeStdout(text);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.cli_command_executed",
+        message: "executed RSVP CLI command",
+        meta: { command: command.kind, sideEffect: false, outputPath, agent: command.agent },
+    });
+    return text;
+}
+async function executeReplay(command) {
+    const replay = await (0, replay_1.replayRsvpFixture)({ fixturePath: command.fixturePath });
+    return basePayload(command, false, "RSVP replay fixture executed offline", {
+        replay: replay,
+    });
+}
+async function executeHabitStage(command, deps) {
+    const agentRoot = maybeAgentRoot(command, deps);
+    if (!command.agent || !agentRoot) {
+        return {
+            ok: false,
+            command: command.kind,
+            sideEffect: false,
+            message: "RSVP habit staging requires --agent <name>",
+            requires: "--agent",
+        };
+    }
+    const result = await (0, habit_stage_1.stageRsvpHabit)({
+        agent: command.agent,
+        agentRoot,
+        ...(command.habitName ? { habitName: command.habitName } : {}),
+        ...(command.title ? { title: command.title } : {}),
+        ...(command.reportTitle ? { reportTitle: command.reportTitle } : {}),
+        mode: command.mode,
+        cadence: command.cadence,
+    });
+    return basePayload(command, true, "native RSVP habit staged", {
+        habit: result,
+    });
+}
+async function executeRefreshInner(command, deps, transportCounter, hardNoSend) {
+    const agentRoot = maybeAgentRoot(command, deps);
+    if (!command.agent || !agentRoot) {
+        return {
+            ok: false,
+            command: command.kind,
+            sideEffect: false,
+            message: "RSVP refresh requires --agent <name>",
+            requires: "--agent",
+        };
+    }
+    const reportCopy = resolveRsvpReportCopy(agentRoot, command.habitName);
+    const configResult = resolveRsvpConfig(agentRoot);
+    if (!configResult.ok) {
+        return basePayload(command, false, "RSVP refresh requires native RSVP config before live work can run", {
+            requires: "native RSVP config",
+            result: configResult,
+        });
+    }
+    const runtimeConfig = await resolveRsvpRuntimeCredentialConfig(command.agent);
+    const machineRuntimeConfig = await resolveRsvpMachineRuntimeCredentialConfig(command.agent);
+    const readiness = (0, config_1.validateRsvpReadiness)({
+        agent: command.agent,
+        agentRoot,
+        config: configResult,
+        runtimeConfig,
+        machineRuntimeConfig,
+    });
+    const readinessOk = readiness.ok === true || readiness.status === "ready";
+    if (!readinessOk) {
+        return {
+            ok: false,
+            command: command.kind,
+            sideEffect: false,
+            agent: command.agent,
+            mode: command.mode,
+            message: "RSVP refresh blocked by readiness checks",
+            checks: { readiness: readiness },
+        };
+    }
+    const credentials = "credentials" in readiness
+        ? readiness.credentials
+        : { username: "", password: "" };
+    const fetched = await (0, aisleplanner_client_1.fetchAislePlannerRsvps)({
+        agent: command.agent,
+        weddingId: configResult.config.source.weddingId,
+        eventId: configResult.config.source.eventId,
+        credentials,
+        ...(deps.fetchImpl ? { fetchFn: deps.fetchImpl } : {}),
+    });
+    if (!fetched.ok) {
+        return {
+            ok: false,
+            command: command.kind,
+            sideEffect: false,
+            agent: command.agent,
+            mode: command.mode,
+            message: fetched.message,
+            result: fetched,
+        };
+    }
+    const previousSnapshot = readBaselineSnapshot(agentRoot);
+    const currentSnapshot = (0, snapshot_1.buildRsvpSnapshot)({
+        agent: command.agent,
+        fetchedAt: fetched.fetchedAt,
+        source: {
+            kind: "aisleplanner",
+            weddingId: configResult.config.source.weddingId,
+            eventId: configResult.config.source.eventId,
+            adapter: "aisleplanner-api-v1",
+        },
+        guests: fetched.guests,
+        allGuests: fetched.allGuests,
+        provenance: { kind: "live-fetch", fetchedBy: "ouro rsvp refresh" },
+    });
+    writeSnapshotFiles(agentRoot, currentSnapshot);
+    const delta = (0, diff_renderer_1.computeRsvpDelta)(previousSnapshot, currentSnapshot);
+    const reportText = (0, diff_renderer_1.renderRsvpReport)(delta, reportCopy);
+    const outboundDecision = (0, outbound_state_1.decideRsvpOutboundReport)({ agentRoot, currentSnapshot, reportText });
+    const requestedLiveSend = command.mode === "live" && command.allowSend === true && outboundDecision.action === "send";
+    const sendAllowedBeforeCutover = requestedLiveSend && !hardNoSend;
+    if (sendAllowedBeforeCutover) {
+        const cutover = await checkLiveSendCutover({
+            agent: command.agent,
+            config: configResult.config,
+            deps,
+        });
+        if (cutover?.sendAllowed !== true) {
+            return blockedLiveSendPayload(command, "RSVP live refresh send blocked by cutover gates", {
+                ...cutoverPayload(cutover),
+                refresh: {
+                    snapshotId: currentSnapshot.snapshotId,
+                    reportText,
+                    outboundDecision: outboundDecision,
+                },
+            });
+        }
+    }
+    const sendAllowed = requestedLiveSend && !hardNoSend;
+    let delivery;
+    let sendBoundary;
+    let sendBoundaryMessage;
+    if (sendAllowed) {
+        if (!command.habitName) {
+            return {
+                ...basePayload(command, false, "RSVP live refresh send requires --habit <name>", {
+                    allowSend: true,
+                    sendAllowed: false,
+                    requires: "--habit <name>",
+                    refresh: {
+                        snapshotId: currentSnapshot.snapshotId,
+                        reportText,
+                        outboundDecision: outboundDecision,
+                    },
+                }),
+                ok: false,
+            };
+        }
+        const bluebubbles = rsvpBlueBubblesClientConfig(configResult.config, machineRuntimeConfig);
+        const client = (0, client_1.createBlueBubblesClient)(bluebubbles.config, bluebubbles.channelConfig);
+        sendBoundary = await (0, outbound_state_1.executeRsvpSendBoundary)({
+            agentRoot,
+            habitId: command.habitName,
+            outboundIdempotencyKey: outboundDecision.idempotencyKey,
+            noSend: hardNoSend,
+            invokeTransport: async (markTransportInvoked) => client.sendText({
+                chat: blueBubblesChatFor(configResult.config),
+                text: reportText,
+                tempGuid: outboundDecision.idempotencyKey,
+                onTransportInvocation: () => {
+                    transportCounter.count += 1;
+                    markTransportInvoked();
+                },
+            }),
+        }, deps.rsvpSendBoundaryDeps);
+        const cleanupFailed = sendBoundary.errorCode === "lifecycle_lock_release_failed";
+        const acceptedProof = sendBoundary.boundaryState === "crossed" && !cleanupFailed;
+        sendBoundaryMessage = cleanupFailed
+            ? "RSVP transport crossed but lifecycle lock cleanup failed"
+            : sendBoundary.boundaryState === "crossed"
+                ? "RSVP refresh completed"
+                : sendBoundary.boundaryState === "not_crossed"
+                    ? "RSVP transport was definitively rejected"
+                    : "RSVP transport delivery is unknown";
+        delivery = acceptedProof
+            ? {
+                status: "accepted",
+                ...normalizeDelivery({ messageGuid: sendBoundary.transportResult.messageGuid }),
+            }
+            : cleanupFailed
+                ? {
+                    status: "failed",
+                    error: sendBoundaryMessage,
+                    ...normalizeDelivery({ messageGuid: sendBoundary.transportResult.messageGuid }),
+                }
+                : sendBoundary.boundaryState === "not_crossed"
+                    ? { status: "failed", error: sendBoundaryMessage }
+                    : { status: "pending-manual-verification", error: sendBoundaryMessage };
+        (0, outbound_state_1.recordRsvpOutboundAttempt)({
+            agentRoot,
+            currentSnapshot,
+            reportText,
+            bluebubblesRecord: {
+                recordId: outboundDecision.idempotencyKey,
+                status: acceptedProof
+                    ? "accepted"
+                    : sendBoundary.boundaryState === "not_crossed" || cleanupFailed
+                        ? "failed"
+                        : "pending-manual-verification",
+                tempGuid: outboundDecision.idempotencyKey,
+                ...(sendBoundary.transportResult.messageGuid
+                    ? { messageGuid: sendBoundary.transportResult.messageGuid }
+                    : {}),
+            },
+            recordedAt: new Date().toISOString(),
+        });
+    }
+    const message = sendBoundaryMessage ?? "RSVP refresh completed";
+    const payload = basePayload(command, sendBoundary?.transportInvoked === true && sendBoundary.replayed === false, message, {
+        allowSend: command.mode === "live" && command.allowSend === true,
+        sendAllowed,
+        ...(sendBoundary ? { sendBoundary: sendBoundary } : {}),
+        refresh: {
+            snapshotId: currentSnapshot.snapshotId,
+            reportText,
+            outboundDecision: outboundDecision,
+            ...(delivery ? { delivery } : {}),
+        },
+    });
+    return sendBoundary && !sendBoundary.ok ? { ...payload, ok: false } : payload;
+}
+async function executeRefresh(command, deps) {
+    const transportCounter = { count: 0 };
+    const hardNoSend = command.noSend === true;
+    const payload = await executeRefreshInner(command, deps, transportCounter, hardNoSend);
+    return {
+        ...payload,
+        ...(hardNoSend ? { noSend: true } : {}),
+        transportInvocationCount: transportCounter.count,
+    };
+}
+async function executeCompare(command) {
+    if (!fs.existsSync(command.nativePath) || !fs.existsSync(command.legacyPath)) {
+        return basePayload(command, false, "RSVP compare requires readable native and legacy snapshot files", {
+            requires: "readable snapshots",
+            inputs: { nativePath: command.nativePath, legacyPath: command.legacyPath },
+        });
+    }
+    const nativeSnapshot = parseSnapshotFromFile(command.nativePath);
+    const legacySnapshot = parseSnapshotFromFile(command.legacyPath);
+    const delta = (0, diff_renderer_1.computeRsvpDelta)(legacySnapshot, nativeSnapshot);
+    const reportText = (0, diff_renderer_1.renderRsvpReport)(delta);
+    return basePayload(command, false, "RSVP native/legacy comparison completed", {
+        compare: {
+            nativeSnapshotId: nativeSnapshot.snapshotId,
+            legacySnapshotId: legacySnapshot.snapshotId,
+            reportText,
+            delta: delta,
+        },
+    });
+}
+async function executeSmoke(command, deps) {
+    const agentRoot = maybeAgentRoot(command, deps);
+    if (!command.agent || !agentRoot) {
+        return {
+            ok: false,
+            command: command.kind,
+            sideEffect: false,
+            message: "RSVP smoke requires --agent <name>",
+            requires: "--agent",
+        };
+    }
+    const configResult = resolveRsvpConfig(agentRoot);
+    if (!configResult.ok) {
+        return basePayload(command, command.allowSend === true, "RSVP smoke requires native RSVP config before follow-up can run", {
+            allowSend: command.allowSend === true,
+            sendAllowed: false,
+            requires: "native RSVP config",
+            result: configResult,
+        });
+    }
+    const snapshotResult = resolveLatestSnapshot(agentRoot);
+    if (!snapshotResult.ok) {
+        return {
+            ...basePayload(command, false, "RSVP smoke requires latest RSVP snapshot before follow-up can run", {
+                allowSend: command.allowSend === true,
+                sendAllowed: false,
+                requires: "latest RSVP snapshot",
+                result: snapshotResult,
+            }),
+            ok: false,
+        };
+    }
+    const snapshot = snapshotResult.snapshot;
+    const question = command.question ?? "who is pending?";
+    const answer = (0, query_1.queryRsvpSnapshot)(snapshot, { query: question });
+    const wantsLiveSend = command.mode === "live" && command.allowSend === true;
+    if (wantsLiveSend) {
+        const cutover = await checkLiveSendCutover({
+            agent: command.agent,
+            config: configResult.config,
+            deps,
+        });
+        if (cutover?.sendAllowed !== true) {
+            const blocked = blockedLiveSendPayload(command, "RSVP live smoke send blocked by cutover gates", {
+                ...cutoverPayload(cutover),
+                answer: answer.text,
+                result: answer,
+            });
+            if (command.replayOutputPath)
+                writeJsonFile(command.replayOutputPath, blocked);
+            return blocked;
+        }
+    }
+    const sendAllowed = wantsLiveSend;
+    let delivery;
+    if (sendAllowed) {
+        const bluebubbles = rsvpBlueBubblesClientConfig(configResult.config, await resolveRsvpMachineRuntimeCredentialConfig(command.agent));
+        const sent = await (0, client_1.createBlueBubblesClient)(bluebubbles.config, bluebubbles.channelConfig).sendText({
+            chat: blueBubblesChatFor(configResult.config),
+            text: answer.text,
+        });
+        delivery = normalizeDelivery(sent);
+    }
+    const payload = basePayload(command, sendAllowed, sendAllowed ? "RSVP live smoke completed" : "RSVP smoke preflight completed", {
+        allowSend: sendAllowed,
+        sendAllowed,
+        answer: answer.text,
+        result: answer,
+        ...(delivery ? { delivery } : {}),
+    });
+    if (command.replayOutputPath)
+        writeJsonFile(command.replayOutputPath, payload);
+    return payload;
+}
+function plannedPayload(command) {
+    throw new Error(`unsupported RSVP CLI command: ${String(command.kind)}`);
+}
+async function runRsvpCliCommand(command, deps) {
+    if (command.kind === "rsvp.incident")
+        return executeIncident(command, deps);
+    if (command.kind === "rsvp.legacy-render")
+        return executeLegacyRender(command, deps);
+    const payload = command.kind === "rsvp.config.import-legacy" || command.kind === "rsvp.import-legacy"
+        ? await executeImportLegacy(command, deps)
+        : command.kind === "rsvp.cutover"
+            ? await executeCutover(command, deps)
+            : command.kind === "rsvp.doctor"
+                ? await executeDoctor(command, deps)
+                : command.kind === "rsvp.replay"
+                    ? await executeReplay(command)
+                    : command.kind === "rsvp.habit.stage"
+                        ? await executeHabitStage(command, deps)
+                        : command.kind === "rsvp.refresh"
+                            ? await executeRefresh(command, deps)
+                            : command.kind === "rsvp.compare"
+                                ? await executeCompare(command)
+                                : command.kind === "rsvp.smoke"
+                                    ? await executeSmoke(command, deps)
+                                    : plannedPayload(command);
+    return writePayload(command, deps, payload);
+}