@ouro.bot/cli 0.1.0-alpha.70 → 0.1.0-alpha.700

package/dist/rsvp/cli.js

@@ -0,0 +1,704 @@
+"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 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_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");
+}
+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 baselinePath = path.join(rsvpStateRoot(agentRoot), "baseline.json");
+    if (!fs.existsSync(baselinePath))
+        return null;
+    const baseline = readJsonFile(baselinePath);
+    const snapshotId = baseline && typeof baseline === "object" && !Array.isArray(baseline)
+        ? baseline.nativeSnapshotId
+        : null;
+    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;
+}
+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 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 = (0, habit_stage_1.stageRsvpHabit)({
+        agent: command.agent,
+        agentRoot,
+        mode: command.mode,
+        cadence: command.cadence,
+    });
+    return basePayload(command, true, "native RSVP habit staged", {
+        habit: result,
+    });
+}
+async function executeRefresh(command, deps) {
+    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 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 (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(command.agent, { preserveCachedOnFailure: true });
+    const machineRuntimeConfig = await (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(command.agent, machineIdForCli(), { preserveCachedOnFailure: true });
+    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);
+    const outboundDecision = (0, outbound_state_1.decideRsvpOutboundReport)({ agentRoot, currentSnapshot, reportText });
+    const wantsLiveSend = command.mode === "live" && command.allowSend === true && outboundDecision.action === "send";
+    if (wantsLiveSend) {
+        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 = wantsLiveSend;
+    let delivery;
+    if (sendAllowed) {
+        const sent = await (0, client_1.createBlueBubblesClient)().sendText({
+            chat: blueBubblesChatFor(configResult.config),
+            text: reportText,
+            tempGuid: outboundDecision.idempotencyKey,
+        });
+        delivery = normalizeDelivery(sent);
+        (0, outbound_state_1.recordRsvpOutboundAttempt)({
+            agentRoot,
+            currentSnapshot,
+            reportText,
+            bluebubblesRecord: {
+                recordId: outboundDecision.idempotencyKey,
+                status: "accepted",
+                tempGuid: outboundDecision.idempotencyKey,
+                ...(delivery.guid ? { messageGuid: String(delivery.guid) } : {}),
+            },
+            recordedAt: new Date().toISOString(),
+        });
+    }
+    return basePayload(command, sendAllowed, "RSVP refresh completed", {
+        allowSend: sendAllowed,
+        sendAllowed,
+        refresh: {
+            snapshotId: currentSnapshot.snapshotId,
+            reportText,
+            outboundDecision: outboundDecision,
+            ...(delivery ? { delivery } : {}),
+        },
+    });
+}
+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 sent = await (0, client_1.createBlueBubblesClient)().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);
+}