@ouro.bot/cli 0.1.0-alpha.468 → 0.1.0-alpha.469

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.469",
+      "changes": [
+        "Delegated HEY MBOX imports now preserve archive freshness/provenance, use message dates when present, suppress historical Screener wakeups, and show `source fresh through` in `ouro mail import-mbox` output.",
+        "Agent Mail setup docs and source-state helpers now orient Slugger to drive browser automation while the human handles HEY login/MFA/export/forwarding confirmation, including recovery for wrong forwarding targets such as `slugger@ouro.bot`.",
+        "Delegated source setup state now emits body-safe Nerves events, and coverage locks the source-state, MBOX import, CLI freshness fallback, and Mailroom ingest provenance branches."
+      ]
+    },
     {
       "version": "0.1.0-alpha.468",
       "changes": [

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

@@ -3391,6 +3391,8 @@ async function executeMailImportMbox(command, deps) {
             `scanned: ${result.scanned}`,
             `imported: ${result.imported}`,
             `duplicates: ${result.duplicates}`,
+            `source fresh through: ${result.sourceFreshThrough ?? "unknown"}`,
+            "archive imports are historical; they do not create Screener wakeups.",
             "body reads remain explicit through mail_recent/mail_search/mail_thread and are access-logged.",
         ].join("\n");
         deps.writeStdout(message);

package/dist/mailroom/core.js

@@ -305,6 +305,9 @@ function candidateSender(input) {
         return { email: "(unknown)", display: input.envelope.mailFrom.trim() };
     }
 }
+function normalizedIngestProvenance(input) {
+    return input ?? { schemaVersion: 1, kind: "smtp" };
+}
 async function buildStoredMailMessage(input) {
     const parsed = await (0, mailparser_1.simpleParser)(input.rawMime);
     const id = messageStorageId(input.envelope, input.rawMime);
@@ -355,10 +358,12 @@ async function buildStoredMailMessage(input) {
         rawSha256,
         rawSize: input.rawMime.byteLength,
         privateEnvelope: privatePayload,
+        ingest: normalizedIngestProvenance(input.ingest),
         receivedAt,
     };
     const sender = candidateSender({ parsedFrom: privateEnvelope.from, envelope: input.envelope });
-    const candidate = input.classification?.candidate || placement === "screener"
+    const shouldCreateCandidate = input.classification?.candidate ?? placement === "screener";
+    const candidate = shouldCreateCandidate
         ? {
             schemaVersion: 1,
             id: `candidate_${id}`,

package/dist/mailroom/file-store.js

@@ -368,6 +368,7 @@ async function ingestRawMailToStore(input) {
             envelope: input.envelope,
             rawMime: input.rawMime,
             receivedAt: input.receivedAt,
+            ...(input.ingest ? { ingest: input.ingest } : {}),
             classification,
         });
         accepted.push(result.message);

package/dist/mailroom/mbox-import.js

@@ -48,13 +48,32 @@ function findSourceGrant(input) {
     }
     return grants[0];
 }
-async function envelopeForMboxMessage(rawMessage, grant) {
+async function parseMboxMessage(rawMessage, grant) {
     const parsed = await (0, mailparser_1.simpleParser)(rawMessage);
     const mailFrom = parsed.from?.value?.[0]?.address;
     return {
-        mailFrom: mailFrom ? (0, core_1.normalizeMailAddress)(mailFrom) : "",
-        rcptTo: [(0, core_1.normalizeMailAddress)(grant.aliasAddress)],
-        remoteAddress: "mbox-import",
+        rawMessage,
+        envelope: {
+            mailFrom: mailFrom ? (0, core_1.normalizeMailAddress)(mailFrom) : "",
+            rcptTo: [(0, core_1.normalizeMailAddress)(grant.aliasAddress)],
+            remoteAddress: "mbox-import",
+        },
+        ...(parsed.date ? { messageDate: parsed.date } : {}),
+    };
+}
+function latestMessageDate(messages) {
+    const timestamps = messages
+        .map((message) => message.messageDate?.getTime())
+        .filter((timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp));
+    if (timestamps.length === 0)
+        return null;
+    return new Date(Math.max(...timestamps)).toISOString();
+}
+function historicalImportClassification(resolvedPlacement, sourceGrant) {
+    return {
+        placement: resolvedPlacement,
+        candidate: false,
+        trustReason: `delegated source grant ${sourceGrant.source} historical mbox import`,
     };
 }
 async function importMboxToStore(input) {
@@ -75,12 +94,23 @@ async function importMboxToStore(input) {
     let duplicates = 0;
     const messages = [];
     const rawMessages = splitMboxMessages(input.rawMbox);
-    for (const rawMessage of rawMessages) {
+    const parsedMessages = await Promise.all(rawMessages.map((rawMessage) => parseMboxMessage(rawMessage, sourceGrant)));
+    const importedAt = (input.importedAt ?? new Date()).toISOString();
+    const sourceFreshThrough = latestMessageDate(parsedMessages);
+    for (const parsedMessage of parsedMessages) {
         const result = await input.store.putRawMessage({
             resolved,
-            envelope: await envelopeForMboxMessage(rawMessage, sourceGrant),
-            rawMime: rawMessage,
-            receivedAt: input.importedAt,
+            envelope: parsedMessage.envelope,
+            rawMime: parsedMessage.rawMessage,
+            receivedAt: parsedMessage.messageDate ?? input.importedAt,
+            ingest: {
+                schemaVersion: 1,
+                kind: "mbox-import",
+                importedAt,
+                sourceFreshThrough,
+                attentionSuppressed: true,
+            },
+            classification: historicalImportClassification(resolved.defaultPlacement, sourceGrant),
         });
         messages.push(result.message);
         if (result.created)
@@ -100,6 +130,7 @@ async function importMboxToStore(input) {
         scanned: rawMessages.length,
         imported,
         duplicates,
+        sourceFreshThrough,
         messages,
     };
 }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.468",
+  "version": "0.1.0-alpha.469",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",