@ouro.bot/cli 0.1.0-alpha.48 → 0.1.0-alpha.481

package/dist/mailroom/reader.js

@@ -0,0 +1,197 @@
+"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.parseMailroomConfig = parseMailroomConfig;
+exports.readMailroomRegistry = readMailroomRegistry;
+exports.resolveMailroomReader = resolveMailroomReader;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const storage_blob_1 = require("@azure/storage-blob");
+const identity_1 = require("@azure/identity");
+const runtime_1 = require("../nerves/runtime");
+const identity_2 = require("../heart/identity");
+const runtime_credentials_1 = require("../heart/runtime-credentials");
+const blob_store_1 = require("./blob-store");
+const file_store_1 = require("./file-store");
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function textField(value, key) {
+    const raw = value[key];
+    return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
+}
+function numberField(value, key) {
+    const raw = value[key];
+    return typeof raw === "number" && Number.isFinite(raw) ? raw : undefined;
+}
+function parseMailroomConfig(value) {
+    if (!isRecord(value))
+        return null;
+    const mailboxAddress = textField(value, "mailboxAddress");
+    if (!mailboxAddress)
+        return null;
+    if (!isRecord(value.privateKeys))
+        return null;
+    const privateKeys = Object.fromEntries(Object.entries(value.privateKeys).filter((entry) => {
+        return typeof entry[0] === "string" && typeof entry[1] === "string" && entry[1].trim().length > 0;
+    }));
+    if (Object.keys(privateKeys).length === 0)
+        return null;
+    const registryPath = textField(value, "registryPath");
+    const storePath = textField(value, "storePath");
+    const azureAccountUrl = textField(value, "azureAccountUrl");
+    const azureContainer = textField(value, "azureContainer");
+    const registryAzureAccountUrl = textField(value, "registryAzureAccountUrl");
+    const registryContainer = textField(value, "registryContainer");
+    const registryBlob = textField(value, "registryBlob");
+    const azureManagedIdentityClientId = textField(value, "azureManagedIdentityClientId");
+    const smtpPort = numberField(value, "smtpPort");
+    const httpPort = numberField(value, "httpPort");
+    const host = textField(value, "host");
+    const attentionIntervalMs = numberField(value, "attentionIntervalMs");
+    const outbound = isRecord(value.outbound) ? { ...value.outbound } : undefined;
+    const autonomousSendPolicy = isRecord(value.autonomousSendPolicy)
+        ? { ...value.autonomousSendPolicy }
+        : undefined;
+    return {
+        mailboxAddress,
+        ...(registryPath ? { registryPath } : {}),
+        ...(storePath ? { storePath } : {}),
+        ...(azureAccountUrl ? { azureAccountUrl } : {}),
+        ...(azureContainer ? { azureContainer } : {}),
+        ...(registryAzureAccountUrl ? { registryAzureAccountUrl } : {}),
+        ...(registryContainer ? { registryContainer } : {}),
+        ...(registryBlob ? { registryBlob } : {}),
+        ...(azureManagedIdentityClientId ? { azureManagedIdentityClientId } : {}),
+        ...(smtpPort !== undefined ? { smtpPort } : {}),
+        ...(httpPort !== undefined ? { httpPort } : {}),
+        ...(host ? { host } : {}),
+        ...(attentionIntervalMs !== undefined ? { attentionIntervalMs } : {}),
+        ...(outbound ? { outbound } : {}),
+        ...(autonomousSendPolicy ? { autonomousSendPolicy } : {}),
+        privateKeys,
+    };
+}
+function createBlobCredential(config) {
+    return config.azureManagedIdentityClientId
+        ? new identity_1.DefaultAzureCredential({ managedIdentityClientId: config.azureManagedIdentityClientId })
+        : new identity_1.DefaultAzureCredential();
+}
+function createMailroomStore(config, agentName) {
+    if (config.azureAccountUrl) {
+        const containerName = config.azureContainer ?? "mailroom";
+        return {
+            store: new blob_store_1.AzureBlobMailroomStore({
+                serviceClient: new storage_blob_1.BlobServiceClient(config.azureAccountUrl, createBlobCredential(config)),
+                containerName,
+            }),
+            storeKind: "azure-blob",
+            storeLabel: `${config.azureAccountUrl}/${containerName}`,
+        };
+    }
+    const storePath = config.storePath ?? path.join((0, identity_2.getAgentRoot)(agentName), "state", "mailroom");
+    return {
+        store: new file_store_1.FileMailroomStore({ rootDir: storePath }),
+        storeKind: "file",
+        storeLabel: storePath,
+    };
+}
+async function readMailroomRegistry(config) {
+    if (config.registryPath) {
+        return JSON.parse(fs.readFileSync(config.registryPath, "utf-8"));
+    }
+    const registryAzureAccountUrl = config.registryAzureAccountUrl ?? config.azureAccountUrl;
+    const registryContainer = config.registryContainer ?? config.azureContainer ?? "mailroom";
+    const registryBlob = config.registryBlob;
+    if (!registryAzureAccountUrl || !registryBlob) {
+        throw new Error("mailroom config is missing registryPath or hosted registry coordinates");
+    }
+    const serviceClient = new storage_blob_1.BlobServiceClient(registryAzureAccountUrl, createBlobCredential(config));
+    const blobClient = serviceClient.getContainerClient(registryContainer).getBlockBlobClient(registryBlob);
+    if (!await blobClient.exists()) {
+        throw new Error(`mailroom registry blob not found: ${registryAzureAccountUrl}/${registryContainer}/${registryBlob}`);
+    }
+    return JSON.parse((await blobClient.downloadToBuffer()).toString("utf-8"));
+}
+function resolveMailroomReader(agentName = (0, identity_2.getAgentName)()) {
+    const runtime = (0, runtime_credentials_1.readRuntimeCredentialConfig)(agentName);
+    if (!runtime.ok) {
+        const result = {
+            ok: false,
+            agentName,
+            reason: "auth-required",
+            error: `AUTH_REQUIRED:mailroom -- Mail is not available because ${runtime.itemPath} is ${runtime.reason}. Agent-runnable repair after vault unlock: 'ouro connect mail --agent ${agentName}'.`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_reader_resolved",
+            message: "mailroom reader resolved",
+            meta: { agentName, status: result.reason },
+        });
+        return result;
+    }
+    const config = parseMailroomConfig(runtime.config.mailroom);
+    if (!config) {
+        const result = {
+            ok: false,
+            agentName,
+            reason: "misconfigured",
+            error: `AUTH_REQUIRED:mailroom -- Missing mailroom mailbox/private key config in vault runtime/config for ${agentName}.`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_reader_resolved",
+            message: "mailroom reader resolved",
+            meta: { agentName, status: result.reason },
+        });
+        return result;
+    }
+    const store = createMailroomStore(config, agentName);
+    const result = {
+        ok: true,
+        agentName,
+        config,
+        store: store.store,
+        storeKind: store.storeKind,
+        storeLabel: store.storeLabel,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_reader_resolved",
+        message: "mailroom reader resolved",
+        meta: { agentName, status: "ready", mailboxAddress: config.mailboxAddress, storeKind: store.storeKind },
+    });
+    return result;
+}

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(" ");
+}

package/dist/mailroom/travel-extract.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTravelFactsFromMail = extractTravelFactsFromMail;
+const runtime_1 = require("../nerves/runtime");
+function firstMatch(text, pattern) {
+    const match = pattern.exec(text);
+    return match?.[1]?.trim() ?? null;
+}
+function flightFact(message) {
+    const text = `${message.private.subject}\n${message.private.text}`;
+    const flightNumber = firstMatch(text, /\bflight\s+([A-Z]{2}\s?\d{1,4})\b/i);
+    const routeMatch = /\b([A-Z]{3})\s*(?:->|to)\s*([A-Z]{3})\b/.exec(text);
+    const confirmationCode = firstMatch(text, /confirmation code:\s*([A-Z0-9-]+)/i);
+    const departure = firstMatch(text, /departure:\s*([^\n]+)/i);
+    if (!flightNumber && !routeMatch && !departure)
+        return null;
+    const fields = {};
+    if (flightNumber)
+        fields.flightNumber = flightNumber.toUpperCase().replace(/\s+/, " ");
+    if (routeMatch)
+        fields.route = `${routeMatch[1]} -> ${routeMatch[2]}`;
+    if (departure)
+        fields.departure = departure;
+    if (confirmationCode)
+        fields.confirmationCode = confirmationCode;
+    return {
+        kind: "flight",
+        messageId: message.id,
+        subject: message.private.subject,
+        source: message.source ?? null,
+        ownerEmail: message.ownerEmail ?? null,
+        summary: [
+            fields.flightNumber ? `flight ${fields.flightNumber}` : "flight",
+            fields.route ? fields.route : null,
+            fields.departure ? `departing ${fields.departure}` : null,
+        ].filter(Boolean).join(" "),
+        fields,
+    };
+}
+function lodgingFact(message) {
+    const text = `${message.private.subject}\n${message.private.text}`;
+    const hotel = firstMatch(text, /hotel:\s*([^\n]+)/i);
+    const checkIn = firstMatch(text, /check-?in:\s*([^\n]+)/i);
+    const checkOut = firstMatch(text, /check-?out:\s*([^\n]+)/i);
+    const confirmationCode = firstMatch(text, /confirmation code:\s*([A-Z0-9-]+)/i);
+    if (!hotel && !checkIn && !/hotel|lodging|booking/i.test(message.private.subject))
+        return null;
+    const fields = {};
+    if (hotel)
+        fields.hotel = hotel;
+    if (checkIn)
+        fields.checkIn = checkIn;
+    if (checkOut)
+        fields.checkOut = checkOut;
+    if (confirmationCode)
+        fields.confirmationCode = confirmationCode;
+    return {
+        kind: "lodging",
+        messageId: message.id,
+        subject: message.private.subject,
+        source: message.source ?? null,
+        ownerEmail: message.ownerEmail ?? null,
+        summary: [
+            hotel ?? "lodging",
+            checkIn ? `check-in ${checkIn}` : null,
+            checkOut ? `check-out ${checkOut}` : null,
+        ].filter(Boolean).join(" "),
+        fields,
+    };
+}
+function extractTravelFactsFromMail(messages) {
+    const facts = messages.flatMap((message) => {
+        const results = [];
+        const flight = flightFact(message);
+        if (flight)
+            results.push(flight);
+        const lodging = lodgingFact(message);
+        if (lodging)
+            results.push(lodging);
+        return results;
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_travel_facts_extracted",
+        message: "travel facts extracted from mail",
+        meta: { messages: messages.length, facts: facts.length },
+    });
+    return facts;
+}

package/dist/mind/bundle-manifest.js

@@ -52,7 +52,13 @@ exports.CANONICAL_BUNDLE_MANIFEST = [
     { path: "psyche/LORE.md", kind: "file" },
     { path: "psyche/TACIT.md", kind: "file" },
     { path: "psyche/ASPIRATIONS.md", kind: "file" },
-    { path: "psyche/memory", kind: "dir" },
+    { path: "arc", kind: "dir" },
+    { path: "arc/episodes", kind: "dir" },
+    { path: "arc/obligations", kind: "dir" },
+    { path: "arc/cares", kind: "dir" },
+    { path: "arc/intentions", kind: "dir" },
+    { path: "diary", kind: "dir" },
+    { path: "journal", kind: "dir" },
     { path: "friends", kind: "dir" },
     { path: "state", kind: "dir" },
     { path: "tasks", kind: "dir" },