@ouro.bot/cli 0.1.0-alpha.696 → 0.1.0-alpha.698

package/dist/heart/daemon/cli-exec.js

@@ -126,10 +126,26 @@ const DEFAULT_DAEMON_STARTUP_POLL_INTERVAL_MS = 500;
 const DEFAULT_DAEMON_STARTUP_STABILITY_WINDOW_MS = 1_500;
 const DEFAULT_DAEMON_STARTUP_RETRY_LIMIT = 1;
 const DEFAULT_DAEMON_STARTUP_LOG_LINES = 10;
+const RSVP_CLI_KINDS = new Set([
+    "rsvp.doctor",
+    "rsvp.incident",
+    "rsvp.cutover",
+    "rsvp.legacy-render",
+    "rsvp.replay",
+    "rsvp.config.import-legacy",
+    "rsvp.habit.stage",
+    "rsvp.import-legacy",
+    "rsvp.refresh",
+    "rsvp.compare",
+    "rsvp.smoke",
+]);
 const CONNECT_PROVIDER_ORIENTATION_PING_OPTIONS = {
     attemptPolicy: { maxAttempts: 1, baseDelayMs: 0, backoffMultiplier: 2 },
     timeoutMs: 5_000,
 };
+function isRsvpCliCommand(command) {
+    return RSVP_CLI_KINDS.has(command.kind);
+}
 function summarizeCliUpdateCheckStatus(error, timedOut = false) {
     const normalized = error.trim().toLowerCase();
     if (timedOut || normalized.includes("timed out") || normalized.includes("abort")) {
@@ -6027,6 +6043,10 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         deps.writeStdout(text);
         return text;
     }
+    if (isRsvpCliCommand(command)) {
+        const { runRsvpCliCommand } = await Promise.resolve().then(() => __importStar(require("../../rsvp/cli")));
+        return runRsvpCliCommand(command, deps);
+    }
     if (command.kind === "connect") {
         return executeConnect(command, deps);
     }

package/dist/heart/daemon/cli-help.js

@@ -144,6 +144,25 @@ exports.COMMAND_REGISTRY = {
         example: "ouro habit list",
         subcommands: ["list", "create", "runs", "inspect", "summary", "poke"],
     },
+    rsvp: {
+        category: "Habits",
+        description: "AislePlanner-backed RSVP habit operations, triage, receipts, ledgers, migration checks, refreshes, and smoke tests",
+        usage: "ouro rsvp <doctor|incident|cutover|legacy-render|replay|config|habit|import-legacy|refresh|compare|smoke> ...",
+        example: "ouro rsvp doctor --agent slugger --json",
+        subcommands: [
+            "doctor",
+            "incident",
+            "cutover",
+            "legacy-render",
+            "replay",
+            "config import-legacy",
+            "habit stage",
+            "import-legacy",
+            "refresh",
+            "compare",
+            "smoke",
+        ],
+    },
     desk: {
         category: "Tasks",
         description: "Manage the agent's desk — tasks, tracks, friction, lessons, search, and recall (routes through the desk MCP server).",
@@ -431,6 +450,61 @@ const SUBCOMMAND_HELP = {
         usage: "ouro habit summary [--agent <name>] (--run-id <id>|--habit <name>|--operation-id <id>) [--which latest|previous|latest-success|latest-failure] [--json]",
         example: "ouro habit summary --agent slugger --operation-id habit:standup --which latest --json",
     },
+    "rsvp doctor": {
+        description: "Check native RSVP configuration, credentials, BlueBubbles attachment, ledgers, receipts, and migration readiness without sending messages; use --json --strict in triage",
+        usage: "ouro rsvp doctor [--agent <name>] [--strict] [--output <path>] [--json]",
+        example: "ouro rsvp doctor --agent slugger --strict --json",
+    },
+    "rsvp incident": {
+        description: "Collect a redacted local RSVP diagnostic incident bundle with doctor status, receipts, and ledger pointers without contacting the daemon",
+        usage: "ouro rsvp incident [--agent <name>] [--output <path>] [--json]",
+        example: "ouro rsvp incident --agent slugger --output /tmp/rsvp-incident.json",
+    },
+    "rsvp cutover": {
+        description: "Inspect or retire legacy RSVP sender state before native live send",
+        usage: "ouro rsvp cutover [--agent <name>] --legacy-root <path> --action check|quarantine-launchd|retire-legacy-send-config [--yes] [--output <path>] [--json]",
+        example: "ouro rsvp cutover --agent slugger --legacy-root ~/Projects/rsvp-tracker --action check --json",
+    },
+    "rsvp legacy-render": {
+        description: "Render the legacy RSVP script's local snapshot/report shape for comparison without mutating native state",
+        usage: "ouro rsvp legacy-render --legacy-root <path> [--agent <name>] [--output <path>] [--json]",
+        example: "ouro rsvp legacy-render --legacy-root ~/Projects/rsvp-tracker --output /tmp/legacy.json",
+    },
+    "rsvp replay": {
+        description: "Replay an offline fixture through deterministic native RSVP report/query logic without live BlueBubbles or AislePlanner access",
+        usage: "ouro rsvp replay [--agent <name>] --fixture <path> [--output <path>] [--json]",
+        example: "ouro rsvp replay --agent slugger --fixture /tmp/rsvp-replay.json --json",
+    },
+    "rsvp config import-legacy": {
+        description: "Import legacy RSVP coordinates into native config and vault-backed runtime/config; mutates only with --yes",
+        usage: "ouro rsvp config import-legacy [--agent <name>] --legacy-root <path> --mode shadow|live [--yes] [--output <path>] [--json]",
+        example: "ouro rsvp config import-legacy --agent slugger --legacy-root ~/Projects/rsvp-tracker --mode shadow --yes",
+    },
+    "rsvp habit stage": {
+        description: "Stage the daily RSVP refresh habit with a fixed cron cadence, usually the 10 AM dogfood run",
+        usage: "ouro rsvp habit stage [--agent <name>] --mode shadow|live --cadence '<cron>' [--output <path>] [--json]",
+        example: "ouro rsvp habit stage --agent slugger --mode shadow --cadence '0 10 * * *'",
+    },
+    "rsvp import-legacy": {
+        description: "Compatibility alias for `ouro rsvp config import-legacy`; mutates only with --yes",
+        usage: "ouro rsvp import-legacy [--agent <name>] --legacy-root <path> --mode shadow|live [--yes] [--output <path>] [--json]",
+        example: "ouro rsvp import-legacy --agent slugger --legacy-root ~/Projects/rsvp-tracker --mode shadow --yes",
+    },
+    "rsvp refresh": {
+        description: "Run the native RSVP refresh path and write receipts; defaults to dry-run behavior unless --allow-send is explicit",
+        usage: "ouro rsvp refresh [--agent <name>] --mode shadow|live [--no-send|--allow-send] [--output <path>] [--json]",
+        example: "ouro rsvp refresh --agent slugger --mode shadow --no-send --json",
+    },
+    "rsvp compare": {
+        description: "Compare native and legacy RSVP render outputs for migration verification",
+        usage: "ouro rsvp compare [--agent <name>] --native <path> --legacy <path> [--output <path>] [--json]",
+        example: "ouro rsvp compare --agent slugger --native /tmp/native.json --legacy /tmp/legacy.json",
+    },
+    "rsvp smoke": {
+        description: "Smoke-test RSVP follow-up behavior through a target sense; preflight is no-send and live mode requires --allow-send",
+        usage: "ouro rsvp smoke [--agent <name>] --mode preflight|live --surface bluebubbles [--question <text>] [--allow-send] [--output <path>] [--replay-output <path>] [--json]",
+        example: "ouro rsvp smoke --agent slugger --mode preflight --surface bluebubbles --question 'who is pending?'",
+    },
     "mail import-mbox": {
         description: "Import a HEY or other MBOX export into an existing delegated Mailroom source grant",
         usage: "ouro mail import-mbox (--file <path>|--discover) [--owner-email <email>] [--source <label>] [--agent <name>] [--foreground]",

package/dist/heart/daemon/cli-parse.js

@@ -114,6 +114,7 @@ function usage() {
         "  ouro habit summary [--agent <name>] (--run-id <id>|--habit <name>|--operation-id <id>) [--which latest|previous|latest-success|latest-failure] [--json]",
         "  ouro link <agent> --friend <id> --provider <provider> --external-id <external-id>",
         "  ouro bluebubbles replay [--agent <name>] --message-guid <guid> [--event-type new-message|updated-message] [--json]",
+        "  ouro rsvp <doctor|incident|cutover|legacy-render|replay|config|habit|import-legacy|refresh|compare|smoke> ...",
         "  ouro friend list [--agent <name>]",
         "  ouro friend show <id> [--agent <name>]",
         "  ouro friend create --name <name> [--trust <level>] [--agent <name>]",
@@ -1681,6 +1682,469 @@ function parseBlueBubblesCommand(args) {
         ...(json ? { json: true } : {}),
     };
 }
+const RSVP_USAGE = "Usage: ouro rsvp <doctor|incident|cutover|legacy-render|replay|config|habit|import-legacy|refresh|compare|smoke> ...";
+function isRsvpMode(value) {
+    return value === "shadow" || value === "live";
+}
+function isRsvpCutoverAction(value) {
+    return value === "check" || value === "quarantine-launchd" || value === "retire-legacy-send-config";
+}
+function isRsvpSmokeMode(value) {
+    return value === "preflight" || value === "live";
+}
+function isRsvpSmokeSurface(value) {
+    return value === "bluebubbles";
+}
+function rsvpPath(value, label) {
+    const trimmed = value.trim();
+    if (!trimmed || /[\r\n\t]/.test(trimmed))
+        throw new Error(`rsvp ${label} requires a non-empty path`);
+    return trimmed;
+}
+function validRsvpCronCadence(value) {
+    const fields = value.trim().split(/\s+/);
+    return fields.length === 5 && fields.every((field) => field.length > 0);
+}
+function parseRsvpCommand(args) {
+    const subcommand = args[0];
+    if (!subcommand)
+        throw new Error(RSVP_USAGE);
+    if (subcommand === "config") {
+        const nested = args[1];
+        if (nested !== "import-legacy")
+            throw new Error("Usage: ouro rsvp config import-legacy [--agent <name>] --legacy-root <path> --mode shadow|live [--yes] [--output <path>] [--json]");
+        return parseRsvpImportLegacyCommand(args.slice(2), "rsvp.config.import-legacy");
+    }
+    if (subcommand === "habit") {
+        const nested = args[1];
+        if (nested !== "stage")
+            throw new Error("Usage: ouro rsvp habit stage [--agent <name>] --mode shadow|live --cadence '<cron>' [--output <path>] [--json]");
+        return parseRsvpHabitStageCommand(args.slice(2));
+    }
+    if (subcommand === "doctor")
+        return parseRsvpDoctorCommand(args.slice(1));
+    if (subcommand === "incident")
+        return parseRsvpIncidentCommand(args.slice(1));
+    if (subcommand === "cutover")
+        return parseRsvpCutoverCommand(args.slice(1));
+    if (subcommand === "legacy-render")
+        return parseRsvpLegacyRenderCommand(args.slice(1));
+    if (subcommand === "replay")
+        return parseRsvpReplayCommand(args.slice(1));
+    if (subcommand === "import-legacy")
+        return parseRsvpImportLegacyCommand(args.slice(1), "rsvp.import-legacy");
+    if (subcommand === "refresh")
+        return parseRsvpRefreshCommand(args.slice(1));
+    if (subcommand === "compare")
+        return parseRsvpCompareCommand(args.slice(1));
+    if (subcommand === "smoke")
+        return parseRsvpSmokeCommand(args.slice(1));
+    throw new Error(RSVP_USAGE);
+}
+function parseRsvpDoctorCommand(args) {
+    const { agent, rest } = extractAgentFlag(args);
+    let json = false;
+    let strict = false;
+    let outputPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--strict") {
+            strict = true;
+            continue;
+        }
+        if (token === "--output" && rest[i + 1]) {
+            outputPath = rsvpPath(rest[++i], "--output");
+            continue;
+        }
+        throw new Error("Usage: ouro rsvp doctor [--agent <name>] [--strict] [--output <path>] [--json]");
+    }
+    return {
+        kind: "rsvp.doctor",
+        ...(agent ? { agent } : {}),
+        ...(json ? { json: true } : {}),
+        ...(strict ? { strict: true } : {}),
+        ...(outputPath ? { outputPath } : {}),
+    };
+}
+function parseRsvpIncidentCommand(args) {
+    const { agent, rest } = extractAgentFlag(args);
+    let json = false;
+    let outputPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--output" && rest[i + 1]) {
+            outputPath = rsvpPath(rest[++i], "--output");
+            continue;
+        }
+        throw new Error("Usage: ouro rsvp incident [--agent <name>] [--output <path>] [--json]");
+    }
+    return {
+        kind: "rsvp.incident",
+        ...(agent ? { agent } : {}),
+        ...(json ? { json: true } : {}),
+        ...(outputPath ? { outputPath } : {}),
+    };
+}
+function parseRsvpCutoverCommand(args) {
+    const { agent, rest } = extractAgentFlag(args);
+    let legacyRoot;
+    let action;
+    let yes = false;
+    let json = false;
+    let outputPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--legacy-root" && rest[i + 1]) {
+            legacyRoot = rsvpPath(rest[++i], "--legacy-root");
+            continue;
+        }
+        if (token === "--action" && rest[i + 1]) {
+            const value = rest[++i];
+            if (!isRsvpCutoverAction(value))
+                throw new Error("rsvp cutover --action must be check, quarantine-launchd, or retire-legacy-send-config");
+            action = value;
+            continue;
+        }
+        if (token === "--yes") {
+            yes = true;
+            continue;
+        }
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--output" && rest[i + 1]) {
+            outputPath = rsvpPath(rest[++i], "--output");
+            continue;
+        }
+        throw new Error("Usage: ouro rsvp cutover [--agent <name>] --legacy-root <path> --action check|quarantine-launchd|retire-legacy-send-config [--yes] [--output <path>] [--json]");
+    }
+    if (!legacyRoot)
+        throw new Error("rsvp cutover requires --legacy-root <path>");
+    if (!action)
+        throw new Error("rsvp cutover requires --action check|quarantine-launchd|retire-legacy-send-config");
+    return {
+        kind: "rsvp.cutover",
+        ...(agent ? { agent } : {}),
+        legacyRoot,
+        action,
+        ...(yes ? { yes: true } : {}),
+        ...(json ? { json: true } : {}),
+        ...(outputPath ? { outputPath } : {}),
+    };
+}
+function parseRsvpLegacyRenderCommand(args) {
+    const { agent, rest } = extractAgentFlag(args);
+    let legacyRoot;
+    let json = false;
+    let outputPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--legacy-root" && rest[i + 1]) {
+            legacyRoot = rsvpPath(rest[++i], "--legacy-root");
+            continue;
+        }
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--output" && rest[i + 1]) {
+            outputPath = rsvpPath(rest[++i], "--output");
+            continue;
+        }
+        throw new Error("Usage: ouro rsvp legacy-render --legacy-root <path> [--agent <name>] [--output <path>] [--json]");
+    }
+    if (!legacyRoot)
+        throw new Error("rsvp legacy-render requires --legacy-root <path>");
+    return {
+        kind: "rsvp.legacy-render",
+        ...(agent ? { agent } : {}),
+        legacyRoot,
+        ...(json ? { json: true } : {}),
+        ...(outputPath ? { outputPath } : {}),
+    };
+}
+function parseRsvpReplayCommand(args) {
+    const { agent, rest } = extractAgentFlag(args);
+    let fixturePath;
+    let json = false;
+    let outputPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--fixture" && rest[i + 1]) {
+            fixturePath = rsvpPath(rest[++i], "--fixture");
+            continue;
+        }
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--output" && rest[i + 1]) {
+            outputPath = rsvpPath(rest[++i], "--output");
+            continue;
+        }
+        throw new Error("Usage: ouro rsvp replay [--agent <name>] --fixture <path> [--output <path>] [--json]");
+    }
+    if (!fixturePath)
+        throw new Error("rsvp replay requires --fixture <path>");
+    return {
+        kind: "rsvp.replay",
+        ...(agent ? { agent } : {}),
+        fixturePath,
+        ...(json ? { json: true } : {}),
+        ...(outputPath ? { outputPath } : {}),
+    };
+}
+function parseRsvpImportLegacyCommand(args, kind) {
+    const { agent, rest } = extractAgentFlag(args);
+    let legacyRoot;
+    let mode;
+    let yes = false;
+    let json = false;
+    let outputPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--legacy-root" && rest[i + 1]) {
+            legacyRoot = rsvpPath(rest[++i], "--legacy-root");
+            continue;
+        }
+        if (token === "--mode" && rest[i + 1]) {
+            const value = rest[++i];
+            if (!isRsvpMode(value))
+                throw new Error("rsvp import-legacy --mode must be shadow or live");
+            mode = value;
+            continue;
+        }
+        if (token === "--yes") {
+            yes = true;
+            continue;
+        }
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--output" && rest[i + 1]) {
+            outputPath = rsvpPath(rest[++i], "--output");
+            continue;
+        }
+        throw new Error("Usage: ouro rsvp config import-legacy [--agent <name>] --legacy-root <path> --mode shadow|live [--yes] [--output <path>] [--json]");
+    }
+    if (!legacyRoot)
+        throw new Error("rsvp import-legacy requires --legacy-root <path>");
+    if (!mode)
+        throw new Error("rsvp import-legacy requires --mode shadow|live");
+    return {
+        kind,
+        ...(agent ? { agent } : {}),
+        legacyRoot,
+        mode,
+        ...(yes ? { yes: true } : {}),
+        ...(json ? { json: true } : {}),
+        ...(outputPath ? { outputPath } : {}),
+    };
+}
+function parseRsvpHabitStageCommand(args) {
+    const { agent, rest } = extractAgentFlag(args);
+    let mode;
+    let cadence;
+    let json = false;
+    let outputPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--mode" && rest[i + 1]) {
+            const value = rest[++i];
+            if (!isRsvpMode(value))
+                throw new Error("rsvp habit stage --mode must be shadow or live");
+            mode = value;
+            continue;
+        }
+        if (token === "--cadence" && rest[i + 1]) {
+            cadence = rest[++i];
+            continue;
+        }
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--output" && rest[i + 1]) {
+            outputPath = rsvpPath(rest[++i], "--output");
+            continue;
+        }
+        throw new Error("Usage: ouro rsvp habit stage [--agent <name>] --mode shadow|live --cadence '<cron>' [--output <path>] [--json]");
+    }
+    if (!mode)
+        throw new Error("rsvp habit stage requires --mode shadow|live");
+    if (!cadence || !validRsvpCronCadence(cadence))
+        throw new Error("rsvp habit stage --cadence must be a five-field cron cadence");
+    return {
+        kind: "rsvp.habit.stage",
+        ...(agent ? { agent } : {}),
+        mode,
+        cadence,
+        ...(json ? { json: true } : {}),
+        ...(outputPath ? { outputPath } : {}),
+    };
+}
+function parseRsvpRefreshCommand(args) {
+    const { agent, rest } = extractAgentFlag(args);
+    let mode = "shadow";
+    let noSend = false;
+    let allowSend = false;
+    let json = false;
+    let outputPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--mode" && rest[i + 1]) {
+            const value = rest[++i];
+            if (!isRsvpMode(value))
+                throw new Error("rsvp refresh --mode must be shadow or live");
+            mode = value;
+            continue;
+        }
+        if (token === "--no-send") {
+            noSend = true;
+            continue;
+        }
+        if (token === "--allow-send") {
+            allowSend = true;
+            continue;
+        }
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--output" && rest[i + 1]) {
+            outputPath = rsvpPath(rest[++i], "--output");
+            continue;
+        }
+        throw new Error("Usage: ouro rsvp refresh [--agent <name>] --mode shadow|live [--no-send|--allow-send] [--output <path>] [--json]");
+    }
+    if (noSend && allowSend)
+        throw new Error("rsvp refresh cannot combine --allow-send and --no-send");
+    if (mode === "shadow" && allowSend)
+        throw new Error("rsvp refresh --mode shadow cannot use --allow-send; use --no-send or omit send flags");
+    if (mode === "live" && !allowSend)
+        throw new Error("rsvp refresh --mode live requires --allow-send, or use --no-send for a dry run");
+    return {
+        kind: "rsvp.refresh",
+        ...(agent ? { agent } : {}),
+        mode,
+        ...(noSend ? { noSend: true } : {}),
+        ...(allowSend ? { allowSend: true } : {}),
+        ...(json ? { json: true } : {}),
+        ...(outputPath ? { outputPath } : {}),
+    };
+}
+function parseRsvpCompareCommand(args) {
+    const { agent, rest } = extractAgentFlag(args);
+    let nativePath;
+    let legacyPath;
+    let json = false;
+    let outputPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--native" && rest[i + 1]) {
+            nativePath = rsvpPath(rest[++i], "--native");
+            continue;
+        }
+        if (token === "--legacy" && rest[i + 1]) {
+            legacyPath = rsvpPath(rest[++i], "--legacy");
+            continue;
+        }
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--output" && rest[i + 1]) {
+            outputPath = rsvpPath(rest[++i], "--output");
+            continue;
+        }
+        throw new Error("Usage: ouro rsvp compare [--agent <name>] --native <path> --legacy <path> [--output <path>] [--json]");
+    }
+    if (!nativePath)
+        throw new Error("rsvp compare requires --native <path>");
+    if (!legacyPath)
+        throw new Error("rsvp compare requires --legacy <path>");
+    return {
+        kind: "rsvp.compare",
+        ...(agent ? { agent } : {}),
+        nativePath,
+        legacyPath,
+        ...(json ? { json: true } : {}),
+        ...(outputPath ? { outputPath } : {}),
+    };
+}
+function parseRsvpSmokeCommand(args) {
+    const { agent, rest } = extractAgentFlag(args);
+    let mode = "preflight";
+    let surface;
+    let question;
+    let allowSend = false;
+    let json = false;
+    let outputPath;
+    let replayOutputPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--mode" && rest[i + 1]) {
+            const value = rest[++i];
+            if (!isRsvpSmokeMode(value))
+                throw new Error("rsvp smoke --mode must be preflight or live");
+            mode = value;
+            continue;
+        }
+        if (token === "--surface" && rest[i + 1]) {
+            const value = rest[++i];
+            if (!isRsvpSmokeSurface(value))
+                throw new Error("rsvp smoke --surface must be bluebubbles");
+            surface = value;
+            continue;
+        }
+        if (token === "--question" && rest[i + 1]) {
+            question = rest[++i];
+            continue;
+        }
+        if (token === "--allow-send") {
+            allowSend = true;
+            continue;
+        }
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--output" && rest[i + 1]) {
+            outputPath = rsvpPath(rest[++i], "--output");
+            continue;
+        }
+        if (token === "--replay-output" && rest[i + 1]) {
+            replayOutputPath = rsvpPath(rest[++i], "--replay-output");
+            continue;
+        }
+        throw new Error("Usage: ouro rsvp smoke [--agent <name>] --mode preflight|live --surface bluebubbles [--question <text>] [--allow-send] [--output <path>] [--replay-output <path>] [--json]");
+    }
+    if (!surface)
+        throw new Error("rsvp smoke requires --surface bluebubbles");
+    if (mode === "live" && !allowSend)
+        throw new Error("rsvp smoke --mode live requires --allow-send");
+    return {
+        kind: "rsvp.smoke",
+        ...(agent ? { agent } : {}),
+        mode,
+        surface,
+        ...(question ? { question } : {}),
+        ...(allowSend ? { allowSend: true } : {}),
+        ...(json ? { json: true } : {}),
+        ...(outputPath ? { outputPath } : {}),
+        ...(replayOutputPath ? { replayOutputPath } : {}),
+    };
+}
 function parseNervesReviewCommand(args) {
     const { agent, rest } = extractAgentFlag(args);
     let processName = "daemon";
@@ -1989,6 +2453,8 @@ function parseOuroCommand(args) {
     }
     if (head === "bluebubbles")
         return parseBlueBubblesCommand(args.slice(1));
+    if (head === "rsvp")
+        return parseRsvpCommand(args.slice(1));
     const suggestion = (0, cli_help_1.suggestCommand)(head);
     const hint = suggestion ? ` Did you mean '${suggestion}'?` : "";
     throw new Error(`Unknown command '${args.join(" ")}'.${hint}\n${usage()}`);