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

package/changelog.json

@@ -1,6 +1,22 @@
 {
   "_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.483",
+      "changes": [
+        "`ouro mail import-mbox --discover` can now find HEY exports downloaded through the browser MCP sandbox as well as `~/Downloads`, so delegated backfill no longer depends on a human hand-copying Playwright-normalized `.mbox` paths.",
+        "Inner-dialog truth surfaces now strip synthetic timestamp noise and understand live v2 session envelopes, which makes `ouro inner`, `ouro thoughts`, and shared-work status checks report the real recent state instead of stale or empty transcript tails.",
+        "Ouro Mailbox is now the human-facing name for the read-only mailbox surface, and stale dead coding lanes no longer masquerade as live return-ready work inside Mailbox obligation and needs-me views while the `ouro.bot` wrapper stays version-synced for the release."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.482",
+      "changes": [
+        "Tracked mail imports and hosted mail index repairs now queue completion and failure notices into the live MCP session when one exists, so `check_response` learns about background mail work immediately instead of silently showing no pending messages.",
+        "When no MCP session is live, background mail-operation notices now fall back cleanly to the freshest non-blocked outward session instead of depending on inner-dialog-only wakeups.",
+        "Hosted Blob duplicate checks now treat unreadable already-existing message blobs as degraded duplicates during import reruns, preventing large delegated HEY archive backfills from crashing on a transient duplicate-read timeout while keeping the `ouro.bot` wrapper version-synced for the release."
+      ]
+    },
     {
       "version": "0.1.0-alpha.481",
       "changes": [

package/dist/heart/active-work.js

@@ -231,6 +231,48 @@ function formatObligationContentNextAction(obligation) {
         return null;
     return `work on "${content}" and bring back a concrete artifact`;
 }
+function backgroundOperationPriority(operation) {
+    switch (operation.status) {
+        case "failed": return 0;
+        case "queued": return 1;
+        case "running": return 2;
+        case "succeeded": return 3;
+    }
+}
+function selectPrimaryBackgroundOperation(frame) {
+    const operations = frame.backgroundOperations ?? [];
+    if (operations.length === 0)
+        return null;
+    return [...operations].sort((left, right) => {
+        const priorityDiff = backgroundOperationPriority(left) - backgroundOperationPriority(right);
+        if (priorityDiff !== 0)
+            return priorityDiff;
+        return Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
+    })[0] ?? null;
+}
+function formatBackgroundOperationNextAction(operation) {
+    if (operation.kind === "mail.import-discovered") {
+        return "inspect the import-ready archive and start the matching mail import";
+    }
+    if (operation.kind === "mail.import-mbox") {
+        switch (operation.status) {
+            case "failed":
+                return "inspect the failed mail import, fix the issue, and retry it";
+            case "queued":
+                return "let the queued mail import start; failure or completion will wake me, so i only re-check if i need status or it looks stalled";
+            case "running":
+                return "let the background mail import run; failure or completion will wake me, so i only check again if i need status or it looks stalled";
+            case "succeeded":
+                return "review the completed mail import and continue from the updated mailbox state; i only rerun if a newer archive appears";
+        }
+    }
+    switch (operation.status) {
+        case "failed": return `repair the failed ${operation.title} operation and retry it`;
+        case "queued": return `let the queued ${operation.title} operation start, then re-check progress`;
+        case "running": return `monitor the ${operation.title} operation and react when it changes`;
+        case "succeeded": return `review the completed ${operation.title} operation and continue`;
+    }
+}
 function formatNextAction(frame, obligation) {
     const obligationHasConcreteArtifact = Boolean(obligation?.currentArtifact?.trim())
         || obligation?.currentSurface?.kind === "merge";
@@ -258,6 +300,10 @@ function formatNextAction(frame, obligation) {
     if (obligation) {
         return formatObligationContentNextAction(obligation) || "continue the active loop and bring the result back here";
     }
+    const backgroundOperation = selectPrimaryBackgroundOperation(frame);
+    if (backgroundOperation) {
+        return formatBackgroundOperationNextAction(backgroundOperation);
+    }
     if (frame.mustResolveBeforeHandoff) {
         return "finish what i started here before moving on";
     }

package/dist/heart/background-operations.js

@@ -128,6 +128,20 @@ function readRecord(filePath) {
         return null;
     }
 }
+function specText(spec, key) {
+    const value = spec?.[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+function visibleOperationKey(record) {
+    if (record.kind !== "mail.import-mbox")
+        return null;
+    const filePath = specText(record.spec, "filePath");
+    if (!filePath)
+        return null;
+    const ownerEmail = specText(record.spec, "ownerEmail").toLowerCase();
+    const source = specText(record.spec, "source").toLowerCase();
+    return `${record.agentName.toLowerCase()}|${record.kind}|${filePath}|${ownerEmail}|${source}`;
+}
 function writeRecord(locator, record) {
     fs.mkdirSync(operationsDir(locator.agentName, locator.agentRoot), { recursive: true });
     fs.writeFileSync(operationPath(locator), `${JSON.stringify(record, null, 2)}\n`, "utf-8");
@@ -160,12 +174,22 @@ function listBackgroundOperations(input) {
     catch {
         return [];
     }
-    return entries
+    const records = entries
         .filter((entry) => entry.endsWith(".json"))
         .map((entry) => readRecord(path.join(dir, entry)))
         .filter((entry) => entry !== null)
-        .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))
-        .slice(0, input.limit ?? 10);
+        .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+    const visibleKeys = new Set();
+    const visible = records.filter((record) => {
+        const key = visibleOperationKey(record);
+        if (!key)
+            return true;
+        if (visibleKeys.has(key))
+            return false;
+        visibleKeys.add(key);
+        return true;
+    });
+    return visible.slice(0, input.limit ?? 10);
 }
 function startBackgroundOperation(input) {
     return writeRecord(input, {

package/dist/heart/core.js

@@ -182,6 +182,13 @@ function getProviderDisplayLabel(facing = "human") {
     };
     return providerLabelBuilders[provider]();
 }
+function hasFreshPendingWork(options) {
+    const pendingMessages = options?.pendingMessages;
+    if (!Array.isArray(pendingMessages))
+        return false;
+    return pendingMessages.some((message) => typeof message?.content === "string"
+        && message.content.trim().length > 0);
+}
 // Sole-call tools must be the only tool call in a turn. When they appear
 // alongside other tools, the sole-call tool is rejected with this message.
 const SOLE_CALL_REJECTION = {
@@ -891,6 +898,14 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
                         continue;
                     }
+                    if (hasFreshPendingWork(options)) {
+                        callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), false);
+                        messages.push(msg);
+                        const gateMessage = "fresh work arrived for me this turn — inspect the pending messages above and take the next concrete action before you rest.";
+                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
+                        providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                        continue;
+                    }
                     callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), true);
                     messages.push(msg);
                     const ack = "(resting)";

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

@@ -44,6 +44,7 @@ exports.mergeStartupStability = mergeStartupStability;
 exports.ensureDaemonRunning = ensureDaemonRunning;
 exports.listGithubCopilotModels = listGithubCopilotModels;
 exports.checkManualCloneBundles = checkManualCloneBundles;
+exports.resolveMailImportFilePath = resolveMailImportFilePath;
 exports.runOuroCli = runOuroCli;
 const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
@@ -84,6 +85,9 @@ const mbox_import_1 = require("../../mailroom/mbox-import");
 const reader_1 = require("../../mailroom/reader");
 const pending_1 = require("../../mind/pending");
 const background_operations_1 = require("../background-operations");
+const mail_import_discovery_1 = require("../mail-import-discovery");
+const session_activity_1 = require("../session-activity");
+const target_resolution_1 = require("../target-resolution");
 const cli_parse_1 = require("./cli-parse");
 const cli_parse_2 = require("./cli-parse");
 const cli_help_1 = require("./cli-help");
@@ -3409,7 +3413,7 @@ function makeBackgroundOperationId(kind) {
     const prefix = kind === "mail.import-mbox" ? "op_mail_import" : "op_mail_backfill";
     return `${prefix}_${(0, crypto_1.randomUUID)().slice(0, 8)}`;
 }
-function notifyMailOperation(agentName, record, deps) {
+async function notifyMailOperation(agentName, record, deps) {
     const lines = [
         "[Background Operation]",
         `${record.title} ${record.status === "failed" ? "failed" : "finished"}.`,
@@ -3419,22 +3423,68 @@ function notifyMailOperation(agentName, record, deps) {
         `detail: ${record.detail}`,
         ...(record.error?.message ? [`error: ${record.error.message}`] : []),
         ...(record.remediation && record.remediation.length > 0 ? ["", "next steps:", ...record.remediation.map((step) => `- ${step}`)] : []),
+        ...(record.kind === "mail.import-mbox" && record.status === "succeeded"
+            ? ["", "do not rerun the same archive unless a newer export appears."]
+            : []),
         "",
         "Use query_active_work for the live background-work view before drilling into mail details.",
     ];
-    (0, pending_1.queuePendingMessage)((0, pending_1.getInnerDialogPendingDir)(agentName), {
+    const agentRoot = providerCliAgentRoot({ agent: agentName }, deps);
+    const content = lines.join("\n");
+    (0, pending_1.queuePendingMessage)(path.join(agentRoot, "state", "pending", "self", "inner", "dialog"), {
         from: "mailroom",
         friendId: "self",
         channel: "inner",
         key: "dialog",
-        content: lines.join("\n"),
+        content,
         timestamp: deps.now?.() ?? Date.now(),
         mode: "reflect",
     });
-    return deps.sendCommand(deps.socketPath, { kind: "inner.wake", agent: agentName })
+    await queueMailOperationTargetNotification(agentName, content, deps).catch(() => undefined);
+    await deps.sendCommand(deps.socketPath, { kind: "inner.wake", agent: agentName })
         .then(() => undefined)
         .catch(() => undefined);
 }
+async function queueMailOperationTargetNotification(agentName, content, deps) {
+    const agentRoot = providerCliAgentRoot({ agent: agentName }, deps);
+    const friendsDir = path.join(agentRoot, "friends");
+    const sessionsDir = path.join(agentRoot, "state", "sessions");
+    const mcpTarget = (0, session_activity_1.listSessionActivity)({
+        sessionsDir,
+        friendsDir,
+        agentName,
+    }).find((candidate) => candidate.channel === "mcp");
+    if (mcpTarget) {
+        (0, pending_1.queuePendingMessage)(path.join(agentRoot, "state", "pending", mcpTarget.friendId, mcpTarget.channel, mcpTarget.key), {
+            from: "mailroom",
+            friendId: mcpTarget.friendId,
+            channel: mcpTarget.channel,
+            key: mcpTarget.key,
+            content,
+            timestamp: deps.now?.() ?? Date.now(),
+            mode: "relay",
+        });
+        return;
+    }
+    const candidates = await (0, target_resolution_1.listTargetSessionCandidates)({
+        sessionsDir,
+        friendsDir,
+        agentName,
+        friendStore: new store_file_1.FileFriendStore(friendsDir),
+    });
+    const target = candidates.find((candidate) => candidate.delivery.mode !== "blocked");
+    if (!target)
+        return;
+    (0, pending_1.queuePendingMessage)(path.join(agentRoot, "state", "pending", target.friendId, target.channel, target.key), {
+        from: "mailroom",
+        friendId: target.friendId,
+        channel: target.channel,
+        key: target.key,
+        content,
+        timestamp: deps.now?.() ?? Date.now(),
+        mode: "relay",
+    });
+}
 function ensureTrackedMailOperation(input) {
     if (!input.operationId)
         return null;
@@ -3543,17 +3593,108 @@ async function launchBackgroundMailCommand(command, deps, args, title, queuedSum
         `operation: ${operationId}`,
         ...(spec ? Object.entries(spec).map(([key, value]) => `${key}: ${String(value)}`) : []),
         `${command.agent} will be woken on failure or completion.`,
-        "Use query_active_work to check live progress.",
+        "Use query_active_work only when a live status check is actually needed.",
     ].join("\n");
     deps.writeStdout(message);
     return message;
 }
+function buildMailImportOperationSpec(filePath, ownerEmail, source) {
+    const stats = fs.statSync(filePath);
+    return {
+        filePath,
+        ...(ownerEmail ? { ownerEmail } : {}),
+        ...(source ? { source } : {}),
+        fileSizeBytes: stats.size,
+        fileModifiedAt: new Date(stats.mtimeMs).toISOString(),
+    };
+}
+function matchingMailImportOperation(record, command, filePath) {
+    if (record.kind !== "mail.import-mbox")
+        return false;
+    if ((record.spec?.filePath ?? null) !== filePath)
+        return false;
+    const expectedOwnerEmail = command.ownerEmail?.trim() ?? "";
+    const expectedSource = command.source?.trim() ?? "";
+    const recordOwnerEmail = typeof record.spec?.ownerEmail === "string" ? record.spec.ownerEmail.trim() : "";
+    const recordSource = typeof record.spec?.source === "string" ? record.spec.source.trim() : "";
+    return recordOwnerEmail === expectedOwnerEmail && recordSource === expectedSource;
+}
+function latestComparableOperationTimestamp(record) {
+    const candidates = [record.finishedAt, record.updatedAt];
+    for (const candidate of candidates) {
+        if (typeof candidate !== "string")
+            continue;
+        const parsed = Date.parse(candidate);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function duplicateMailImportMessage(command, filePath, record) {
+    const lines = [
+        `Background mail import already ${record.status === "succeeded" ? "completed" : record.status} for ${command.agent}`,
+        `operation: ${record.id}`,
+        `filePath: ${filePath}`,
+        ...(command.ownerEmail ? [`ownerEmail: ${command.ownerEmail}`] : []),
+        ...(command.source ? [`source: ${command.source}`] : []),
+        `summary: ${record.summary}`,
+        ...(record.detail ? [`detail: ${record.detail}`] : []),
+    ];
+    if (record.status === "succeeded") {
+        lines.push("This archive has not changed since that import. Download a newer export before rerunning.");
+    }
+    else {
+        lines.push(`${command.agent} will be woken on failure or completion.`);
+    }
+    return lines.join("\n");
+}
+function findExistingMailImportOperation(command, deps, filePath) {
+    const agentRoot = providerCliAgentRoot({ agent: command.agent }, deps);
+    const currentFileMtimeMs = fs.statSync(filePath).mtimeMs;
+    const operations = (0, background_operations_1.listBackgroundOperations)({ agentName: command.agent, agentRoot, limit: 50 });
+    for (const record of operations) {
+        if (!matchingMailImportOperation(record, command, filePath))
+            continue;
+        if (record.status === "queued" || record.status === "running") {
+            return record;
+        }
+        if (record.status === "succeeded") {
+            const recordTimestamp = latestComparableOperationTimestamp(record);
+            if (recordTimestamp !== null && currentFileMtimeMs <= recordTimestamp) {
+                return record;
+            }
+        }
+    }
+    return null;
+}
+function resolveMailImportFilePath(command, deps) {
+    if (command.filePath) {
+        return path.resolve(command.filePath);
+    }
+    if (!command.discover) {
+        throw new Error("mail import requires either --file <path> or --discover");
+    }
+    return (0, mail_import_discovery_1.discoverMailImportFilePath)({
+        agentName: command.agent,
+        ownerEmail: command.ownerEmail,
+        source: command.source,
+        repoRoot: path.resolve(deps.getRepoCwd?.() ?? process.cwd()),
+        homeDir: deps.homeDir ?? os.homedir(),
+    });
+}
 async function executeMailImportMbox(command, deps) {
-    const filePath = path.resolve(command.filePath);
+    const filePath = resolveMailImportFilePath(command, deps);
     if (!command.foreground) {
         if (!fs.existsSync(filePath)) {
             throw new Error(`no such file: ${filePath}`);
         }
+        const duplicate = findExistingMailImportOperation(command, deps, filePath);
+        if (duplicate) {
+            const message = duplicateMailImportMessage(command, filePath, duplicate);
+            deps.writeStdout(message);
+            return message;
+        }
+        const spec = buildMailImportOperationSpec(filePath, command.ownerEmail, command.source);
         return launchBackgroundMailCommand(command, deps, [
             "mail",
             "import-mbox",
@@ -3563,13 +3704,10 @@ async function executeMailImportMbox(command, deps) {
             filePath,
             ...(command.ownerEmail ? ["--owner-email", command.ownerEmail] : []),
             ...(command.source ? ["--source", command.source] : []),
-        ], "mail import", "queued delegated mail import", {
-            filePath,
-            ...(command.ownerEmail ? { ownerEmail: command.ownerEmail } : {}),
-            ...(command.source ? { source: command.source } : {}),
-        });
+        ], "mail import", "queued delegated mail import", spec);
     }
     const progress = createHumanCommandProgress(deps, "mail import");
+    const spec = buildMailImportOperationSpec(filePath, command.ownerEmail, command.source);
     const trackedOperation = ensureTrackedMailOperation({
         agentName: command.agent,
         deps,
@@ -3577,11 +3715,7 @@ async function executeMailImportMbox(command, deps) {
         kind: "mail.import-mbox",
         title: "mail import",
         queuedSummary: "queued delegated mail import",
-        spec: {
-            filePath,
-            ...(command.ownerEmail ? { ownerEmail: command.ownerEmail } : {}),
-            ...(command.source ? { source: command.source } : {}),
-        },
+        spec,
     });
     try {
         trackedOperation?.running("reading Mailroom config", `file: ${filePath}`, {
@@ -3643,6 +3777,7 @@ async function executeMailImportMbox(command, deps) {
         progress.completePhase("reading Mailroom config", "imported");
         progress.end();
         const message = [
+            ...(command.discover ? [`Discovered MBOX: ${filePath}`] : []),
             `Imported MBOX for ${command.agent}`,
             `file: ${filePath}`,
             `grant: ${result.sourceGrant.grantId} (${result.sourceGrant.source}; ${result.sourceGrant.ownerEmail})`,
@@ -6538,14 +6673,13 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     /* v8 ignore start -- inner status handler: requires real agent state on disk @preserve */
     if (command.kind === "inner.status") {
         try {
-            const agentRoot = (0, identity_1.getAgentRoot)(command.agent);
+            const agentRoot = deps.agentBundleRoot ?? (0, identity_1.getAgentRoot)(command.agent);
             const { buildInnerStatusOutput } = await Promise.resolve().then(() => __importStar(require("./inner-status")));
-            const { sessionPath: getSessionPath } = await Promise.resolve().then(() => __importStar(require("../config")));
             const { parseCadenceToMs: parseCadenceMs, DEFAULT_CADENCE_MS } = await Promise.resolve().then(() => __importStar(require("./cadence")));
             const { parseFrontmatter } = await Promise.resolve().then(() => __importStar(require("../../repertoire/tasks/parser")));
             const { listActiveReturnObligations } = await Promise.resolve().then(() => __importStar(require("../../arc/obligations")));
             // Read runtime state
-            const innerSessionPath = getSessionPath("inner-dialog", "inner", "session");
+            const innerSessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
             const runtimeJsonPath = path.join(path.dirname(innerSessionPath), "runtime.json");
             let runtimeState = null;
             try {

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

@@ -79,9 +79,15 @@ exports.COMMAND_REGISTRY = {
         usage: "ouro doctor",
         example: "ouro doctor",
     },
+    mailbox: {
+        category: "Agents",
+        description: "Show the agent's current mailbox overview",
+        usage: "ouro mailbox [--json]",
+        example: "ouro mailbox --json",
+    },
     outlook: {
         category: "Agents",
-        description: "Show the agent's current outlook",
+        description: "Deprecated alias for `ouro mailbox`",
         usage: "ouro outlook [--json]",
         example: "ouro outlook --json",
     },
@@ -181,7 +187,7 @@ exports.COMMAND_REGISTRY = {
         category: "Auth",
         description: "Import delegated mail and repair hosted Mailroom mailbox indexes",
         usage: "ouro mail <import-mbox|backfill-indexes> [--agent <name>]",
-        example: "ouro mail import-mbox --file ~/Downloads/hey.mbox --owner-email ari@mendelow.me --source hey --agent slugger",
+        example: "ouro mail import-mbox --discover --owner-email ari@mendelow.me --source hey --agent slugger",
         subcommands: ["import-mbox", "backfill-indexes"],
     },
     use: {
@@ -323,8 +329,8 @@ const SUBCOMMAND_HELP = {
     },
     "mail import-mbox": {
         description: "Import a HEY or other MBOX export into an existing delegated Mailroom source grant",
-        usage: "ouro mail import-mbox --file <path> [--owner-email <email>] [--source <label>] [--agent <name>] [--foreground]",
-        example: "ouro mail import-mbox --file ~/Downloads/hey.mbox --owner-email ari@mendelow.me --source hey --agent slugger",
+        usage: "ouro mail import-mbox (--file <path>|--discover) [--owner-email <email>] [--source <label>] [--agent <name>] [--foreground]",
+        example: "ouro mail import-mbox --discover --owner-email ari@mendelow.me --source hey --agent slugger",
     },
     "mail backfill-indexes": {
         description: "Rebuild hosted blob mailbox indexes for faster recent-mail reads after large legacy imports or drift repair.",

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

@@ -79,7 +79,7 @@ function usage() {
         "  ouro check [--agent <name>] --lane outward|inner",
         "  ouro repair [--agent <name>]",
         "  ouro provider refresh [--agent <name>]",
-        "  ouro outlook [--json]",
+        "  ouro mailbox [--json]",
         "  ouro -v|--version",
         "  ouro config model [--agent <name>] <model-name>",
         "  ouro config models [--agent <name>]",
@@ -885,7 +885,7 @@ function parseConnectCommand(args) {
 }
 function parseMailCommand(args) {
     const [sub, ...subArgs] = args;
-    const usageText = "Usage: ouro mail import-mbox --file <path> [--owner-email <email>] [--source <label>] [--agent <name>] [--foreground]\n       ouro mail backfill-indexes [--agent <name>] [--foreground]";
+    const usageText = "Usage: ouro mail import-mbox (--file <path>|--discover) [--owner-email <email>] [--source <label>] [--agent <name>] [--foreground]\n       ouro mail backfill-indexes [--agent <name>] [--foreground]";
     if (sub === "backfill-indexes") {
         const { agent, rest } = extractAgentFlag(subArgs);
         let foreground = false;
@@ -914,6 +914,7 @@ function parseMailCommand(args) {
     }
     const { agent, rest } = extractAgentFlag(subArgs);
     let filePath;
+    let discover = false;
     let ownerEmail;
     let source;
     let foreground = false;
@@ -924,6 +925,10 @@ function parseMailCommand(args) {
             filePath = rest[++i];
             continue;
         }
+        if (token === "--discover") {
+            discover = true;
+            continue;
+        }
         if (token === "--owner-email" && rest[i + 1]) {
             ownerEmail = rest[++i];
             continue;
@@ -942,13 +947,14 @@ function parseMailCommand(args) {
         }
         throw new Error(usageText);
     }
-    if (!filePath) {
+    if ((filePath ? 1 : 0) + (discover ? 1 : 0) !== 1) {
         throw new Error(usageText);
     }
     return {
         kind: "mail.import-mbox",
         ...(agent ? { agent } : {}),
-        filePath,
+        ...(filePath ? { filePath } : {}),
+        ...(discover ? { discover: true } : {}),
         ...(ownerEmail ? { ownerEmail } : {}),
         ...(source ? { source } : {}),
         ...(foreground ? { foreground: true } : {}),
@@ -1452,7 +1458,7 @@ function parseOuroCommand(args) {
             return { kind: "daemon.logs.prune" };
         return { kind: "daemon.logs" };
     }
-    if (head === "outlook")
+    if (head === "mailbox" || head === "outlook")
         return { kind: "outlook", ...(args.includes("--json") ? { json: true } : {}) };
     if (head === "hatch")
         return parseHatchCommand(args.slice(1));

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

@@ -308,7 +308,7 @@ function formatDaemonStatusOutput(response, fallback) {
     // ── Key-value overview ──
     const kvLine = (label, value) => `  ${teal(label.padEnd(11))} ${value}`;
     lines.push(kvLine("Socket", ov.socketPath));
-    lines.push(kvLine("Outlook", ov.outlookUrl));
+    lines.push(kvLine("Mailbox", ov.outlookUrl));
     lines.push(kvLine("Health", `${statusDot(ov.health)} ${ov.health}`));
     lines.push(kvLine("Updated", ov.lastUpdated));
     lines.push("");

package/dist/heart/daemon/thoughts.js

@@ -48,6 +48,7 @@ exports.readInnerDialogRawData = readInnerDialogRawData;
 exports.followThoughts = followThoughts;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const session_events_1 = require("../session-events");
 const runtime_1 = require("../../nerves/runtime");
 function contentToText(content) {
     if (typeof content === "string")
@@ -364,21 +365,34 @@ function parseInnerDialogSession(sessionPath) {
     catch {
         return [];
     }
-    let data;
+    let parsedRaw;
     try {
-        data = JSON.parse(raw);
+        parsedRaw = JSON.parse(raw);
     }
     catch {
         return [];
     }
-    if (data.version !== 1 || !Array.isArray(data.messages))
+    const legacyRecord = parsedRaw && typeof parsedRaw === "object"
+        ? parsedRaw
+        : null;
+    const messages = legacyRecord?.version === 1 && Array.isArray(legacyRecord.messages)
+        ? legacyRecord.messages
+        : (() => {
+            const envelope = (0, session_events_1.parseSessionEnvelope)(parsedRaw, {
+                recordedAt: new Date().toISOString(),
+            });
+            if (!envelope)
+                return null;
+            return (0, session_events_1.projectProviderMessages)(envelope);
+        })();
+    if (!messages)
         return [];
+    const normalizedMessages = messages;
     const turns = [];
-    const messages = data.messages;
     // Walk messages, pairing user → (tool calls) → assistant sequences
     let i = 0;
-    while (i < messages.length) {
-        const msg = messages[i];
+    while (i < normalizedMessages.length) {
+        const msg = normalizedMessages[i];
         if (msg.role === "system") {
             i++;
             continue;
@@ -392,8 +406,8 @@ function parseInnerDialogSession(sessionPath) {
         // Collect all messages until the next user message (or end)
         const turnMessages = [];
         let j = i + 1;
-        while (j < messages.length && messages[j].role !== "user") {
-            turnMessages.push(messages[j]);
+        while (j < normalizedMessages.length && normalizedMessages[j].role !== "user") {
+            turnMessages.push(normalizedMessages[j]);
             j++;
         }
         // Find the last assistant text response in this turn.