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

package/dist/rsvp/outbound-state.js

@@ -0,0 +1,628 @@
+"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_OUTBOUND_STATE_POLICY_VERSION = void 0;
+exports.classifyRsvpSendBoundary = classifyRsvpSendBoundary;
+exports.executeRsvpSendBoundary = executeRsvpSendBoundary;
+exports.readRsvpOutboundState = readRsvpOutboundState;
+exports.ensureRsvpOutboundState = ensureRsvpOutboundState;
+exports.writeRsvpBaseline = writeRsvpBaseline;
+exports.decideRsvpOutboundReport = decideRsvpOutboundReport;
+exports.recordRsvpOutboundAttempt = recordRsvpOutboundAttempt;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const habit_lifecycle_1 = require("../heart/habits/habit-lifecycle");
+const habit_parser_1 = require("../heart/habits/habit-parser");
+const runtime_1 = require("../nerves/runtime");
+exports.RSVP_OUTBOUND_STATE_POLICY_VERSION = "rsvp-outbound-state/v1";
+const AMBIGUOUS_HTTP_STATUSES = new Set([408, 409, 425, 429]);
+const retainedRsvpSendLeases = new Map();
+function classifyRsvpSendBoundary(observation) {
+    if (!observation.transportInvoked)
+        return "not_crossed";
+    const messageGuid = observation.messageGuid?.trim() ?? "";
+    if (observation.httpStatus !== null
+        && observation.httpStatus >= 200
+        && observation.httpStatus <= 299
+        && messageGuid.length > 0)
+        return "crossed";
+    if (observation.httpStatus !== null
+        && observation.httpStatus >= 400
+        && observation.httpStatus <= 499
+        && !AMBIGUOUS_HTTP_STATUSES.has(observation.httpStatus))
+        return "not_crossed";
+    return "crossing_unknown";
+}
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function lifecycleNowIso(deps) {
+    return (deps.now?.() ?? new Date()).toISOString();
+}
+function lifecycleErrorCode(error, fallback) {
+    return error instanceof habit_lifecycle_1.HabitLifecycleError ? error.code : fallback;
+}
+function emitBoundaryTelemetry(event) {
+    try {
+        (0, runtime_1.emitNervesEvent)(event);
+    }
+    catch {
+        // Observability must never mutate or obscure the durable transport boundary.
+    }
+}
+function failedBoundaryResult(operationId, errorCode, options = {}) {
+    const boundaryState = options.boundaryState ?? "not_crossed";
+    return {
+        ok: false,
+        operationId,
+        boundaryState,
+        transportInvoked: options.transportInvoked ?? false,
+        replayed: options.replayed ?? false,
+        transportResult: {
+            httpStatus: null,
+            messageGuid: null,
+            errorCode,
+        },
+        errorCode,
+    };
+}
+function currentHabitStatus(agentRoot, habitId, deps) {
+    const definitionPath = path.join(agentRoot, "habits", `${habitId}.md`);
+    try {
+        return (0, habit_parser_1.parseHabitFile)((deps.fs ?? fs).readFileSync(definitionPath, "utf8"), definitionPath).status;
+    }
+    catch (error) {
+        return (0, habit_parser_1.createDegradedHabitFile)(definitionPath, "read_error", "", String(error)).status;
+    }
+}
+function cancellationFencesSend(agentRoot, habitId, deps) {
+    return (0, habit_lifecycle_1.listHabitLifecycleJournals)({ agentRoot, habitId }, deps).some((journal) => (journal.operationKind === "cancel" && journal.generation >= 1));
+}
+function terminalBoundaryResult(journal, replayed, errorCode) {
+    const boundaryState = journal.boundaryState;
+    const transportResult = journal.transportResult;
+    const failureCode = errorCode ?? transportResult.errorCode ?? undefined;
+    return {
+        ok: boundaryState === "crossed",
+        operationId: journal.operationId,
+        boundaryState,
+        transportInvoked: journal.transportInvokedAt !== null,
+        replayed,
+        transportResult,
+        ...(boundaryState === "crossed" || failureCode === undefined ? {} : { errorCode: failureCode }),
+    };
+}
+function emitBoundaryClassified(habitId, operationId, boundaryState, transportInvoked) {
+    emitBoundaryTelemetry({
+        component: "rsvp",
+        event: "habit_send_boundary_classified",
+        message: "classified RSVP habit send boundary",
+        meta: { habitId, operationId, boundaryState, transportInvoked },
+    });
+}
+function persistBoundaryClassification(input) {
+    const boundaryState = classifyRsvpSendBoundary(input.observation);
+    const classifiedAt = lifecycleNowIso(input.deps);
+    let terminal;
+    let resultErrorCode = input.errorCode;
+    try {
+        terminal = (0, habit_lifecycle_1.transitionHabitLifecycleJournal)(input.intent, {
+            state: boundaryState,
+            at: classifiedAt,
+            transportInvokedAt: input.observation.transportInvoked ? input.transportInvokedAt : null,
+            transportResult: {
+                httpStatus: input.observation.httpStatus,
+                messageGuid: input.observation.messageGuid,
+                errorCode: input.observation.errorCode,
+            },
+        });
+        (0, habit_lifecycle_1.writeHabitLifecycleJournal)(input.lease, terminal, input.deps);
+    }
+    catch {
+        const fallbackError = "classification_durability_unknown";
+        const fallbackBoundaryState = input.observation.transportInvoked
+            ? "crossing_unknown"
+            : "not_crossed";
+        terminal = (0, habit_lifecycle_1.transitionHabitLifecycleJournal)(input.intent, {
+            state: fallbackBoundaryState,
+            at: classifiedAt,
+            transportInvokedAt: input.observation.transportInvoked
+                ? input.transportInvokedAt ?? input.intent.intentAt
+                : null,
+            transportResult: {
+                httpStatus: input.observation.httpStatus,
+                messageGuid: input.observation.messageGuid,
+                errorCode: fallbackError,
+            },
+        });
+        try {
+            (0, habit_lifecycle_1.writeHabitLifecycleJournal)(input.lease, terminal, input.deps);
+        }
+        catch {
+            // The caller still reports the only safe classification when terminal durability cannot be proven.
+        }
+        resultErrorCode = fallbackError;
+    }
+    emitBoundaryClassified(input.lease.habitId, input.lease.operationId, terminal.boundaryState, terminal.transportInvokedAt !== null);
+    return terminalBoundaryResult(terminal, input.replayed, resultErrorCode);
+}
+function rsvpSendLeaseKey(agentRoot, habitId, operationId) {
+    return JSON.stringify([path.resolve(agentRoot), habitId, operationId]);
+}
+async function releaseRsvpSendLease(leaseKey, lease, deps) {
+    const lifecycle = deps.lifecycle ?? {};
+    const release = deps.releaseLifecycleLock ?? habit_lifecycle_1.releaseHabitLifecycleLock;
+    const attempts = Math.floor(habit_lifecycle_1.HABIT_LIFECYCLE_TIMEOUT_MS / habit_lifecycle_1.HABIT_LIFECYCLE_POLL_MS) + 1;
+    const wait = lifecycle.sleep ?? ((milliseconds) => new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    }));
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        try {
+            if (release(lease, lifecycle)) {
+                retainedRsvpSendLeases.delete(leaseKey);
+                return true;
+            }
+        }
+        catch {
+            retainedRsvpSendLeases.set(leaseKey, lease);
+            return false;
+        }
+        if (attempt + 1 < attempts)
+            await wait(habit_lifecycle_1.HABIT_LIFECYCLE_POLL_MS);
+    }
+    retainedRsvpSendLeases.set(leaseKey, lease);
+    return false;
+}
+function transportErrorObservation(error, transportInvoked) {
+    const record = error && typeof error === "object" ? error : {};
+    const declaredInvoked = record.transportInvoked === true;
+    const httpStatus = typeof record.httpStatus === "number" && Number.isInteger(record.httpStatus)
+        ? record.httpStatus
+        : null;
+    const name = typeof record.name === "string" ? record.name : "";
+    const errorCode = typeof record.errorCode === "string" && record.errorCode.trim().length > 0
+        ? record.errorCode.trim()
+        : name === "TimeoutError"
+            ? "timeout"
+            : name === "AbortError"
+                ? "abort"
+                : error instanceof TypeError
+                    ? "socket"
+                    : transportInvoked || declaredInvoked
+                        ? "transport_error"
+                        : "validation";
+    return {
+        transportInvoked: transportInvoked || declaredInvoked,
+        httpStatus,
+        messageGuid: null,
+        errorCode,
+    };
+}
+async function executeRsvpSendBoundary(input, deps = {}) {
+    const lifecycle = deps.lifecycle ?? {};
+    const operation = (0, habit_lifecycle_1.buildHabitSendOperation)({
+        habitId: input.habitId,
+        outboundIdempotencyKey: input.outboundIdempotencyKey,
+    });
+    if (input.noSend)
+        return failedBoundaryResult(operation.operationId, "immutable_no_send");
+    const leaseKey = rsvpSendLeaseKey(input.agentRoot, input.habitId, operation.operationId);
+    let lease = retainedRsvpSendLeases.get(leaseKey);
+    try {
+        if (lease && !(0, habit_lifecycle_1.habitLifecycleLeaseIsCurrent)(lease, lifecycle)) {
+            retainedRsvpSendLeases.delete(leaseKey);
+            lease = undefined;
+        }
+        if (!lease) {
+            const lock = await (0, habit_lifecycle_1.acquireHabitLifecycleLock)({
+                agentRoot: input.agentRoot,
+                habitId: input.habitId,
+                operationId: operation.operationId,
+            }, lifecycle);
+            if (lock.status === "timeout") {
+                return failedBoundaryResult(operation.operationId, lock.error);
+            }
+            lease = lock.lease;
+        }
+    }
+    catch (error) {
+        return failedBoundaryResult(operation.operationId, lifecycleErrorCode(error, "lifecycle_lock_failed"));
+    }
+    const activeLease = lease;
+    let transportInvoked = false;
+    let transportInvokedAt = null;
+    let intent = null;
+    const markTransportInvoked = () => {
+        if (transportInvoked)
+            return;
+        transportInvoked = true;
+        transportInvokedAt = lifecycleNowIso(lifecycle);
+        emitBoundaryTelemetry({
+            component: "rsvp",
+            event: "habit_transport_invoked",
+            message: "invoked RSVP habit transport",
+            meta: { habitId: input.habitId, operationId: operation.operationId },
+        });
+    };
+    const boundaryResult = await (async () => {
+        try {
+            const existing = (0, habit_lifecycle_1.readHabitLifecycleJournal)({
+                agentRoot: input.agentRoot,
+                habitId: input.habitId,
+                operationId: operation.operationId,
+            }, lifecycle);
+            if (existing?.state === "not_crossed"
+                || existing?.state === "crossing_unknown"
+                || existing?.state === "crossed")
+                return terminalBoundaryResult(existing, true);
+            if (existing?.state === "send_intent") {
+                return persistBoundaryClassification({
+                    lease: activeLease,
+                    intent: existing,
+                    observation: {
+                        transportInvoked: true,
+                        httpStatus: null,
+                        messageGuid: null,
+                        errorCode: "recovered_unclassified_send_intent",
+                    },
+                    transportInvokedAt: existing.intentAt,
+                    replayed: true,
+                    deps: lifecycle,
+                    errorCode: "recovered_unclassified_send_intent",
+                });
+            }
+            const status = currentHabitStatus(input.agentRoot, input.habitId, lifecycle);
+            if (status !== "active") {
+                return failedBoundaryResult(operation.operationId, `habit_status_${status}`);
+            }
+            if (cancellationFencesSend(input.agentRoot, input.habitId, lifecycle)) {
+                return failedBoundaryResult(operation.operationId, "cancellation_pending");
+            }
+            intent = existing ?? (0, habit_lifecycle_1.createHabitLifecycleJournal)({
+                habitId: input.habitId,
+                operationId: operation.operationId,
+                operationKind: "send",
+                updatedAt: lifecycleNowIso(lifecycle),
+            });
+            if (existing === null)
+                (0, habit_lifecycle_1.writeHabitLifecycleJournal)(activeLease, intent, lifecycle);
+            intent = (0, habit_lifecycle_1.transitionHabitLifecycleJournal)(intent, {
+                state: "send_intent",
+                at: lifecycleNowIso(lifecycle),
+            });
+            try {
+                (0, habit_lifecycle_1.writeHabitLifecycleJournal)(activeLease, intent, lifecycle);
+            }
+            catch (error) {
+                const visible = (0, habit_lifecycle_1.readHabitLifecycleJournal)({
+                    agentRoot: input.agentRoot,
+                    habitId: input.habitId,
+                    operationId: operation.operationId,
+                }, lifecycle);
+                if (visible?.state === "send_intent") {
+                    return persistBoundaryClassification({
+                        lease: activeLease,
+                        intent: visible,
+                        observation: {
+                            transportInvoked: false,
+                            httpStatus: null,
+                            messageGuid: null,
+                            errorCode: lifecycleErrorCode(error, "lifecycle_write_failed"),
+                        },
+                        transportInvokedAt: null,
+                        replayed: false,
+                        deps: lifecycle,
+                        errorCode: lifecycleErrorCode(error, "lifecycle_write_failed"),
+                    });
+                }
+                return failedBoundaryResult(operation.operationId, lifecycleErrorCode(error, "lifecycle_write_failed"));
+            }
+            emitBoundaryTelemetry({
+                component: "rsvp",
+                event: "habit_send_intent",
+                message: "recorded durable RSVP habit send intent",
+                meta: { habitId: input.habitId, operationId: operation.operationId },
+            });
+            let observation;
+            try {
+                const result = await input.invokeTransport(markTransportInvoked);
+                const messageGuid = result?.messageGuid?.trim() || null;
+                if (messageGuid !== null && !transportInvoked)
+                    markTransportInvoked();
+                observation = {
+                    transportInvoked,
+                    httpStatus: typeof result?.httpStatus === "number" ? result.httpStatus : 200,
+                    messageGuid,
+                    errorCode: messageGuid === null ? "missing_message_guid" : null,
+                };
+            }
+            catch (error) {
+                observation = transportErrorObservation(error, transportInvoked);
+                if (observation.transportInvoked && !transportInvoked)
+                    markTransportInvoked();
+            }
+            return persistBoundaryClassification({
+                lease: activeLease,
+                intent,
+                observation,
+                transportInvokedAt,
+                replayed: false,
+                deps: lifecycle,
+            });
+        }
+        catch (error) {
+            const errorCode = lifecycleErrorCode(error, "send_boundary_failed");
+            return failedBoundaryResult(operation.operationId, errorCode, {
+                transportInvoked,
+                boundaryState: transportInvoked ? "crossing_unknown" : "not_crossed",
+            });
+        }
+    })();
+    let released = false;
+    try {
+        released = await releaseRsvpSendLease(leaseKey, activeLease, deps);
+    }
+    catch {
+        retainedRsvpSendLeases.set(leaseKey, activeLease);
+    }
+    if (!released) {
+        return {
+            ...boundaryResult,
+            ok: false,
+            errorCode: "lifecycle_lock_release_failed",
+        };
+    }
+    return boundaryResult;
+}
+function hashString(input) {
+    return `sha256:${sha256Hex(input)}`;
+}
+function rsvpOutboundStatePath(agentRoot) {
+    return path.join(agentRoot, "state", "rsvp", "outbound-state.json");
+}
+function emptyState(now) {
+    return {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+        updatedAt: now,
+        pendingReports: [],
+    };
+}
+function nowIso(input) {
+    return input ?? new Date().toISOString();
+}
+function reportHash(reportText) {
+    return hashString(reportText.trim().replace(/\s+/g, " "));
+}
+function idempotencyKeyFor(snapshot, reportText) {
+    return [
+        "rsvp-report",
+        snapshot.agent,
+        snapshot.source.weddingId,
+        snapshot.source.eventId,
+        snapshot.snapshotId,
+        reportHash(reportText).slice("sha256:".length, "sha256:".length + 16),
+    ].join(":");
+}
+function isBaseline(value) {
+    const row = value;
+    return !!row
+        && typeof row.snapshotId === "string"
+        && typeof row.contentHash === "string"
+        && typeof row.recordedAt === "string"
+        && typeof row.reason === "string";
+}
+function isPending(value) {
+    const row = value;
+    return !!row
+        && typeof row.snapshotId === "string"
+        && typeof row.contentHash === "string"
+        && typeof row.reportHash === "string"
+        && typeof row.reportLength === "number"
+        && typeof row.idempotencyKey === "string"
+        && typeof row.bluebubblesRecordId === "string"
+        && typeof row.status === "string"
+        && typeof row.recordedAt === "string"
+        && typeof row.updatedAt === "string"
+        && row.contentStored === false;
+}
+function isState(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && row.policyVersion === exports.RSVP_OUTBOUND_STATE_POLICY_VERSION
+        && typeof row.updatedAt === "string"
+        && (row.baseline === undefined || isBaseline(row.baseline))
+        && Array.isArray(row.pendingReports);
+}
+function readRsvpOutboundState(agentRoot) {
+    const filePath = rsvpOutboundStatePath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return emptyState(new Date().toISOString());
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (!isState(parsed))
+            return emptyState(new Date().toISOString());
+        return {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+            updatedAt: parsed.updatedAt,
+            ...(parsed.baseline ? { baseline: parsed.baseline } : {}),
+            pendingReports: parsed.pendingReports.filter(isPending),
+        };
+    }
+    catch {
+        return emptyState(new Date().toISOString());
+    }
+}
+function writeState(agentRoot, state) {
+    const filePath = rsvpOutboundStatePath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+    fs.renameSync(tmp, filePath);
+    return state;
+}
+function ensureRsvpOutboundState(agentRoot, now = new Date().toISOString()) {
+    const filePath = rsvpOutboundStatePath(agentRoot);
+    if (fs.existsSync(filePath))
+        return readRsvpOutboundState(agentRoot);
+    const state = writeState(agentRoot, emptyState(now));
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_state_initialized",
+        message: "initialized RSVP outbound state",
+        meta: { updatedAt: state.updatedAt },
+    });
+    return state;
+}
+function writeRsvpBaseline(input) {
+    const current = readRsvpOutboundState(input.agentRoot);
+    const state = writeState(input.agentRoot, {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+        updatedAt: input.recordedAt,
+        baseline: {
+            snapshotId: input.snapshot.snapshotId,
+            contentHash: input.snapshot.contentHash,
+            recordedAt: input.recordedAt,
+            reason: input.reason,
+        },
+        pendingReports: current.pendingReports.filter((entry) => entry.snapshotId !== input.snapshot.snapshotId),
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_baseline_written",
+        message: "wrote RSVP outbound baseline",
+        meta: { snapshotId: input.snapshot.snapshotId, reason: input.reason },
+    });
+    return state;
+}
+function decideRsvpOutboundReport(input) {
+    const state = readRsvpOutboundState(input.agentRoot);
+    const idempotencyKey = idempotencyKeyFor(input.currentSnapshot, input.reportText);
+    const currentSnapshotId = input.currentSnapshot.snapshotId;
+    const report = reportHash(input.reportText);
+    if (state.baseline?.snapshotId === currentSnapshotId
+        && state.baseline.contentHash === input.currentSnapshot.contentHash) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "rsvp",
+            event: "rsvp.outbound_decision",
+            message: "decided RSVP report outbound action",
+            meta: { action: "skip", snapshotId: currentSnapshotId },
+        });
+        return {
+            action: "skip",
+            reason: "baseline-current",
+            currentSnapshotId,
+            idempotencyKey,
+            reportText: input.reportText,
+        };
+    }
+    const existingPending = state.pendingReports.find((entry) => entry.snapshotId === currentSnapshotId && entry.reportHash === report);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_decision",
+        message: "decided RSVP report outbound action",
+        meta: { action: "send", snapshotId: currentSnapshotId, existingPending: Boolean(existingPending), now: nowIso(input.now) },
+    });
+    return {
+        action: "send",
+        currentSnapshotId,
+        idempotencyKey,
+        reportText: input.reportText,
+        ...(existingPending ? { existingPending } : {}),
+    };
+}
+function isAdvanceStatus(status) {
+    return status === "accepted" || status === "enqueued" || status === "local-visible" || status === "delivered";
+}
+function pendingReportFor(input) {
+    const normalized = input.reportText.trim().replace(/\s+/g, " ");
+    return {
+        snapshotId: input.currentSnapshot.snapshotId,
+        contentHash: input.currentSnapshot.contentHash,
+        reportHash: reportHash(input.reportText),
+        reportLength: normalized.length,
+        idempotencyKey: idempotencyKeyFor(input.currentSnapshot, input.reportText),
+        bluebubblesRecordId: input.bluebubblesRecord.recordId,
+        status: input.bluebubblesRecord.status,
+        ...(input.bluebubblesRecord.tempGuid?.trim() ? { tempGuid: input.bluebubblesRecord.tempGuid.trim() } : {}),
+        ...(input.bluebubblesRecord.messageGuid?.trim() ? { messageGuid: input.bluebubblesRecord.messageGuid.trim() } : {}),
+        recordedAt: input.recordedAt,
+        updatedAt: input.recordedAt,
+        contentStored: false,
+    };
+}
+function recordRsvpOutboundAttempt(input) {
+    const current = readRsvpOutboundState(input.agentRoot);
+    const pending = pendingReportFor(input);
+    const remainingPending = current.pendingReports.filter((entry) => entry.snapshotId !== pending.snapshotId || entry.reportHash !== pending.reportHash);
+    const state = isAdvanceStatus(input.bluebubblesRecord.status)
+        ? writeState(input.agentRoot, {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+            updatedAt: input.recordedAt,
+            baseline: {
+                snapshotId: input.currentSnapshot.snapshotId,
+                contentHash: input.currentSnapshot.contentHash,
+                recordedAt: input.recordedAt,
+                reason: "bluebubbles-outbound-accepted",
+                bluebubblesRecordId: input.bluebubblesRecord.recordId,
+                advancedBy: input.bluebubblesRecord.status,
+            },
+            pendingReports: remainingPending,
+        })
+        : writeState(input.agentRoot, {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+            updatedAt: input.recordedAt,
+            ...(current.baseline ? { baseline: current.baseline } : {}),
+            pendingReports: [...remainingPending, pending],
+        });
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_attempt_recorded",
+        message: "recorded RSVP outbound attempt",
+        meta: {
+            snapshotId: input.currentSnapshot.snapshotId,
+            bluebubblesRecordId: input.bluebubblesRecord.recordId,
+            status: input.bluebubblesRecord.status,
+            baselineAdvanced: isAdvanceStatus(input.bluebubblesRecord.status),
+        },
+    });
+    return state;
+}