@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.551

package/dist/mailroom/search-relevance.js

@@ -0,0 +1,319 @@
+"use strict";
+// Booking-intent relevance for mail search.
+//
+// Today the agent's mail search ranks by recency only — `searchText.includes(term)`
+// then `receivedAt` desc. That works for "give me the latest message" but fails
+// the workflow Slugger actually does most: "find the decisive booking message
+// in this delegated mailbox so I can update a travel doc from real evidence."
+// Recent newsletter / itinerary chatter from the same sender drowns the older
+// confirmation.
+//
+// This module adds a small additive score per document. Signals are heuristic
+// and intentionally legible — not learned. Each signal is also exposed so the
+// renderer can surface a "matched on" hint to the agent for triage.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scoreMailSearchDocument = scoreMailSearchDocument;
+exports.compareByRelevanceThenRecency = compareByRelevanceThenRecency;
+exports.formatRelevanceHint = formatRelevanceHint;
+const BOOKING_INTENT_TOKENS = [
+    "booking confirmation",
+    "booked",
+    "your booking",
+    "your reservation",
+    "your stay",
+    "your trip",
+    "reservation confirmation",
+    "reservation confirmed",
+    "confirmation number",
+    "e-ticket",
+    "eticket",
+    "itinerary",
+    "receipt",
+    "invoice",
+    "check-in",
+    "check in",
+    "departure",
+    "arrival",
+    "boarding pass",
+    "confirmed",
+    "confirmation",
+    "reservation",
+];
+// Subject-only tokens get an extra bump because subjects rarely include them
+// for non-decisive mail.
+const SUBJECT_DECISIVE_TOKENS = [
+    "booking confirmation",
+    "reservation confirmation",
+    "your booking",
+    "your reservation",
+    "your stay",
+    "e-ticket",
+    "eticket",
+    "boarding pass",
+    "confirmed",
+    "itinerary",
+    "receipt",
+];
+// Known travel-domain senders. Substring match against the from list. Kept
+// short on purpose — the score still works without exhaustive coverage; this
+// just reinforces obvious cases.
+const KNOWN_TRAVEL_SENDER_PATTERNS = [
+    "booking.com",
+    "hotels.com",
+    "expedia",
+    "airbnb",
+    "marriott",
+    "hilton",
+    "hyatt",
+    "ihg",
+    "accorhotels",
+    "kayak",
+    "agoda",
+    "trivago",
+    "vrbo",
+    "swiss.com",
+    "lufthansa",
+    "ryanair",
+    "easyjet",
+    "ba.com",
+    "delta.com",
+    "united.com",
+    "aa.com",
+    "alaskaair",
+    "klm.com",
+    "airfrance",
+    "iberia",
+    "sas.se",
+    "norwegian.com",
+    "sbb.ch",
+    "sncf",
+    "trenitalia",
+    "renfe",
+    "eurail",
+    "trainline",
+    "omio",
+    "raileurope",
+    "amtrak",
+    "viarail",
+    "rentalcars",
+    "hertz",
+    "avis",
+    "europcar",
+    "sixt",
+    "uber.com",
+    "lyft.com",
+    "lime",
+    "tripit",
+    "kiwi.com",
+    "tap.pt",
+];
+// Confirmation-number-shaped tokens. Two flavors:
+//   - alphanumeric mix at least 6 long: PNRs, hotel confirmation codes
+//   - long pure-digit runs (>= 8): airline ref numbers, OTA references
+const ALPHANUM_CONF_RE = /\b(?=[A-Z0-9]*[A-Z])(?=[A-Z0-9]*\d)[A-Z0-9]{6,12}\b/g;
+const LONG_DIGIT_RE = /\b\d{8,}\b/g;
+// Currency amounts. Symbol or ISO 3-letter currency immediately followed by
+// (or following) a number. Catches "$420", "€189.50", "CHF 320", "USD 199".
+const CURRENCY_RE = /(?:[$£€¥₣]\s?\d{1,3}(?:[,.\s]\d{3})*(?:[.,]\d{2})?|\b(?:USD|EUR|GBP|CHF|JPY|CAD|AUD|SEK|NOK|DKK)\s?\d{1,3}(?:[,.\s]\d{3})*(?:[.,]\d{2})?)/g;
+// ISO-8601 dates and "January 2[, 2026]" / "2 January 2026" forms.
+const ISO_DATE_RE = /\b\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])\b/g;
+const MONTH_DAY_RE = /\b(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+\d{1,2}(?:,?\s+\d{4})?\b/gi;
+const DAY_MONTH_RE = /\b\d{1,2}\s+(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)(?:,?\s+\d{4})?\b/gi;
+// Status tokens — decisive truth signals. These often determine whether a
+// "this trip is on" reading is correct. Lowercased substring match.
+const STATUS_TOKENS = [
+    "confirmed",
+    "booked",
+    "cancelled",
+    "canceled",
+    "changed",
+    "rescheduled",
+    "refunded",
+    "refund",
+    "pending",
+    "tentative",
+    "waitlist",
+    "no longer",
+    "rebooked",
+    "modified",
+];
+function uniqueLowercaseHits(text, regex) {
+    const hits = text.match(regex);
+    if (!hits)
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const hit of hits) {
+        const norm = hit.toLowerCase();
+        if (seen.has(norm))
+            continue;
+        seen.add(norm);
+        out.push(hit);
+    }
+    return out;
+}
+function findKnownTravelSender(fromList) {
+    for (const from of fromList) {
+        const lower = from.toLowerCase();
+        for (const pattern of KNOWN_TRAVEL_SENDER_PATTERNS) {
+            if (lower.includes(pattern))
+                return pattern;
+        }
+    }
+    return undefined;
+}
+function countOccurrences(haystack, needle) {
+    /* v8 ignore start -- defensive: BOOKING_INTENT_TOKENS are non-empty by construction */
+    if (!needle)
+        return 0;
+    /* v8 ignore stop */
+    let count = 0;
+    let from = 0;
+    while (true) {
+        const idx = haystack.indexOf(needle, from);
+        if (idx === -1)
+            break;
+        count++;
+        from = idx + needle.length;
+    }
+    return count;
+}
+/**
+ * Score a cached search document for booking-intent relevance against a list
+ * of (already lowercased, non-empty) query terms.
+ *
+ * Signals (additive, all small integers so the result stays interpretable):
+ *   - +6 per query term hit in subject
+ *   - +4 per query term hit in any from address
+ *   - +2 per query term hit in body
+ *   - +5 per booking-intent token in subject (extra +3 for decisive subject tokens)
+ *   - +2 per booking-intent token in body
+ *   - +4 if any confirmation-number-shaped token appears
+ *   - +3 if any currency amount appears
+ *   - +6 if any from address matches a known travel-sender pattern
+ *
+ * The numbers are tunable. They are chosen so that a noisy newsletter that
+ * mentions the query terms in body but has no booking signals scores below
+ * a decisive booking confirmation that has the query terms + booking tokens
+ * in subject + a confirmation code, even if the booking confirmation is older.
+ */
+function scoreMailSearchDocument(document, queryTerms) {
+    const subjectLower = document.subject.toLowerCase();
+    const bodyLower = document.textExcerpt.toLowerCase();
+    const fromLower = document.from.join(" ").toLowerCase();
+    let score = 0;
+    const matchedFields = new Set();
+    for (const term of queryTerms) {
+        /* v8 ignore start -- defensive: callers always normalize/filter empty terms */
+        if (!term)
+            continue;
+        /* v8 ignore stop */
+        if (subjectLower.includes(term)) {
+            score += 6;
+            matchedFields.add("subject");
+        }
+        if (fromLower.includes(term)) {
+            score += 4;
+            matchedFields.add("from");
+        }
+        if (bodyLower.includes(term)) {
+            score += 2;
+            matchedFields.add("body");
+        }
+    }
+    const bookingHits = new Set();
+    for (const token of BOOKING_INTENT_TOKENS) {
+        const inSubject = countOccurrences(subjectLower, token);
+        const inBody = countOccurrences(bodyLower, token);
+        if (inSubject > 0) {
+            score += 5 * inSubject;
+            bookingHits.add(token);
+        }
+        if (inBody > 0) {
+            score += 2 * inBody;
+            bookingHits.add(token);
+        }
+    }
+    for (const decisive of SUBJECT_DECISIVE_TOKENS) {
+        if (subjectLower.includes(decisive))
+            score += 3;
+    }
+    const subjectAndBody = `${document.subject}\n${document.textExcerpt}`;
+    const subjectAndBodyLower = subjectAndBody.toLowerCase();
+    const confirmationTokens = [
+        ...uniqueLowercaseHits(subjectAndBody, ALPHANUM_CONF_RE),
+        ...uniqueLowercaseHits(subjectAndBody, LONG_DIGIT_RE),
+    ];
+    if (confirmationTokens.length > 0)
+        score += 4;
+    const currencyTokens = uniqueLowercaseHits(subjectAndBody, CURRENCY_RE);
+    if (currencyTokens.length > 0)
+        score += 3;
+    const dateTokens = [
+        ...uniqueLowercaseHits(subjectAndBody, ISO_DATE_RE),
+        ...uniqueLowercaseHits(subjectAndBody, MONTH_DAY_RE),
+        ...uniqueLowercaseHits(subjectAndBody, DAY_MONTH_RE),
+    ];
+    const statusTokens = [];
+    for (const token of STATUS_TOKENS) {
+        if (subjectAndBodyLower.includes(token))
+            statusTokens.push(token);
+    }
+    const travelSenderHint = findKnownTravelSender(document.from);
+    if (travelSenderHint)
+        score += 6;
+    const signal = {
+        score,
+        matchedFields: Array.from(matchedFields),
+        bookingTokens: Array.from(bookingHits),
+        confirmationTokens,
+        currencyTokens,
+        statusTokens,
+        dateTokens,
+    };
+    if (travelSenderHint)
+        signal.travelSenderHint = travelSenderHint;
+    return signal;
+}
+/**
+ * Sort comparator: booking relevance first, recency as tiebreaker.
+ * Returns negative when `a` should come before `b`.
+ */
+function compareByRelevanceThenRecency(a, b) {
+    if (b.relevance.score !== a.relevance.score)
+        return b.relevance.score - a.relevance.score;
+    return b.document.receivedAt.localeCompare(a.document.receivedAt);
+}
+/**
+ * Render a short "matched on" hint for surfacing under a search result.
+ * Empty string when nothing notable to report (no signals, no fields). The
+ * caller decides whether to display the line.
+ */
+function formatRelevanceHint(signal) {
+    if (signal.score === 0)
+        return "";
+    const parts = [];
+    if (signal.matchedFields.length > 0) {
+        parts.push(`fields: ${signal.matchedFields.join("+")}`);
+    }
+    if (signal.bookingTokens.length > 0) {
+        const preview = signal.bookingTokens.slice(0, 3).join(", ");
+        parts.push(`booking signals: ${preview}`);
+    }
+    if (signal.statusTokens.length > 0) {
+        parts.push(`status: ${signal.statusTokens.slice(0, 3).join(", ")}`);
+    }
+    if (signal.confirmationTokens.length > 0) {
+        parts.push(`conf token: ${signal.confirmationTokens[0]}`);
+    }
+    if (signal.currencyTokens.length > 0) {
+        parts.push(`amount: ${signal.currencyTokens[0]}`);
+    }
+    if (signal.dateTokens.length > 0) {
+        parts.push(`dates: ${signal.dateTokens.slice(0, 3).join(", ")}`);
+    }
+    if (signal.travelSenderHint) {
+        parts.push(`sender: ${signal.travelSenderHint}`);
+    }
+    return parts.join(" | ");
+}

package/dist/mailroom/smtp-ingress.js

@@ -0,0 +1,176 @@
+"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.createMailroomSmtpServer = createMailroomSmtpServer;
+exports.createMailroomHealthServer = createMailroomHealthServer;
+exports.startMailroomIngress = startMailroomIngress;
+const http = __importStar(require("node:http"));
+const smtp_server_1 = require("smtp-server");
+const runtime_1 = require("../nerves/runtime");
+const core_1 = require("./core");
+const file_store_1 = require("./file-store");
+function collectStream(stream, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        stream.on("data", (chunk) => {
+            total += chunk.byteLength;
+            if (total > maxBytes) {
+                reject(new Error(`message exceeds max size ${maxBytes}`));
+                stream.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        stream.on("error", reject);
+        stream.on("end", () => resolve(Buffer.concat(chunks)));
+    });
+}
+function sessionRecipients(session) {
+    /* v8 ignore next -- smtp-server supplies rcptTo during DATA; fallback is a defensive harness edge. @preserve */
+    return (session.envelope.rcptTo ?? []).map((address) => (0, core_1.normalizeMailAddress)(address.address));
+}
+function createMailroomSmtpServer(options) {
+    const maxMessageBytes = options.maxMessageBytes ?? 25 * 1024 * 1024;
+    const server = new smtp_server_1.SMTPServer({
+        disabledCommands: ["AUTH", "STARTTLS"],
+        logger: false,
+        onRcptTo(address, _session, callback) {
+            const normalized = (0, core_1.normalizeMailAddress)(address.address);
+            const resolved = (0, core_1.resolveMailAddress)(options.registry, normalized);
+            if (!resolved) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.mail_smtp_recipient_rejected",
+                    message: "smtp recipient rejected",
+                    meta: { address: normalized },
+                });
+                const error = new Error(`unknown recipient ${normalized}`);
+                error.responseCode = 550;
+                callback(error);
+                return;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.mail_smtp_recipient_accepted",
+                message: "smtp recipient accepted",
+                meta: { address: normalized, agentId: resolved.agentId },
+            });
+            callback();
+        },
+        async onData(stream, session, callback) {
+            try {
+                const raw = await collectStream(stream, maxMessageBytes);
+                const mailFrom = session.envelope.mailFrom;
+                /* v8 ignore next -- smtp-server exposes normal and null senders as address objects; false/undefined are defensive direct-call states. @preserve */
+                const rawMailFrom = mailFrom === false ? "" : mailFrom?.address ?? "";
+                const envelope = {
+                    mailFrom: rawMailFrom ? (0, core_1.normalizeMailAddress)(rawMailFrom) : "",
+                    rcptTo: sessionRecipients(session),
+                    /* v8 ignore next -- smtp-server network sessions carry remoteAddress; fallback is a defensive direct-call edge. @preserve */
+                    ...(session.remoteAddress ? { remoteAddress: session.remoteAddress } : {}),
+                };
+                const result = await (0, file_store_1.ingestRawMailToStore)({
+                    registry: options.registry,
+                    store: options.store,
+                    envelope,
+                    rawMime: raw,
+                });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.mail_smtp_data_stored",
+                    message: "smtp data stored",
+                    meta: { accepted: result.accepted.length, rejected: result.rejectedRecipients.length },
+                });
+                callback();
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.mail_smtp_data_error",
+                    message: "smtp data handling failed",
+                    meta: { error: error instanceof Error ? error.message : String(error) },
+                });
+                callback(error instanceof Error ? error : new Error(String(error)));
+            }
+        },
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_smtp_server_created",
+        message: "mailroom smtp server created",
+        meta: { maxMessageBytes },
+    });
+    return server;
+}
+function createMailroomHealthServer(registry) {
+    const server = http.createServer((_request, response) => {
+        const body = JSON.stringify({
+            ok: true,
+            service: "ouro-mailroom",
+            domain: registry.domain,
+            mailboxes: registry.mailboxes.length,
+            sourceGrants: registry.sourceGrants.length,
+        });
+        response.writeHead(200, {
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(body),
+        });
+        response.end(body);
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_health_server_created",
+        message: "mailroom health server created",
+        meta: { domain: registry.domain },
+    });
+    return server;
+}
+function startMailroomIngress(options) {
+    const smtp = createMailroomSmtpServer(options);
+    const health = createMailroomHealthServer(options.registry);
+    /* v8 ignore next -- production/container entrypoints may omit host; unit tests bind loopback explicitly. @preserve */
+    const host = options.host ?? "0.0.0.0";
+    smtp.listen(options.smtpPort, host);
+    health.listen(options.httpPort, host);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_ingress_started",
+        message: "mailroom ingress started",
+        meta: { smtpPort: options.smtpPort, httpPort: options.httpPort, host },
+    });
+    return { smtp, health };
+}

package/dist/mailroom/source-state.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDelegatedMailSourceState = createDelegatedMailSourceState;
+exports.markMboxBackfillComplete = markMboxBackfillComplete;
+exports.markForwardingProbeResult = markForwardingProbeResult;
+exports.renderDelegatedMailSourceNextStep = renderDelegatedMailSourceNextStep;
+const runtime_1 = require("../nerves/runtime");
+const core_1 = require("./core");
+const HUMAN_REQUIRED = [
+    "browser_auth",
+    "mfa_or_captcha",
+    "export_download",
+    "forwarding_confirmation",
+];
+function normalizedSource(source) {
+    const value = source.trim().toLowerCase();
+    return value || "hey";
+}
+function normalizedAgentId(agentId) {
+    return agentId.trim().toLowerCase();
+}
+function createDelegatedMailSourceState(input) {
+    const aliasAddress = (0, core_1.normalizeMailAddress)(input.aliasAddress);
+    const state = {
+        schemaVersion: 1,
+        agentId: normalizedAgentId(input.agentId),
+        ownerEmail: (0, core_1.normalizeMailAddress)(input.ownerEmail),
+        source: normalizedSource(input.source),
+        aliasAddress,
+        backfill: {
+            status: "not_started",
+        },
+        forwarding: {
+            status: "blocked_by_human",
+            targetAlias: aliasAddress,
+            browserAutomationOwner: "agent",
+            humanRequired: [...HUMAN_REQUIRED],
+        },
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_delegated_source_state_created",
+        message: "delegated mail source setup state created",
+        meta: {
+            agentId: state.agentId,
+            source: state.source,
+            forwardingStatus: state.forwarding.status,
+            backfillStatus: state.backfill.status,
+        },
+    });
+    return state;
+}
+function markMboxBackfillComplete(state, input) {
+    const nextState = {
+        ...state,
+        backfill: {
+            status: "ready",
+            scanned: input.scanned,
+            imported: input.imported,
+            duplicates: input.duplicates,
+            sourceFreshThrough: input.sourceFreshThrough,
+            completedAt: input.completedAt,
+        },
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_delegated_source_backfill_ready",
+        message: "delegated mail source archive backfill marked ready",
+        meta: {
+            agentId: nextState.agentId,
+            source: nextState.source,
+            scanned: input.scanned,
+            imported: input.imported,
+            duplicates: input.duplicates,
+            sourceFreshThroughKnown: input.sourceFreshThrough !== null,
+        },
+    });
+    return nextState;
+}
+function markForwardingProbeResult(state, input) {
+    const expectedRecipient = (0, core_1.normalizeMailAddress)(state.forwarding.targetAlias);
+    if (!input.observedRecipient) {
+        const nextState = {
+            ...state,
+            forwarding: {
+                ...state.forwarding,
+                status: "pending_propagation",
+                observedRecipient: null,
+                expectedRecipient,
+                recoveryAction: "Wait briefly, then have Slugger re-check the delegated source alias before asking the human to change HEY again.",
+            },
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_delegated_source_forwarding_probe",
+            message: "delegated mail source forwarding probe checked",
+            meta: {
+                agentId: nextState.agentId,
+                source: nextState.source,
+                status: nextState.forwarding.status,
+                observedRecipientPresent: false,
+                expectedRecipientDomain: expectedRecipient.split("@")[1],
+                messageIdPresent: Boolean(input.messageId),
+            },
+        });
+        return nextState;
+    }
+    const observedRecipient = (0, core_1.normalizeMailAddress)(input.observedRecipient);
+    if (observedRecipient !== expectedRecipient) {
+        const nextState = {
+            ...state,
+            forwarding: {
+                ...state.forwarding,
+                status: "failed_recoverable",
+                observedRecipient,
+                expectedRecipient,
+                ...(input.messageId ? { lastProbeMessageId: input.messageId } : {}),
+                recoveryAction: `HEY is forwarding to ${observedRecipient}. Slugger must correct the HEY forwarding target to ${expectedRecipient}; do not import or label that probe as delegated Ari HEY mail.`,
+            },
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_delegated_source_forwarding_probe",
+            message: "delegated mail source forwarding probe checked",
+            meta: {
+                agentId: nextState.agentId,
+                source: nextState.source,
+                status: nextState.forwarding.status,
+                observedRecipientPresent: true,
+                observedRecipientMatches: false,
+                expectedRecipientDomain: expectedRecipient.split("@")[1],
+                observedRecipientDomain: observedRecipient.split("@")[1],
+                messageIdPresent: Boolean(input.messageId),
+            },
+        });
+        return nextState;
+    }
+    const nextState = {
+        ...state,
+        forwarding: {
+            ...state.forwarding,
+            status: "ready",
+            observedRecipient,
+            expectedRecipient,
+            verifiedAt: input.checkedAt,
+            ...(input.messageId ? { lastProbeMessageId: input.messageId } : {}),
+        },
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_delegated_source_forwarding_probe",
+        message: "delegated mail source forwarding probe checked",
+        meta: {
+            agentId: nextState.agentId,
+            source: nextState.source,
+            status: nextState.forwarding.status,
+            observedRecipientPresent: true,
+            observedRecipientMatches: true,
+            expectedRecipientDomain: expectedRecipient.split("@")[1],
+            observedRecipientDomain: observedRecipient.split("@")[1],
+            messageIdPresent: Boolean(input.messageId),
+        },
+    });
+    return nextState;
+}
+function renderDelegatedMailSourceNextStep(state) {
+    if (state.forwarding.status === "ready") {
+        return `${state.source} forwarding is verified for ${state.aliasAddress}.`;
+    }
+    return [
+        `Slugger should continue ${state.source.toUpperCase()} setup with browser automation where it is safe.`,
+        "The human remains at the keyboard for login, MFA/CAPTCHA, export download, and final forwarding confirmation.",
+        `Forward ${state.ownerEmail}'s ${state.source} mailbox to ${state.aliasAddress}.`,
+        "Do not use the native agent mailbox as the forwarding target.",
+    ].join(" ");
+}