@ouro.bot/cli 0.1.0-alpha.72 → 0.1.0-alpha.721

package/dist/rsvp/diff-renderer.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RSVP_REPORT_COPY = void 0;
+exports.guestDisplayName = guestDisplayName;
+exports.computeRsvpDelta = computeRsvpDelta;
+exports.renderRsvpReport = renderRsvpReport;
+const runtime_1 = require("../nerves/runtime");
+exports.DEFAULT_RSVP_REPORT_COPY = {
+    title: "RSVP Update",
+    firstRunLabel: "Current RSVP summary:",
+    noChangesLabel: "No changes since last check.",
+    newRsvpsLabel: "New RSVPs:",
+    statusChangesLabel: "Status changes:",
+    newGuestsLabel: "New guests added:",
+    removedGuestsLabel: "Guests removed:",
+};
+function reportCopy(input = {}) {
+    return {
+        ...exports.DEFAULT_RSVP_REPORT_COPY,
+        ...Object.fromEntries(Object.entries(input).filter(([, value]) => typeof value === "string" && value.trim().length > 0)),
+    };
+}
+function byId(left, right) {
+    return left.id.localeCompare(right.id);
+}
+function sameGroup(left, right) {
+    return left !== null && right !== null && String(left) === String(right);
+}
+function guestDisplayName(guest, peers) {
+    if (guest.displayName !== "Unnamed guest")
+        return guest.displayName;
+    const primary = peers
+        .filter((candidate) => candidate.id !== guest.id && candidate.displayName !== "Unnamed guest" && sameGroup(candidate.groupId, guest.groupId))
+        .sort(byId)[0];
+    return primary ? `Unnamed guest (via ${primary.displayName})` : "Unnamed guest";
+}
+function guestBase(guest, peers) {
+    return {
+        id: guest.id,
+        displayName: guest.displayName,
+        contextualDisplayName: guestDisplayName(guest, peers),
+        groupId: guest.groupId,
+    };
+}
+function mapById(snapshot) {
+    return new Map(snapshot.guests.map((guest) => [guest.id, guest]));
+}
+function statusLabel(status) {
+    return status;
+}
+function reportName(guest) {
+    return guest.contextualDisplayName;
+}
+function summaryLine(summary) {
+    const base = `${summary.attending} attending / ${summary.declined} declined / ${summary.pending} pending`;
+    return summary.unknown > 0 ? `${base} / ${summary.unknown} unknown` : base;
+}
+function computeRsvpDelta(previous, current) {
+    const previousGuests = previous ? mapById(previous) : new Map();
+    const currentGuests = mapById(current);
+    const newRsvps = [];
+    const statusChanges = [];
+    const newGuests = [];
+    const removedGuests = [];
+    for (const currentGuest of current.guests) {
+        const previousGuest = previousGuests.get(currentGuest.id);
+        if (!previousGuest) {
+            newGuests.push({ ...guestBase(currentGuest, current.guests), status: currentGuest.status });
+            continue;
+        }
+        if (previousGuest.status === currentGuest.status)
+            continue;
+        const changed = {
+            ...guestBase(currentGuest, current.guests),
+            oldStatus: previousGuest.status,
+            newStatus: currentGuest.status,
+        };
+        if (previousGuest.status === "pending" && (currentGuest.status === "attending" || currentGuest.status === "declined")) {
+            newRsvps.push(changed);
+        }
+        else {
+            statusChanges.push(changed);
+        }
+    }
+    if (previous) {
+        for (const previousGuest of previous.guests) {
+            if (currentGuests.has(previousGuest.id))
+                continue;
+            removedGuests.push({ ...guestBase(previousGuest, previous.guests), status: previousGuest.status });
+        }
+    }
+    const delta = {
+        previousSnapshotId: previous?.snapshotId ?? null,
+        currentSnapshotId: current.snapshotId,
+        isFirstRun: previous === null,
+        newRsvps: newRsvps.sort(byId),
+        statusChanges: statusChanges.sort(byId),
+        newGuests: newGuests.sort(byId),
+        removedGuests: removedGuests.sort(byId),
+        summary: current.summary,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.delta_computed",
+        message: "computed RSVP snapshot delta",
+        meta: {
+            currentSnapshotId: current.snapshotId,
+            previousSnapshotId: previous?.snapshotId ?? null,
+            isFirstRun: previous === null,
+            newRsvps: delta.newRsvps.length,
+            statusChanges: delta.statusChanges.length,
+            newGuests: delta.newGuests.length,
+            removedGuests: delta.removedGuests.length,
+        },
+    });
+    return delta;
+}
+function hasChanges(delta) {
+    return delta.newRsvps.length > 0
+        || delta.statusChanges.length > 0
+        || delta.newGuests.length > 0
+        || delta.removedGuests.length > 0;
+}
+function renderRsvpReport(delta, copyInput = {}) {
+    const copy = reportCopy(copyInput);
+    const lines = [copy.title, ""];
+    if (delta.isFirstRun) {
+        lines.push(copy.firstRunLabel, "");
+    }
+    else if (!hasChanges(delta)) {
+        lines.push(copy.noChangesLabel, "");
+    }
+    else {
+        if (delta.newRsvps.length > 0) {
+            lines.push(copy.newRsvpsLabel);
+            for (const guest of delta.newRsvps) {
+                lines.push(`  • ${reportName(guest)} — ${statusLabel(guest.newStatus)}`);
+            }
+            lines.push("");
+        }
+        if (delta.statusChanges.length > 0) {
+            lines.push(copy.statusChangesLabel);
+            for (const guest of delta.statusChanges) {
+                lines.push(`  • ${reportName(guest)}: ${statusLabel(guest.oldStatus)} → ${statusLabel(guest.newStatus)}`);
+            }
+            lines.push("");
+        }
+        if (delta.newGuests.length > 0) {
+            lines.push(copy.newGuestsLabel);
+            for (const guest of delta.newGuests) {
+                lines.push(`  • ${reportName(guest)} (${statusLabel(guest.status)})`);
+            }
+            lines.push("");
+        }
+        if (delta.removedGuests.length > 0) {
+            lines.push(copy.removedGuestsLabel);
+            for (const guest of delta.removedGuests) {
+                lines.push(`  • ${reportName(guest)}`);
+            }
+            lines.push("");
+        }
+    }
+    lines.push(summaryLine(delta.summary));
+    const report = lines.join("\n");
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.report_rendered",
+        message: "rendered RSVP report",
+        meta: {
+            currentSnapshotId: delta.currentSnapshotId,
+            isFirstRun: delta.isFirstRun,
+            characters: report.length,
+        },
+    });
+    return report;
+}

package/dist/rsvp/habit-policy.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RSVP_HABIT_ALLOWED_TOOLS = exports.DEFAULT_RSVP_HABIT_NAME = exports.RSVP_HABIT_POLICY_VERSION = void 0;
+exports.isRsvpHabitName = isRsvpHabitName;
+exports.parseRsvpHabitMetadata = parseRsvpHabitMetadata;
+exports.rsvpHabitRuntimePolicy = rsvpHabitRuntimePolicy;
+const runtime_1 = require("../nerves/runtime");
+exports.RSVP_HABIT_POLICY_VERSION = "rsvp-habit/v1";
+exports.DEFAULT_RSVP_HABIT_NAME = "rsvp-updates";
+exports.RSVP_HABIT_ALLOWED_TOOLS = ["rsvp_query", "rsvp_summary"];
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function requiredString(record, key) {
+    const value = record[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`RSVP habit metadata requires ${key}`);
+    }
+    return value.trim();
+}
+function requiredBoolean(record, key) {
+    const value = record[key];
+    if (typeof value === "boolean")
+        return value;
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    throw new Error(`RSVP habit metadata requires boolean ${key}`);
+}
+function optionalString(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function isRsvpHabitName(name) {
+    return name.startsWith("rsvp-");
+}
+function parseRsvpHabitMetadata(raw) {
+    if (raw === undefined || raw === null)
+        return null;
+    if (!isRecord(raw))
+        throw new Error("RSVP habit metadata must be an object");
+    if (raw.channel !== undefined) {
+        throw new Error("RSVP habit metadata requires sense, not channel");
+    }
+    const policyVersion = requiredString(raw, "policyVersion");
+    if (policyVersion !== exports.RSVP_HABIT_POLICY_VERSION)
+        throw new Error("RSVP habit metadata has unsupported policyVersion");
+    const mode = requiredString(raw, "mode");
+    if (mode !== "shadow" && mode !== "live")
+        throw new Error("RSVP habit metadata mode must be shadow or live");
+    const sense = requiredString(raw, "sense");
+    if (sense !== "bluebubbles")
+        throw new Error("RSVP habit metadata sense must be bluebubbles");
+    const source = requiredString(raw, "source");
+    if (source !== "aisleplanner")
+        throw new Error("RSVP habit metadata source must be aisleplanner");
+    const parsed = {
+        policyVersion: exports.RSVP_HABIT_POLICY_VERSION,
+        mode,
+        sense,
+        source,
+        routeRef: requiredString(raw, "routeRef"),
+        snapshotRef: requiredString(raw, "snapshotRef"),
+        outboundStateRef: requiredString(raw, "outboundStateRef"),
+        budgetRef: requiredString(raw, "budgetRef"),
+        idempotencyRef: requiredString(raw, "idempotencyRef"),
+        liveSendEligible: requiredBoolean(raw, "liveSendEligible"),
+    };
+    for (const key of [
+        "reportTitle",
+        "firstRunLabel",
+        "noChangesLabel",
+        "newRsvpsLabel",
+        "statusChangesLabel",
+        "newGuestsLabel",
+        "removedGuestsLabel",
+    ]) {
+        const value = optionalString(raw, key);
+        if (value)
+            parsed[key] = value;
+    }
+    return parsed;
+}
+function rsvpHabitRuntimePolicy(metadata) {
+    const policy = {
+        ...metadata,
+        sendAllowed: metadata.mode === "live" && metadata.liveSendEligible,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.habit_policy_resolved",
+        message: "resolved RSVP habit runtime policy",
+        meta: {
+            mode: metadata.mode,
+            sense: metadata.sense,
+            source: metadata.source,
+            sendAllowed: policy.sendAllowed,
+            liveSendEligible: metadata.liveSendEligible,
+        },
+    });
+    return policy;
+}

package/dist/rsvp/habit-stage.js

@@ -0,0 +1,108 @@
+"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.stageRsvpHabit = stageRsvpHabit;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const habit_parser_1 = require("../heart/habits/habit-parser");
+const runtime_1 = require("../nerves/runtime");
+const outbound_state_1 = require("./outbound-state");
+const spend_ledger_1 = require("./spend-ledger");
+const habit_policy_1 = require("./habit-policy");
+function defaultRsvpHabitMetadata(mode, reportTitle) {
+    return {
+        policyVersion: habit_policy_1.RSVP_HABIT_POLICY_VERSION,
+        mode,
+        sense: "bluebubbles",
+        source: "aisleplanner",
+        routeRef: "rsvp/config.json#bluebubblesRoute",
+        snapshotRef: "state/rsvp/snapshots/latest.json",
+        outboundStateRef: "state/rsvp/outbound-state.json",
+        budgetRef: "state/rsvp/spend-ledger.json",
+        idempotencyRef: "state/rsvp/outbound-state.json",
+        liveSendEligible: false,
+        reportTitle,
+    };
+}
+function stagedHabitBody() {
+    return [
+        "Refresh AislePlanner RSVP state through the native RSVP workflow.",
+        "Use the latest native snapshot to answer follow-up questions, and only surface RSVP updates through the guarded outbound policy.",
+    ].join("\n\n");
+}
+function normalizeHabitName(name) {
+    const normalized = name?.trim() || habit_policy_1.DEFAULT_RSVP_HABIT_NAME;
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(normalized) || !(0, habit_policy_1.isRsvpHabitName)(normalized)) {
+        throw new Error("RSVP habit name must start with rsvp- and contain only letters, numbers, underscores, or hyphens");
+    }
+    return normalized;
+}
+function stageRsvpHabit(input) {
+    const habitName = normalizeHabitName(input.habitName);
+    const title = input.title?.trim() || "RSVP Updates";
+    const rsvp = defaultRsvpHabitMetadata(input.mode, input.reportTitle?.trim() || title);
+    const habitPath = path.join(input.agentRoot, "habits", `${habitName}.md`);
+    const created = (input.now ?? new Date()).toISOString();
+    const content = (0, habit_parser_1.renderHabitFile)({
+        title,
+        status: "active",
+        cadence: input.cadence,
+        created,
+        tools: [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS],
+        continuity: { mode: "stateful" },
+        rsvp,
+    }, stagedHabitBody());
+    fs.mkdirSync(path.dirname(habitPath), { recursive: true });
+    fs.writeFileSync(habitPath, content, "utf-8");
+    (0, outbound_state_1.ensureRsvpOutboundState)(input.agentRoot, created);
+    (0, spend_ledger_1.ensureRsvpSpendLedger)(input.agentRoot, created);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.habit_staged",
+        message: "staged native RSVP habit",
+        meta: { agent: input.agent, habitName, mode: input.mode, cadence: input.cadence },
+    });
+    return {
+        ok: true,
+        sideEffect: true,
+        agent: input.agent,
+        name: habitName,
+        habitName,
+        habitPath,
+        mode: input.mode,
+        cadence: input.cadence,
+        rsvp,
+    };
+}

package/dist/rsvp/incident-bundle.js

@@ -0,0 +1,97 @@
+"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.buildRsvpIncidentBundle = buildRsvpIncidentBundle;
+exports.writeRsvpIncidentBundle = writeRsvpIncidentBundle;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const doctor_1 = require("../heart/daemon/doctor");
+const runtime_1 = require("../nerves/runtime");
+const diagnostics_1 = require("./diagnostics");
+function nowIso(deps) {
+    return (deps.now?.() ?? new Date()).toISOString();
+}
+async function doctorResult(input) {
+    if (input.deps.runDoctorChecks)
+        return input.deps.runDoctorChecks();
+    const bundleRoot = path.dirname(input.agentRoot);
+    return (0, doctor_1.runDoctorChecks)({
+        existsSync: input.deps.existsSync,
+        readFileSync: input.deps.readFileSync,
+        readdirSync: input.deps.readdirSync,
+        statSync: input.deps.statSync,
+        checkSocketAlive: input.deps.checkSocketAlive,
+        socketPath: "",
+        bundlesRoot: bundleRoot,
+        homedir: path.dirname(bundleRoot),
+        envPath: "",
+        platform: process.platform,
+    }, { category: "RSVP" });
+}
+async function buildRsvpIncidentBundle(input) {
+    const diagnostics = (0, diagnostics_1.collectRsvpDiagnostics)(input.agentRoot, input.deps);
+    const bundle = {
+        schemaVersion: 1,
+        agent: input.agent,
+        generatedAt: nowIso(input.deps),
+        sideEffect: false,
+        doctor: await doctorResult(input),
+        ...diagnostics,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.incident_bundle_built",
+        message: "built RSVP incident bundle",
+        meta: {
+            agent: input.agent,
+            doctorFailed: bundle.doctor.summary.failed,
+            contextPacketLedger: bundle.contextPacketLedger.status,
+            latestFetch: bundle.latestFetch.status,
+        },
+    });
+    return bundle;
+}
+async function writeRsvpIncidentBundle(input) {
+    const bundle = await buildRsvpIncidentBundle(input);
+    fs.mkdirSync(path.dirname(input.outputPath), { recursive: true });
+    fs.writeFileSync(input.outputPath, `${JSON.stringify(bundle, null, 2)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.incident_bundle_written",
+        message: "wrote RSVP incident bundle",
+        meta: { agent: input.agent, outputPath: input.outputPath },
+    });
+    return { outputPath: input.outputPath, bundle };
+}

package/dist/rsvp/migration.js

@@ -0,0 +1,204 @@
+"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.RSVP_MIGRATION_POLICY_VERSION = void 0;
+exports.readRsvpBaselineState = readRsvpBaselineState;
+exports.importLegacyRsvpState = importLegacyRsvpState;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+const snapshot_1 = require("./snapshot");
+exports.RSVP_MIGRATION_POLICY_VERSION = "rsvp-migration/v1";
+function rsvpRoot(agentRoot) {
+    return path.join(agentRoot, "state", "rsvp");
+}
+function snapshotsDir(agentRoot) {
+    return path.join(rsvpRoot(agentRoot), "snapshots");
+}
+function baselineStatePath(agentRoot) {
+    return path.join(rsvpRoot(agentRoot), "baseline.json");
+}
+function hashBytes(bytes) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex")}`;
+}
+function hashFile(filePath) {
+    return hashBytes(fs.readFileSync(filePath));
+}
+function writeJson(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+function fail(reason, message) {
+    return { ok: false, reason, actor: "agent-runnable", message };
+}
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeRelative(root, filePath) {
+    const relative = path.relative(path.resolve(root), path.resolve(filePath));
+    if (relative.startsWith(".."))
+        return null;
+    return relative.split(path.sep).join("/");
+}
+function listLegacySnapshotFiles(legacyRoot) {
+    const dataDir = path.join(legacyRoot, "data");
+    return fs.readdirSync(dataDir)
+        .filter((name) => /^snapshot_.*\.json$/.test(name))
+        .sort()
+        .map((name) => path.join(dataDir, name));
+}
+function readLegacySnapshot(filePath) {
+    const parsed = readJsonFile(filePath);
+    if (!parsed || !parsed.guests || typeof parsed.guests !== "object" || Array.isArray(parsed.guests))
+        return null;
+    const allGuests = parsed.all_guests && typeof parsed.all_guests === "object" && !Array.isArray(parsed.all_guests)
+        ? parsed.all_guests
+        : {};
+    return {
+        guests: parsed.guests,
+        all_guests: allGuests,
+    };
+}
+function fetchedAtFromLegacyName(filePath) {
+    const basename = path.basename(filePath);
+    const match = basename.match(/^snapshot_(\d{4}-\d{2}-\d{2})_(\d{2})(\d{2})(\d{2})\.json$/);
+    if (!match)
+        return new Date(0).toISOString();
+    return `${match[1]}T${match[2]}:${match[3]}:${match[4]}.000Z`;
+}
+function snapshotPath(agentRoot, snapshot) {
+    return path.join(snapshotsDir(agentRoot), `${snapshot.snapshotId}.json`);
+}
+function writeSnapshot(agentRoot, snapshot) {
+    const filePath = snapshotPath(agentRoot, snapshot);
+    writeJson(filePath, snapshot);
+    return filePath;
+}
+function buildImportedSnapshot(input, filePath, sentStateHash) {
+    const legacy = readLegacySnapshot(filePath);
+    const relativePath = normalizeRelative(input.legacyRoot, filePath);
+    if (!legacy || !relativePath)
+        return null;
+    return (0, snapshot_1.buildRsvpSnapshot)({
+        agent: input.agent,
+        fetchedAt: fetchedAtFromLegacyName(filePath),
+        source: {
+            kind: "aisleplanner",
+            weddingId: input.weddingId,
+            eventId: input.eventId,
+            adapter: "aisleplanner-api-v1",
+        },
+        guests: legacy.guests,
+        allGuests: legacy.all_guests,
+        provenance: {
+            kind: "legacy-import",
+            importedAt: input.importedAt,
+            legacySnapshotRelativePath: relativePath,
+            legacySnapshotHash: hashFile(filePath),
+            ...(sentStateHash ? { sentStateHash } : {}),
+        },
+    });
+}
+function readRsvpBaselineState(agentRoot) {
+    return readJsonFile(baselineStatePath(agentRoot));
+}
+function importLegacyRsvpState(input) {
+    const dataDir = path.join(input.legacyRoot, "data");
+    if (!fs.existsSync(dataDir))
+        return fail("missing_legacy_data", "legacy RSVP data directory is missing");
+    const sentStatePath = path.join(dataDir, "sent_state.json");
+    if (!fs.existsSync(sentStatePath))
+        return fail("missing_sent_state", "legacy sent_state.json is missing; refusing to bootstrap baseline");
+    const sentStateRaw = fs.readFileSync(sentStatePath, "utf-8");
+    const sentState = readJsonFile(sentStatePath);
+    if (!sentState || typeof sentState.snapshot_path !== "string") {
+        return fail("malformed_sent_state", "legacy sent_state.json is malformed; refusing to bootstrap baseline");
+    }
+    const baselineLegacyPath = path.resolve(sentState.snapshot_path);
+    const baselineRelativePath = normalizeRelative(input.legacyRoot, baselineLegacyPath);
+    if (!baselineRelativePath)
+        return fail("baseline_outside_legacy_root", "legacy sent baseline points outside the legacy root");
+    if (!fs.existsSync(baselineLegacyPath))
+        return fail("missing_baseline_snapshot", "legacy sent baseline snapshot is missing");
+    const legacySnapshots = listLegacySnapshotFiles(input.legacyRoot);
+    const latestLegacyPath = legacySnapshots.at(-1);
+    if (!latestLegacyPath)
+        return fail("missing_legacy_snapshot", "no legacy snapshot_*.json files found");
+    const sentStateHash = hashBytes(sentStateRaw);
+    const baselineSnapshot = buildImportedSnapshot(input, baselineLegacyPath, sentStateHash);
+    const latestSnapshot = buildImportedSnapshot(input, latestLegacyPath);
+    if (!baselineSnapshot || !latestSnapshot)
+        return fail("malformed_legacy_snapshot", "legacy snapshot file is malformed");
+    const baselineSnapshotPath = writeSnapshot(input.agentRoot, baselineSnapshot);
+    const latestSnapshotPath = writeSnapshot(input.agentRoot, latestSnapshot);
+    const baselineState = {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_MIGRATION_POLICY_VERSION,
+        agent: input.agent,
+        importedAt: input.importedAt,
+        baselineSource: typeof sentState.source === "string" ? sentState.source : "sent",
+        legacySnapshotRelativePath: baselineRelativePath,
+        legacySnapshotHash: hashFile(baselineLegacyPath),
+        sentStateHash,
+        nativeSnapshotId: baselineSnapshot.snapshotId,
+        nativeSnapshotRelativePath: normalizeRelative(input.agentRoot, baselineSnapshotPath),
+    };
+    writeJson(baselineStatePath(input.agentRoot), baselineState);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.legacy_state_imported",
+        message: "imported legacy RSVP snapshots into native state",
+        meta: {
+            agent: input.agent,
+            latestSnapshotId: latestSnapshot.snapshotId,
+            baselineSnapshotId: baselineSnapshot.snapshotId,
+            baselineSource: baselineState.baselineSource,
+        },
+    });
+    return {
+        ok: true,
+        latestSnapshotId: latestSnapshot.snapshotId,
+        baselineSnapshotId: baselineSnapshot.snapshotId,
+        latestSnapshotPath,
+        baselineSnapshotPath,
+        baselineSource: baselineState.baselineSource,
+    };
+}