@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.636

package/dist/heart/mailbox/readers/continuity-readers.js

@@ -0,0 +1,319 @@
+"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.readMailboxContinuity = readMailboxContinuity;
+exports.readOrientationView = readOrientationView;
+exports.readObligationDetailView = readObligationDetailView;
+exports.readChangesView = readChangesView;
+exports.readSelfFixView = readSelfFixView;
+exports.readNoteDecisionView = readNoteDecisionView;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../../nerves/runtime");
+const cares_1 = require("../../../arc/cares");
+const episodes_1 = require("../../../arc/episodes");
+const obligations_1 = require("../../../arc/obligations");
+const presence_1 = require("../../../arc/presence");
+const active_work_1 = require("../../active-work");
+const session_activity_1 = require("../../session-activity");
+const agent_machine_1 = require("./agent-machine");
+function sortOpenObligations(obligations) {
+    const statusPriority = {
+        returning: 0,
+        collaborating: 1,
+        in_progress: 2,
+        delegated: 3,
+        accepted: 4,
+        pending: 5,
+    };
+    return obligations
+        .map((obligation) => ({
+        obligation,
+        priority: statusPriority[obligation.status] ?? 99,
+        updatedMs: new Date(obligation.updatedAt ?? obligation.createdAt).getTime(),
+    }))
+        .sort((a, b) => {
+        if (a.priority !== b.priority)
+            return a.priority - b.priority;
+        return b.updatedMs - a.updatedMs;
+    })
+        .map((entry) => entry.obligation);
+}
+function readMailboxContinuity(agentRoot, agentName) {
+    const self = (0, presence_1.readPresence)(agentRoot, agentName);
+    const peers = (0, presence_1.readPeerPresence)(agentRoot);
+    const cares = (0, cares_1.readActiveCares)(agentRoot);
+    const episodes = (0, episodes_1.readRecentEpisodes)(agentRoot, { limit: 10 });
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.mailbox_continuity_read",
+        message: `mailbox continuity: ${cares.length} cares, ${episodes.length} episodes`,
+        meta: { careCount: cares.length, episodeCount: episodes.length, hasSelf: self != null, peerCount: peers.length },
+    });
+    return {
+        presence: { self, peers },
+        cares: {
+            activeCount: cares.length,
+            items: cares.map((c) => ({
+                id: c.id,
+                label: c.label,
+                status: c.status,
+                salience: c.salience,
+            })),
+        },
+        episodes: {
+            recentCount: episodes.length,
+            items: episodes.map((ep) => ({
+                id: ep.id,
+                kind: ep.kind,
+                summary: ep.summary,
+                timestamp: ep.timestamp,
+            })),
+        },
+    };
+}
+function readOrientationView(agentRoot, agentName) {
+    let obligations = [];
+    try {
+        obligations = (0, obligations_1.readObligations)(agentRoot);
+    }
+    catch {
+        obligations = [];
+    }
+    const openObligations = obligations.filter(obligations_1.isOpenObligation);
+    const sorted = sortOpenObligations(openObligations);
+    const primary = sorted[0] ?? null;
+    let sessions = [];
+    try {
+        sessions = (0, session_activity_1.listSessionActivity)({
+            sessionsDir: path.join(agentRoot, "state", "sessions"),
+            friendsDir: path.join(agentRoot, "friends"),
+            agentName,
+        });
+    }
+    catch {
+        sessions = [];
+    }
+    const sortedSessions = [...sessions].sort((a, b) => b.lastActivityMs - a.lastActivityMs);
+    const currentSession = sortedSessions.length > 0
+        ? {
+            friendId: sortedSessions[0].friendId,
+            channel: sortedSessions[0].channel,
+            key: sortedSessions[0].key,
+            lastActivityAt: sortedSessions[0].lastActivityAt,
+        }
+        : null;
+    const otherActiveSessions = sortedSessions.slice(1).map((s) => ({
+        friendId: s.friendId,
+        friendName: s.friendName,
+        channel: s.channel,
+        key: s.key,
+        lastActivityAt: s.lastActivityAt,
+    }));
+    const parts = [];
+    if (primary)
+        parts.push(primary.content);
+    if (openObligations.length > 1)
+        parts.push(`${openObligations.length} open obligations`);
+    if (sessions.length > 0)
+        parts.push(`${sessions.length} active sessions`);
+    const centerOfGravity = parts.length > 0 ? parts.join(" | ") : "idle";
+    const primaryObligation = primary
+        ? {
+            id: primary.id,
+            content: primary.content,
+            status: primary.status,
+            nextAction: primary.nextAction ?? null,
+            waitingOn: primary.meaning?.waitingOn?.detail ?? null,
+        }
+        : null;
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.mailbox_orientation_read",
+        message: `mailbox orientation: ${openObligations.length} obligations, ${sessions.length} sessions`,
+        meta: { obligationCount: openObligations.length, sessionCount: sessions.length, primaryId: primary?.id ?? null },
+    });
+    return {
+        currentSession,
+        centerOfGravity,
+        primaryObligation,
+        resumeHandle: null,
+        otherActiveSessions,
+        rawState: null,
+    };
+}
+function readObligationDetailView(agentRoot) {
+    let obligations = [];
+    try {
+        obligations = (0, obligations_1.readObligations)(agentRoot);
+    }
+    catch {
+        obligations = [];
+    }
+    const openObligations = obligations.filter(obligations_1.isOpenObligation);
+    const sorted = sortOpenObligations(openObligations);
+    const primary = sorted[0] ?? null;
+    const normalizedSummary = new Map((0, agent_machine_1.readObligationSummary)(agentRoot).items.map((item) => [item.id, item.currentSurface]));
+    const items = openObligations.map((ob) => ({
+        id: ob.id,
+        status: ob.status,
+        content: ob.content,
+        updatedAt: ob.updatedAt ?? ob.createdAt,
+        nextAction: ob.nextAction ?? null,
+        origin: ob.origin ?? null,
+        currentSurface: normalizedSummary.has(ob.id)
+            ? (normalizedSummary.get(ob.id) ?? null)
+            : (ob.currentSurface ? { kind: ob.currentSurface.kind, label: ob.currentSurface.label } : null),
+        meaning: ob.meaning ? { waitingOn: ob.meaning.waitingOn?.detail ?? null } : null,
+        isPrimary: ob.id === primary.id,
+    }));
+    let primarySelectionReason = null;
+    if (primary) {
+        if (primary.status !== "pending") {
+            primarySelectionReason = `most advanced status: ${primary.status}`;
+        }
+        else {
+            primarySelectionReason = "most recent pending";
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.mailbox_obligations_read",
+        message: `mailbox obligations: ${openObligations.length} open`,
+        meta: { openCount: openObligations.length, primaryId: primary?.id ?? null },
+    });
+    return {
+        openCount: openObligations.length,
+        primaryId: primary?.id ?? null,
+        primarySelectionReason,
+        items,
+    };
+}
+function readChangesView(agentRoot) {
+    const snapshotPath = path.join(agentRoot, "state", "mailbox", "active-work-snapshot.json");
+    const legacySnapshotPath = path.join(agentRoot, "state", "outlook", "active-work-snapshot.json");
+    let previous = null;
+    try {
+        const raw = fs.readFileSync(fs.existsSync(snapshotPath) ? snapshotPath : legacySnapshotPath, "utf-8");
+        previous = JSON.parse(raw);
+        if (!previous.obligationSnapshots || !previous.codingSnapshots)
+            previous = null;
+    }
+    catch {
+        previous = null;
+    }
+    let obligations = [];
+    try {
+        obligations = (0, obligations_1.readObligations)(agentRoot);
+    }
+    catch {
+        obligations = [];
+    }
+    const openObligations = obligations.filter(obligations_1.isOpenObligation);
+    const current = {
+        obligationSnapshots: openObligations.map((ob) => ({
+            id: ob.id,
+            status: ob.status,
+            artifact: ob.currentArtifact?.trim() || null,
+            nextAction: ob.nextAction?.trim() || null,
+        })),
+        codingSnapshots: [],
+        timestamp: new Date().toISOString(),
+    };
+    try {
+        fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+        fs.writeFileSync(snapshotPath, JSON.stringify(current, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // Best effort
+    }
+    if (!previous) {
+        return { changeCount: 0, items: [], snapshotAge: null, formatted: "" };
+    }
+    const changes = (0, active_work_1.detectActiveWorkChanges)(previous, current);
+    const formatted = (0, active_work_1.formatActiveWorkChanges)(changes);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.mailbox_changes_read",
+        message: `mailbox changes: ${changes.length} detected`,
+        meta: { changeCount: changes.length, snapshotAge: previous.timestamp },
+    });
+    return {
+        changeCount: changes.length,
+        items: changes.map((c) => ({ kind: c.kind, id: c.id, from: c.from, to: c.to, summary: c.summary })),
+        snapshotAge: previous.timestamp,
+        formatted,
+    };
+}
+function readSelfFixView(_agentRoot) {
+    // W6 Unit 8a: self-fix view used to scan `tasks/` for fix-named tasks.
+    // The built-in task module is being retired; the desk MCP server owns
+    // task state now. The self-fix surface will be re-derived from desk in a
+    // follow-up unit. Return inactive until that wiring lands.
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.mailbox_selffix_read",
+        message: "mailbox self-fix: inactive (desk wiring pending)",
+        meta: { taskCount: 0, active: false },
+    });
+    return { active: false, currentStep: null, steps: [] };
+}
+function readNoteDecisionView(agentRoot, limit = 50) {
+    const logPath = path.join(agentRoot, "state", "mailbox", "note-decisions.jsonl");
+    const legacyLogPath = path.join(agentRoot, "state", "outlook", "note-decisions.jsonl");
+    let lines = [];
+    try {
+        const raw = fs.readFileSync(fs.existsSync(logPath) ? logPath : legacyLogPath, "utf-8");
+        lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    }
+    catch {
+        return { totalCount: 0, items: [] };
+    }
+    const items = [];
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.kind && parsed.decision && parsed.timestamp) {
+                items.push(parsed);
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    items.reverse();
+    const limited = items.slice(0, limit);
+    return { totalCount: items.length, items: limited };
+}

package/dist/heart/mailbox/readers/mail.js

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readMailView = readMailView;
+exports.readMailMessageView = readMailMessageView;
+const runtime_1 = require("../../../nerves/runtime");
+const file_store_1 = require("../../../mailroom/file-store");
+const reader_1 = require("../../../mailroom/reader");
+const core_1 = require("../../../mailroom/core");
+const MAILBOX_MAIL_LIST_LIMIT = 50;
+const MAILBOX_MAIL_SUMMARY_LIMIT = MAILBOX_MAIL_LIST_LIMIT;
+// Cap the outbound list returned to the UI. The Mailbox tab renders a
+// bounded recent-outbound view; surfacing the entire outbound history is
+// what makes the tab hang on a loading spinner for large mailboxes.
+const MAILBOX_MAIL_OUTBOUND_LIMIT = 50;
+const MAILBOX_MAIL_BODY_LIMIT = 12_000;
+function emptyFolders() {
+    return [
+        { id: "imbox", label: "Imbox", count: 0 },
+        { id: "screener", label: "Screener", count: 0 },
+        { id: "discarded", label: "Discarded", count: 0 },
+        { id: "quarantine", label: "Quarantine", count: 0 },
+        { id: "draft", label: "Drafts", count: 0 },
+        { id: "sent", label: "Sent", count: 0 },
+        { id: "delegated", label: "Delegated", count: 0 },
+        { id: "native", label: "Native", count: 0 },
+    ];
+}
+function emptyRecovery() {
+    return { discardedCount: 0, quarantineCount: 0, undecryptableCount: 0, missingKeyIds: [] };
+}
+function unavailableMailView(agentName, status, error) {
+    return {
+        status,
+        agentName,
+        mailboxAddress: null,
+        generatedAt: new Date().toISOString(),
+        store: null,
+        folders: emptyFolders(),
+        messages: [],
+        screener: [],
+        outbound: [],
+        recovery: emptyRecovery(),
+        accessLog: [],
+        error,
+    };
+}
+function unavailableMessageView(agentName, status, error) {
+    return {
+        status,
+        agentName,
+        mailboxAddress: null,
+        generatedAt: new Date().toISOString(),
+        message: null,
+        accessLog: [],
+        error,
+    };
+}
+function mailSummary(message) {
+    const provenance = {
+        placement: message.placement,
+        compartmentKind: message.compartmentKind,
+        ownerEmail: message.ownerEmail ?? null,
+        source: message.source ?? null,
+        recipient: message.recipient,
+        mailboxId: message.mailboxId,
+        grantId: message.grantId ?? null,
+        trustReason: message.trustReason,
+    };
+    return {
+        id: message.id,
+        subject: message.private.subject,
+        from: message.private.from,
+        to: message.private.to,
+        cc: message.private.cc,
+        date: message.private.date ?? null,
+        receivedAt: message.receivedAt,
+        snippet: message.private.snippet,
+        placement: message.placement,
+        compartmentKind: message.compartmentKind,
+        ownerEmail: message.ownerEmail ?? null,
+        source: message.source ?? null,
+        recipient: message.recipient,
+        attachmentCount: message.private.attachments.length,
+        untrustedContentWarning: message.private.untrustedContentWarning,
+        provenance,
+    };
+}
+function missingPrivateMailKeyId(error) {
+    /* v8 ignore next -- non-Error throw branch: decryptMessages only ever throws Error subclasses (MissingPrivateMailKeyError or crypto errors); this guard is defensive. @preserve */
+    if (!(error instanceof Error))
+        return null;
+    const errorWithKeyId = error;
+    return typeof errorWithKeyId.keyId === "string" && errorWithKeyId.keyId.length > 0
+        ? errorWithKeyId.keyId
+        : null;
+}
+function decryptVisibleMessages(messages, privateKeys) {
+    const decrypted = [];
+    const skipped = [];
+    for (const message of messages) {
+        try {
+            decrypted.push((0, file_store_1.decryptMessages)([message], privateKeys)[0]);
+        }
+        catch (error) {
+            const keyId = missingPrivateMailKeyId(error);
+            if (!keyId)
+                throw error;
+            skipped.push({ messageId: message.id, keyId });
+        }
+    }
+    return { decrypted, skipped };
+}
+function buildFolders(messages, outbound) {
+    const folders = [
+        { id: "imbox", label: "Imbox", count: messages.filter((message) => message.placement === "imbox").length },
+        { id: "screener", label: "Screener", count: messages.filter((message) => message.placement === "screener").length },
+        { id: "discarded", label: "Discarded", count: messages.filter((message) => message.placement === "discarded").length },
+        { id: "quarantine", label: "Quarantine", count: messages.filter((message) => message.placement === "quarantine").length },
+        { id: "draft", label: "Drafts", count: outbound.filter((record) => record.status === "draft").length },
+        { id: "sent", label: "Sent", count: outbound.filter((record) => record.status !== "draft").length },
+        { id: "delegated", label: "Delegated", count: messages.filter((message) => message.compartmentKind === "delegated").length },
+        { id: "native", label: "Native", count: messages.filter((message) => message.compartmentKind === "native").length },
+    ];
+    const sourceCounts = new Map();
+    const sourceOwnerCounts = new Map();
+    for (const message of messages) {
+        if (!message.source)
+            continue;
+        sourceCounts.set(message.source, (sourceCounts.get(message.source) ?? 0) + 1);
+        const owner = message.ownerEmail ?? "";
+        const ownerCounts = sourceOwnerCounts.get(message.source) ?? new Map();
+        ownerCounts.set(owner, (ownerCounts.get(owner) ?? 0) + 1);
+        sourceOwnerCounts.set(message.source, ownerCounts);
+    }
+    for (const [source, count] of [...sourceCounts.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        const ownerCounts = sourceOwnerCounts.get(source);
+        if (!ownerCounts || ownerCounts.size <= 1) {
+            folders.push({ id: `source:${source}`, label: source.toUpperCase(), count });
+            continue;
+        }
+        for (const [owner, ownerCount] of [...ownerCounts.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+            const ownerLabel = owner || "unknown owner";
+            const ownerId = owner || "unknown-owner";
+            folders.push({ id: `source:${source}:${ownerId}`, label: `${source.toUpperCase()} / ${ownerLabel}`, count: ownerCount });
+        }
+    }
+    return folders;
+}
+function screenerCandidate(candidate) {
+    return {
+        id: candidate.id,
+        messageId: candidate.messageId,
+        senderEmail: candidate.senderEmail,
+        senderDisplay: candidate.senderDisplay,
+        recipient: candidate.recipient,
+        source: candidate.source ?? null,
+        ownerEmail: candidate.ownerEmail ?? null,
+        status: candidate.status,
+        placement: candidate.placement,
+        trustReason: candidate.trustReason,
+        firstSeenAt: candidate.firstSeenAt,
+        lastSeenAt: candidate.lastSeenAt,
+        messageCount: candidate.messageCount,
+    };
+}
+function outboundRecord(record) {
+    const policyDecision = record.policyDecision;
+    return {
+        id: record.id,
+        status: record.status,
+        mailboxRole: record.mailboxRole ?? "agent-native-mailbox",
+        sendAuthority: record.sendAuthority ?? "agent-native",
+        ownerEmail: record.ownerEmail ?? null,
+        source: record.source ?? null,
+        from: record.from,
+        to: record.to,
+        cc: record.cc,
+        bcc: record.bcc,
+        subject: record.subject,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        sentAt: record.sentAt ?? null,
+        submittedAt: record.submittedAt ?? null,
+        acceptedAt: record.acceptedAt ?? null,
+        deliveredAt: record.deliveredAt ?? null,
+        failedAt: record.failedAt ?? null,
+        sendMode: record.sendMode ?? null,
+        policyDecision: policyDecision
+            ? {
+                allowed: policyDecision.allowed,
+                mode: policyDecision.mode,
+                code: policyDecision.code,
+                reason: policyDecision.reason,
+                evaluatedAt: policyDecision.evaluatedAt,
+                recipients: policyDecision.recipients,
+                fallback: policyDecision.fallback,
+                policyId: policyDecision.policyId ?? null,
+                remainingSendsInWindow: policyDecision.remainingSendsInWindow ?? null,
+            }
+            : null,
+        provider: record.provider ?? null,
+        providerMessageId: record.providerMessageId ?? null,
+        providerRequestId: record.providerRequestId ?? null,
+        operationLocation: record.operationLocation ?? null,
+        deliveryEvents: (record.deliveryEvents ?? []).map((event) => ({
+            provider: event.provider,
+            providerEventId: event.providerEventId,
+            providerMessageId: event.providerMessageId,
+            outcome: event.outcome,
+            recipient: event.recipient ?? null,
+            occurredAt: event.occurredAt,
+            receivedAt: event.receivedAt,
+            bodySafeSummary: event.bodySafeSummary,
+            providerStatus: event.providerStatus ?? null,
+        })),
+        transport: record.transport ?? null,
+        reason: record.reason,
+    };
+}
+function buildRecovery(messages, skipped = []) {
+    return {
+        discardedCount: messages.filter((message) => message.placement === "discarded").length,
+        quarantineCount: messages.filter((message) => message.placement === "quarantine").length,
+        undecryptableCount: skipped.length,
+        missingKeyIds: [...new Set(skipped.map((entry) => entry.keyId))].sort(),
+    };
+}
+function accessEntries(entries) {
+    return entries
+        .slice()
+        .sort((left, right) => right.accessedAt.localeCompare(left.accessedAt))
+        .slice(0, 20)
+        .map((entry) => ({
+        id: entry.id,
+        messageId: entry.messageId ?? null,
+        threadId: entry.threadId ?? null,
+        tool: entry.tool,
+        reason: entry.reason,
+        mailboxRole: entry.mailboxRole ?? null,
+        compartmentKind: entry.compartmentKind ?? null,
+        ownerEmail: entry.ownerEmail ?? null,
+        source: entry.source ?? null,
+        accessedAt: entry.accessedAt,
+    }));
+}
+function accessProvenance(message) {
+    const provenance = (0, core_1.describeMailProvenance)(message);
+    return {
+        mailboxRole: provenance.mailboxRole,
+        compartmentKind: message.compartmentKind,
+        ownerEmail: provenance.ownerEmail,
+        source: provenance.source,
+    };
+}
+function emitMailRead(agentName, mode, status) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.mailbox_mail_read",
+        message: "reading Mailbox mail surface",
+        meta: { agentName, mode, status },
+    });
+}
+function statusFromReaderFailure(reason) {
+    return reason;
+}
+async function readMailView(agentName) {
+    const resolved = await (0, reader_1.resolveMailroomReaderWithRefresh)(agentName);
+    if (!resolved.ok) {
+        const status = statusFromReaderFailure(resolved.reason);
+        emitMailRead(agentName, "list", status);
+        return unavailableMailView(agentName, status, resolved.error);
+    }
+    try {
+        const stored = await resolved.store.listMessages({ agentId: agentName, limit: MAILBOX_MAIL_SUMMARY_LIMIT });
+        const result = decryptVisibleMessages(stored, resolved.config.privateKeys);
+        const summaries = result.decrypted.map(mailSummary);
+        const screener = (await resolved.store.listScreenerCandidates({ agentId: agentName, status: "pending", limit: 100 }))
+            .map(screenerCandidate);
+        // Cap outbound records returned to the UI. The mailbox tab shows a
+        // bounded recent-outbound view; pulling the entire history blocks the
+        // Mailbox tab on a loading spinner while the blob/file store grinds
+        // through every outbound record the agent has ever written.
+        const outbound = (await resolved.store.listMailOutbound(agentName, { limit: MAILBOX_MAIL_OUTBOUND_LIMIT })).map(outboundRecord);
+        await resolved.store.recordAccess({
+            agentId: agentName,
+            tool: "mailbox_mail_list",
+            reason: "mailbox read-only mailbox",
+        });
+        const accessLog = accessEntries(await resolved.store.listAccessLog(agentName));
+        emitMailRead(agentName, "list", "ready");
+        return {
+            status: "ready",
+            agentName,
+            mailboxAddress: resolved.config.mailboxAddress,
+            generatedAt: new Date().toISOString(),
+            store: {
+                kind: resolved.storeKind,
+                label: resolved.storeLabel,
+            },
+            folders: buildFolders(summaries, outbound),
+            messages: summaries.slice(0, MAILBOX_MAIL_LIST_LIMIT),
+            screener,
+            outbound,
+            recovery: buildRecovery(summaries, result.skipped),
+            accessLog,
+            error: null,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        emitMailRead(agentName, "list", "error");
+        return unavailableMailView(agentName, "error", message);
+    }
+}
+async function readMailMessageView(agentName, messageId) {
+    const resolved = await (0, reader_1.resolveMailroomReaderWithRefresh)(agentName);
+    if (!resolved.ok) {
+        const status = statusFromReaderFailure(resolved.reason);
+        emitMailRead(agentName, "message", status);
+        return unavailableMessageView(agentName, status, resolved.error);
+    }
+    try {
+        const stored = await resolved.store.getMessage(messageId);
+        if (!stored || stored.agentId !== agentName) {
+            emitMailRead(agentName, "message", "not-found");
+            return {
+                status: "not-found",
+                agentName,
+                mailboxAddress: resolved.config.mailboxAddress,
+                generatedAt: new Date().toISOString(),
+                message: null,
+                accessLog: accessEntries(await resolved.store.listAccessLog(agentName)),
+                error: `No visible mail message found for ${messageId}.`,
+            };
+        }
+        const decrypted = (0, file_store_1.decryptMessages)([stored], resolved.config.privateKeys)[0];
+        const access = await resolved.store.recordAccess({
+            agentId: agentName,
+            messageId,
+            tool: "mailbox_mail_message",
+            reason: "mailbox read-only message body",
+            ...accessProvenance(decrypted),
+        });
+        const body = decrypted.private.text.length > MAILBOX_MAIL_BODY_LIMIT
+            ? decrypted.private.text.slice(0, MAILBOX_MAIL_BODY_LIMIT)
+            : decrypted.private.text;
+        const detail = {
+            ...mailSummary(decrypted),
+            text: body,
+            htmlAvailable: typeof decrypted.private.html === "string" && decrypted.private.html.length > 0,
+            bodyTruncated: decrypted.private.text.length > MAILBOX_MAIL_BODY_LIMIT,
+            attachments: decrypted.private.attachments,
+            access: {
+                tool: access.tool,
+                reason: access.reason,
+                accessedAt: access.accessedAt,
+            },
+        };
+        emitMailRead(agentName, "message", "ready");
+        return {
+            status: "ready",
+            agentName,
+            mailboxAddress: resolved.config.mailboxAddress,
+            generatedAt: new Date().toISOString(),
+            message: detail,
+            accessLog: accessEntries(await resolved.store.listAccessLog(agentName)),
+            error: null,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        emitMailRead(agentName, "message", "error");
+        return unavailableMessageView(agentName, "error", message);
+    }
+}