@ouro.bot/cli 0.1.0-alpha.484 → 0.1.0-alpha.486

package/changelog.json

@@ -1,6 +1,23 @@
 {
   "_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.486",
+      "changes": [
+        "Mail convergence pass 1-5 hardens hosted-mail truth surfaces under live HEY ingest: import truth + audit resilience, accurate archive freshness and identity surfaces, sharper recovery and archive truth, delegated search resilience, and natural anchor-list retrieval; imported archive content is now searched on parsed message text rather than raw archive bytes so quoted-printable / HTML-heavy booking mail is reachable.",
+        "`mail_search` now ranks by booking-aware relevance instead of pure recency. Score signals weight query-term hits by field (subject +6 / from +4 / body +2), booking-intent tokens (`booking confirmation`, `your stay`, e-ticket, etc.), confirmation-number-shaped tokens, currency amounts, and known travel-sender domains; recency stays as a tiebreaker. Recall is unchanged — noise still appears in results, just below the decisive message. Each rendered result also surfaces a `matched on:` line listing fields, booking signals, status (confirmed / cancelled / changed / refunded / etc.), confirmation token, amount, dates, attachment count, and sender hint, so the agent can triage without paying for a body open.",
+        "BlueBubbles sense no longer sticks in `error` status when a single message is permanently unrecoverable. `upstreamStatus` now tracks upstream health and pending work only — per-cycle recovery failures stay informational in `detail` for transparency without contradicting `ouro doctor`'s healthy verdict, so a malformed payload that fails repairEvent on every retry can no longer brick the visible sense state until operator intervention.",
+        "Heart streaming caps oversized Responses-API `function_call_output` history items both when rebuilding provider input from session history and when appending fresh tool output mid-turn, preventing a giant tool result on resume from blowing the model context."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.485",
+      "changes": [
+        "Session JSON storage no longer accumulates duplicate event ids when two writers race for the same session — `parseSessionEnvelope` now dedupes on read (last-occurrence-wins) so existing corrupted sessions self-heal on the next save, `buildCanonicalSessionEnvelope` assigns the next sequence as `max(existing) + 1` instead of `events.length + 1` so pruning gaps cannot collide, and `deferPostTurnPersist` serializes per-`sessPath` through an in-process queue so concurrent BlueBubbles webhooks for the same chat (or CLI postTurn racing the inner-dialog turn for the same MCP session) cannot interleave their writes.",
+        "Auto-created BlueBubbles group friends are now marked with a `notes.autoCreatedGroup` flag at resolver time, and the trust gate's family-member bypass surfaces a one-time inner-pending notice the first time messages route through an unacknowledged stranger-trust group so the agent can label, rename, or dismiss the relationship before activity accumulates invisibly.",
+        "Inner-dialog worker now caps consecutive `instinct` follow-on turns at `MAX_CONSECUTIVE_INSTINCT_TURNS = 3` to break self-sustaining loops where a tool that writes to the inner-dialog pending dir during a turn would otherwise re-fire the worker indefinitely; externally-queued messages reset the counter so legitimate cascading follow-ups still run, and a new `senses.inner_dialog_worker_instinct_loop_capped` event surfaces when the cap fires."
+      ]
+    },
     {
       "version": "0.1.0-alpha.484",
       "changes": [

package/dist/heart/active-work.js

@@ -239,6 +239,10 @@ function backgroundOperationPriority(operation) {
         case "succeeded": return 3;
     }
 }
+function backgroundOperationSpecText(spec, key) {
+    const value = spec?.[key];
+    return typeof value === "string" ? value.trim() : "";
+}
 function selectPrimaryBackgroundOperation(frame) {
     const operations = frame.backgroundOperations ?? [];
     if (operations.length === 0)
@@ -257,13 +261,34 @@ function formatBackgroundOperationNextAction(operation) {
     if (operation.kind === "mail.import-mbox") {
         switch (operation.status) {
             case "failed":
+                switch (operation.failure?.class?.trim()) {
+                    case "transient-storage-read":
+                        return "retry-safe once the transient storage/network issue clears";
+                    case "mailroom-auth":
+                    case "mailroom-config":
+                        return "repair mail auth/config access, then retry";
+                    case "source-grant-missing":
+                    case "source-grant-ambiguous":
+                        return "repair the delegated owner/source lane, then retry";
+                    case "archive-discovery":
+                    case "archive-ambiguity":
+                    case "archive-missing":
+                    case "archive-access":
+                        return "materialize or point at the correct local archive, then retry";
+                }
+                if (operation.failure?.retryDisposition === "retry-safe") {
+                    return "retry the failed mail import once the transient issue clears or the dependency answers again";
+                }
+                if (operation.failure?.retryDisposition === "investigate-first") {
+                    return "inspect the failed mail import carefully, confirm the root cause, and then decide whether to retry";
+                }
                 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";
+                return "queued — no action unless it stalls or i need live status";
             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";
+                return "in flight — no action unless it stalls or i need live status";
             case "succeeded":
-                return "review the completed mail import and continue from the updated mailbox state; i only rerun if a newer archive appears";
+                return "caught up — no rerun needed unless a newer archive appears";
         }
     }
     switch (operation.status) {
@@ -273,6 +298,66 @@ function formatBackgroundOperationNextAction(operation) {
         case "succeeded": return `review the completed ${operation.title} operation and continue`;
     }
 }
+function formatMailImportRecoveryUniverse(operation) {
+    const failureClass = operation.failure?.class?.trim();
+    if (!failureClass)
+        return null;
+    switch (failureClass) {
+        case "transient-storage-read":
+            return "transient dependency/read issue — safe to retry once storage/network answers again";
+        case "mailroom-auth":
+        case "mailroom-config":
+            return "mail auth/config issue — repair mail access or runtime config before retrying";
+        case "source-grant-missing":
+        case "source-grant-ambiguous":
+            return "delegated lane/registry issue — inspect owner/source linking before retrying";
+        case "archive-discovery":
+        case "archive-ambiguity":
+        case "archive-missing":
+        case "archive-access":
+            return "local archive/file issue — materialize or point at the right archive before retrying";
+        default:
+            return "unclassified import issue — inspect the recorded error before retrying";
+    }
+}
+function formatBackgroundOperationMeta(operation) {
+    const lines = [`operation: ${operation.id}`];
+    const filePath = backgroundOperationSpecText(operation.spec, "filePath")
+        || backgroundOperationSpecText(operation.spec, "newestCandidatePath");
+    if (filePath)
+        lines.push(`file: ${filePath}`);
+    const originLabel = backgroundOperationSpecText(operation.spec, "fileOriginLabel")
+        || backgroundOperationSpecText(operation.spec, "newestCandidateOriginLabel");
+    if (originLabel)
+        lines.push(`origin: ${originLabel}`);
+    const ownerEmail = backgroundOperationSpecText(operation.spec, "ownerEmail");
+    const source = backgroundOperationSpecText(operation.spec, "source");
+    if (ownerEmail || source) {
+        lines.push(`owner/source: ${ownerEmail || "unknown"} / ${source || "unknown"}`);
+    }
+    if (operation.failure?.class?.trim())
+        lines.push(`failure class: ${operation.failure.class}`);
+    if (operation.failure?.retryDisposition?.trim())
+        lines.push(`retry: ${operation.failure.retryDisposition}`);
+    if (operation.failure?.hint?.trim())
+        lines.push(`recovery: ${operation.failure.hint}`);
+    const recoveryUniverse = operation.kind === "mail.import-mbox" ? formatMailImportRecoveryUniverse(operation) : null;
+    if (recoveryUniverse)
+        lines.push(`recovery universe: ${recoveryUniverse}`);
+    if (operation.startedAt?.trim())
+        lines.push(`started: ${operation.startedAt}`);
+    if (operation.finishedAt?.trim())
+        lines.push(`finished: ${operation.finishedAt}`);
+    else if (operation.updatedAt?.trim())
+        lines.push(`updated: ${operation.updatedAt}`);
+    const nextAction = formatBackgroundOperationNextAction(operation);
+    if (nextAction.trim().length > 0)
+        lines.push(`next: ${nextAction}`);
+    if (operation.remediation?.length) {
+        lines.push(...operation.remediation.map((step) => `remediation: ${step}`));
+    }
+    return lines;
+}
 function formatNextAction(frame, obligation) {
     const obligationHasConcreteArtifact = Boolean(obligation?.currentArtifact?.trim())
         || obligation?.currentSurface?.kind === "merge";
@@ -696,6 +781,7 @@ function formatActiveWorkFrame(frame, options) {
             if (operation.summary.trim().length > 0) {
                 line += `: ${operation.summary}`;
             }
+            line += `\n  ${formatBackgroundOperationMeta(operation).join("\n  ")}`;
             if (operation.detail?.trim()) {
                 line += `\n  ${operation.detail.trim()}`;
             }

package/dist/heart/background-operations.js

@@ -112,6 +112,20 @@ function normalizeRecord(record) {
     if (record.error && typeof record.error.message === "string" && record.error.message.trim().length > 0) {
         normalized.error = { message: record.error.message.trim() };
     }
+    if (record.failure && typeof record.failure === "object" && !Array.isArray(record.failure)) {
+        const failureClass = typeof record.failure.class === "string" ? record.failure.class.trim() : "";
+        const retryDisposition = record.failure.retryDisposition;
+        const hint = typeof record.failure.hint === "string" ? record.failure.hint.trim() : "";
+        if (failureClass) {
+            normalized.failure = {
+                class: failureClass,
+                ...(retryDisposition === "retry-safe" || retryDisposition === "fix-before-retry" || retryDisposition === "investigate-first"
+                    ? { retryDisposition }
+                    : {}),
+                ...(hint ? { hint } : {}),
+            };
+        }
+    }
     if (Array.isArray(record.remediation)) {
         const remediation = record.remediation.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
         if (remediation.length > 0)
@@ -143,15 +157,19 @@ function visibleOperationKey(record) {
     return `${record.agentName.toLowerCase()}|${record.kind}|${filePath}|${ownerEmail}|${source}`;
 }
 function writeRecord(locator, record) {
+    const normalized = normalizeRecord(record);
+    if (!normalized) {
+        throw new Error(`invalid background operation record: ${locator.id}`);
+    }
     fs.mkdirSync(operationsDir(locator.agentName, locator.agentRoot), { recursive: true });
-    fs.writeFileSync(operationPath(locator), `${JSON.stringify(record, null, 2)}\n`, "utf-8");
+    fs.writeFileSync(operationPath(locator), `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.background_operation_written",
         message: "background operation state written",
-        meta: { agentName: locator.agentName, id: locator.id, kind: record.kind, status: record.status },
+        meta: { agentName: locator.agentName, id: locator.id, kind: normalized.kind, status: normalized.status },
     });
-    return record;
+    return normalized;
 }
 function requireRecord(locator) {
     const record = readBackgroundOperation(locator);
@@ -226,6 +244,7 @@ function updateBackgroundOperation(input) {
         summary: input.summary ?? current.summary,
         ...(input.detail ? { detail: input.detail } : {}),
         ...(normalizeProgress(input.progress) ? { progress: normalizeProgress(input.progress) } : {}),
+        ...(input.spec ? { spec: input.spec } : {}),
         updatedAt: input.updatedAt ?? current.updatedAt,
     });
 }
@@ -238,6 +257,9 @@ function completeBackgroundOperation(input) {
         ...(input.detail ? { detail: input.detail } : {}),
         ...(normalizeProgress(input.progress) ? { progress: normalizeProgress(input.progress) } : {}),
         ...(input.result ? { result: input.result } : {}),
+        error: undefined,
+        remediation: undefined,
+        failure: undefined,
         finishedAt: input.finishedAt,
         updatedAt: input.updatedAt ?? input.finishedAt,
     });
@@ -251,6 +273,7 @@ function failBackgroundOperation(input) {
         ...(input.detail ? { detail: input.detail } : {}),
         ...(normalizeProgress(input.progress) ? { progress: normalizeProgress(input.progress) } : {}),
         error: { message: input.error },
+        ...(input.failure ? { failure: input.failure } : {}),
         ...(input.remediation && input.remediation.length > 0 ? { remediation: input.remediation } : {}),
         finishedAt: input.finishedAt,
         updatedAt: input.updatedAt ?? input.finishedAt,

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

@@ -3421,6 +3421,9 @@ async function notifyMailOperation(agentName, record, deps) {
         `status: ${record.status}`,
         `summary: ${record.summary}`,
         `detail: ${record.detail}`,
+        ...(record.failure?.class ? [`failure class: ${record.failure.class}`] : []),
+        ...(record.failure?.retryDisposition ? [`retry: ${record.failure.retryDisposition}`] : []),
+        ...(record.failure?.hint ? [`recovery: ${record.failure.hint}`] : []),
         ...(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"
@@ -3518,7 +3521,7 @@ function ensureTrackedMailOperation(input) {
                 ...(progress ? { progress } : {}),
             });
         },
-        update: (summary, detail, progress) => {
+        update: (summary, detail, progress, spec) => {
             (0, background_operations_1.updateBackgroundOperation)({
                 agentName: input.agentName,
                 agentRoot,
@@ -3527,6 +3530,7 @@ function ensureTrackedMailOperation(input) {
                 updatedAt: cliNowIso(input.deps),
                 ...(detail ? { detail } : {}),
                 ...(progress ? { progress } : {}),
+                ...(spec ? { spec } : {}),
             });
         },
         succeed: async (summary, detail, result) => {
@@ -3541,7 +3545,7 @@ function ensureTrackedMailOperation(input) {
             });
             await notifyMailOperation(input.agentName, { ...completed, detail }, input.deps);
         },
-        fail: async (error, summary, detail, remediation) => {
+        fail: async (error, summary, detail, remediation, failure) => {
             const failed = (0, background_operations_1.failBackgroundOperation)({
                 agentName: input.agentName,
                 agentRoot,
@@ -3550,6 +3554,7 @@ function ensureTrackedMailOperation(input) {
                 summary,
                 detail,
                 error: error instanceof Error ? error.message : String(error),
+                ...(failure ? { failure } : {}),
                 remediation,
             });
             await notifyMailOperation(input.agentName, { ...failed, detail }, input.deps);
@@ -3608,6 +3613,143 @@ function buildMailImportOperationSpec(filePath, ownerEmail, source) {
         fileModifiedAt: new Date(stats.mtimeMs).toISOString(),
     };
 }
+function classifyMailImportFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    if (normalized.includes("auth_required:mailroom") || normalized.includes("cannot read mailroom config")) {
+        return {
+            failure: {
+                class: "mailroom-auth",
+                retryDisposition: "fix-before-retry",
+                hint: "mailroom credentials or vault access are unavailable; unlock or repair mail auth first",
+            },
+            remediation: [
+                "unlock or repair the owning agent vault/runtime config, then rerun the import",
+                "use query_active_work to confirm the failed operation has settled before retrying",
+            ],
+        };
+    }
+    if (normalized.includes("missing mailroom config")
+        || normalized.includes("missing registrypath/storepath")
+        || normalized.includes("missing hosted registry coordinates")) {
+        return {
+            failure: {
+                class: "mailroom-config",
+                retryDisposition: "fix-before-retry",
+                hint: "mailroom runtime config is incomplete for this agent",
+            },
+            remediation: [
+                `rerun 'ouro connect mail --agent <agent>' or repair the stored mailroom runtime config`,
+                "retry the import only after the config repair is complete",
+            ],
+        };
+    }
+    if (normalized.includes("no enabled mailroom source grant found")) {
+        return {
+            failure: {
+                class: "source-grant-missing",
+                retryDisposition: "fix-before-retry",
+                hint: "the requested owner/source lane is not provisioned yet",
+            },
+            remediation: [
+                "create or repair the delegated source grant for the intended owner/source, then rerun the import",
+                "confirm the import is pointed at the intended owner/source before retrying",
+            ],
+        };
+    }
+    if (normalized.includes("multiple source grants found")) {
+        return {
+            failure: {
+                class: "source-grant-ambiguous",
+                retryDisposition: "fix-before-retry",
+                hint: "more than one source grant matches; the import needs a narrower owner/source target",
+            },
+            remediation: [
+                "rerun the import with explicit --owner-email and/or --source hints",
+                "confirm which delegated lane should receive this archive before retrying",
+            ],
+        };
+    }
+    if (normalized.includes("could not discover an mbox file")) {
+        return {
+            failure: {
+                class: "archive-discovery",
+                retryDisposition: "fix-before-retry",
+                hint: "no matching local archive was discovered in the known browser/download locations",
+            },
+            remediation: [
+                "check the recent browser/download artifact locations or pass --file with the exact archive path",
+                "retry only after the correct archive is visible locally",
+            ],
+        };
+    }
+    if (normalized.includes("multiple candidate mbox files found")) {
+        return {
+            failure: {
+                class: "archive-ambiguity",
+                retryDisposition: "fix-before-retry",
+                hint: "more than one plausible archive matches this import request",
+            },
+            remediation: [
+                "rerun with --file <path> or narrower owner/source hints so the archive choice is unambiguous",
+                "retry after confirming which archive is the intended one",
+            ],
+        };
+    }
+    if (normalized.includes("no such file:") || normalized.includes("enoent")) {
+        return {
+            failure: {
+                class: "archive-missing",
+                retryDisposition: "fix-before-retry",
+                hint: "the chosen archive path is not readable on disk anymore",
+            },
+            remediation: [
+                "re-check the local archive path or re-download the export before retrying",
+                "retry after the archive exists locally again",
+            ],
+        };
+    }
+    if (normalized.includes("permission denied") || normalized.includes("eacces") || normalized.includes("eperm")) {
+        return {
+            failure: {
+                class: "archive-access",
+                retryDisposition: "fix-before-retry",
+                hint: "the archive or backing store could not be read with current filesystem permissions",
+            },
+            remediation: [
+                "repair filesystem access to the archive or backing store, then rerun the import",
+                "retry after confirming the path is readable by Ouro",
+            ],
+        };
+    }
+    if (normalized.includes("timed out")
+        || normalized.includes("socket closed early")
+        || normalized.includes("econnreset")
+        || normalized.includes("eai_again")) {
+        return {
+            failure: {
+                class: "transient-storage-read",
+                retryDisposition: "retry-safe",
+                hint: "likely transient hosted read failure",
+            },
+            remediation: [
+                "retry the import from the same archive after the transient storage/network issue clears",
+                "use query_active_work to confirm the failed operation has settled before retrying",
+            ],
+        };
+    }
+    return {
+        failure: {
+            class: "unknown-mail-import-failure",
+            retryDisposition: "investigate-first",
+            hint: "the import failed for a reason that does not match a known recovery class yet",
+        },
+        remediation: [
+            "inspect the recorded error and surrounding Mailroom/runtime state before retrying",
+            "retry only after the likely cause is understood or ruled out",
+        ],
+    };
+}
 function matchingMailImportOperation(record, command, filePath) {
     if (record.kind !== "mail.import-mbox")
         return false;
@@ -3683,8 +3825,8 @@ function resolveMailImportFilePath(command, deps) {
     });
 }
 async function executeMailImportMbox(command, deps) {
-    const filePath = resolveMailImportFilePath(command, deps);
     if (!command.foreground) {
+        const filePath = resolveMailImportFilePath(command, deps);
         if (!fs.existsSync(filePath)) {
             throw new Error(`no such file: ${filePath}`);
         }
@@ -3707,7 +3849,7 @@ async function executeMailImportMbox(command, deps) {
         ], "mail import", "queued delegated mail import", spec);
     }
     const progress = createHumanCommandProgress(deps, "mail import");
-    const spec = buildMailImportOperationSpec(filePath, command.ownerEmail, command.source);
+    let filePath = command.filePath ? path.resolve(command.filePath) : null;
     const trackedOperation = ensureTrackedMailOperation({
         agentName: command.agent,
         deps,
@@ -3715,13 +3857,28 @@ async function executeMailImportMbox(command, deps) {
         kind: "mail.import-mbox",
         title: "mail import",
         queuedSummary: "queued delegated mail import",
-        spec,
+        spec: {
+            ...(filePath ? { filePath } : {}),
+            ...(command.ownerEmail ? { ownerEmail: command.ownerEmail } : {}),
+            ...(command.source ? { source: command.source } : {}),
+            ...(command.discover ? { discovery: true } : {}),
+        },
     });
     try {
+        trackedOperation?.running("resolving mail archive", filePath ? `file: ${filePath}` : "mode: discover", {
+            current: 0,
+            unit: "messages",
+        });
+        filePath = resolveMailImportFilePath(command, deps);
+        const spec = buildMailImportOperationSpec(filePath, command.ownerEmail, command.source);
         trackedOperation?.running("reading Mailroom config", `file: ${filePath}`, {
             current: 0,
             unit: "messages",
         });
+        trackedOperation?.update("reading Mailroom config", `file: ${filePath}`, {
+            current: 0,
+            unit: "messages",
+        }, spec);
         progress.startPhase("reading Mailroom config");
         const runtime = await (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(command.agent, { preserveCachedOnFailure: true });
         if (!runtime.ok) {
@@ -3799,10 +3956,15 @@ async function executeMailImportMbox(command, deps) {
     }
     catch (error) {
         progress.end();
-        await trackedOperation?.fail(error, "delegated mail import failed", `file: ${filePath}`, [
-            "fix the reported Mailroom or MBOX problem, then rerun the import",
-            "use query_active_work to confirm whether the operation has cleared",
-        ]);
+        const classifiedFailure = classifyMailImportFailure(error);
+        const failureDetail = filePath
+            ? `file: ${filePath}`
+            : [
+                "mode: discover",
+                ...(command.ownerEmail ? [`owner: ${command.ownerEmail}`] : []),
+                ...(command.source ? [`source: ${command.source}`] : []),
+            ].join("; ");
+        await trackedOperation?.fail(error, "delegated mail import failed", failureDetail, classifiedFailure.remediation, classifiedFailure.failure);
         throw error;
     }
 }

package/dist/heart/mail-import-discovery.js

@@ -111,6 +111,26 @@ function listChildDirs(dir) {
         return [];
     }
 }
+function classifyDiscoveredMboxOrigin(dir) {
+    const normalizedDir = path.resolve(dir);
+    const parts = normalizedDir.split(path.sep).filter(Boolean);
+    if (parts.includes(".playwright-mcp")) {
+        return {
+            originKind: "playwright-sandbox",
+            originLabel: "browser sandbox (.playwright-mcp)",
+        };
+    }
+    if (path.basename(normalizedDir) === "Downloads") {
+        return {
+            originKind: "downloads",
+            originLabel: "Downloads",
+        };
+    }
+    return {
+        originKind: "filesystem",
+        originLabel: "filesystem",
+    };
+}
 function findWorktreePools(rootDir, maxDepth) {
     const seen = new Set();
     const found = [];
@@ -176,12 +196,19 @@ function listDiscoveredMboxCandidates(dir) {
     if (!fs.existsSync(dir))
         return [];
     try {
+        const origin = classifyDiscoveredMboxOrigin(dir);
         return fs.readdirSync(dir, { withFileTypes: true })
             .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".mbox"))
             .map((entry) => {
             const candidatePath = path.join(dir, entry.name);
             const stat = fs.statSync(candidatePath);
-            return { path: candidatePath, name: entry.name, mtimeMs: stat.mtimeMs };
+            return {
+                path: candidatePath,
+                name: entry.name,
+                mtimeMs: stat.mtimeMs,
+                originKind: origin.originKind,
+                originLabel: origin.originLabel,
+            };
         });
     }
     catch {
@@ -244,7 +271,7 @@ function summarizeAmbientImportCandidates(candidates, candidateLimit) {
         : `${visibleCandidates.length} recent MBOX archives ready for import`;
     const detailLines = [
         "recent candidates:",
-        ...visibleCandidates.map((candidate) => `- ${candidate.path}`),
+        ...visibleCandidates.map((candidate) => `- [${candidate.originLabel}] ${candidate.path}`),
         ...(hiddenCount > 0 ? [`- ...and ${hiddenCount} more recent archive${hiddenCount === 1 ? "" : "s"}`] : []),
         "next: if one matches an outstanding mail backfill, run `ouro mail import-mbox --discover` with owner/source hints so Ouro can select the right archive or report ambiguity.",
     ];
@@ -254,8 +281,16 @@ function summarizeAmbientImportCandidates(candidates, candidateLimit) {
         spec: {
             fingerprint: recentImportFingerprint(candidates),
             candidatePaths: visibleCandidates.map((candidate) => candidate.path),
+            candidateDescriptors: visibleCandidates.map((candidate) => ({
+                path: candidate.path,
+                originKind: candidate.originKind,
+                originLabel: candidate.originLabel,
+                modifiedAt: new Date(candidate.mtimeMs).toISOString(),
+            })),
             newestCandidatePath: visibleCandidates[0]?.path ?? null,
             newestCandidateMtime: visibleCandidates[0] ? new Date(visibleCandidates[0].mtimeMs).toISOString() : null,
+            newestCandidateOriginKind: visibleCandidates[0]?.originKind ?? null,
+            newestCandidateOriginLabel: visibleCandidates[0]?.originLabel ?? null,
         },
     };
 }

package/dist/heart/providers/azure.js

@@ -120,7 +120,7 @@ function createAzureProviderRuntime(model, azureConfig = (0, config_1.getAzureCo
         appendToolOutput(callId, output) {
             if (!nativeInput)
                 return;
-            nativeInput.push({ type: "function_call_output", call_id: callId, output });
+            nativeInput.push({ type: "function_call_output", call_id: callId, output: (0, streaming_1.truncateResponsesFunctionCallOutput)(output) });
         },
         async streamTurn(request) {
             if (!nativeInput)

package/dist/heart/providers/github-copilot.js

@@ -102,7 +102,7 @@ function createGithubCopilotProviderRuntime(model, config = (0, config_1.getGith
         appendToolOutput(callId, output) {
             if (!nativeInput)
                 return;
-            nativeInput.push({ type: "function_call_output", call_id: callId, output });
+            nativeInput.push({ type: "function_call_output", call_id: callId, output: (0, streaming_1.truncateResponsesFunctionCallOutput)(output) });
         },
         async streamTurn(request) {
             if (!nativeInput)

package/dist/heart/providers/openai-codex.js

@@ -154,7 +154,7 @@ function createOpenAICodexProviderRuntime(model, codexConfig = (0, config_1.getO
         appendToolOutput(callId, output) {
             if (!nativeInput)
                 return;
-            nativeInput.push({ type: "function_call_output", call_id: callId, output });
+            nativeInput.push({ type: "function_call_output", call_id: callId, output: (0, streaming_1.truncateResponsesFunctionCallOutput)(output) });
         },
         async streamTurn(request) {
             if (!nativeInput)

package/dist/heart/session-events.js

@@ -254,6 +254,35 @@ function messageFingerprint(message) {
 function makeEventId(sequence) {
     return `evt-${String(sequence).padStart(6, "0")}`;
 }
+/**
+ * Collapse duplicate event ids to a single entry, last-occurrence-wins.
+ *
+ * Concurrent writers in older versions of postTurnPersist could each load the
+ * envelope, compute `events.length + 1` for the next sequence, and both write
+ * an event with the same id. The duplicates would persist in the saved JSON
+ * and confuse downstream replay (the same outbound message could appear to
+ * have been sent twice from the agent's perspective without the agent knowing
+ * it sent it). We dedupe defensively on every load so corrupted sessions
+ * self-heal on the next save and so any future race produces a consistent
+ * view.
+ */
+function dedupeEventsByIdLastWins(events) {
+    // Index id → last position so we can preserve original order while
+    // collapsing duplicates to their final occurrence.
+    const lastIndexById = new Map();
+    for (let i = 0; i < events.length; i++) {
+        lastIndexById.set(events[i].id, i);
+    }
+    return events.filter((event, index) => lastIndexById.get(event.id) === index);
+}
+/**
+ * The next sequence to assign for a freshly-built event. Uses max(existing
+ * sequences) + 1 rather than `events.length + 1` so that gaps from earlier
+ * pruning, archive replay, or self-heal dedup never produce a colliding id.
+ */
+function nextEventSequence(existing) {
+    return existing.reduce((max, event) => Math.max(max, event.sequence), 0) + 1;
+}
 function validateSessionMessages(messages) {
     const violations = [];
     let prevNonToolRole = null;
@@ -665,7 +694,7 @@ function parseSessionEnvelope(raw, options = {}) {
     if (record.version !== 2 || !Array.isArray(record.events) || !record.projection || typeof record.projection !== "object") {
         return null;
     }
-    const events = record.events
+    const rawEvents = record.events
         .filter((event) => event != null && typeof event === "object")
         .map((event, index) => {
         const role = normalizeRole(event.role);
@@ -705,6 +734,12 @@ function parseSessionEnvelope(raw, options = {}) {
             },
         };
     });
+    // Self-heal duplicate event ids that may have been written by concurrent
+    // writers in older harness versions. Last-occurrence-wins by id (later
+    // entries in the persisted file are the more recent state for that id).
+    // We preserve the original document order otherwise, so projection.eventIds
+    // still resolves predictably.
+    const events = dedupeEventsByIdLastWins(rawEvents);
     const projection = record.projection;
     return {
         version: 2,
@@ -821,8 +856,10 @@ function buildCanonicalSessionEnvelope(options) {
         else {
             if (!isSystem)
                 nonSystemSeen++;
-            // Create a new event
-            const event = buildEventFromMessage(currentMessages[i], events.length + 1, options.recordedAt, "live", null, null, currentIngressTimes[i]);
+            // Create a new event. Use nextEventSequence(events) instead of
+            // `events.length + 1` so that any gap (from pruning, archive replay,
+            // or self-heal dedup) cannot collide with an existing id.
+            const event = buildEventFromMessage(currentMessages[i], nextEventSequence(events), options.recordedAt, "live", null, null, currentIngressTimes[i]);
             events.push(event);
             currentEventIds.push(event.id);
         }