@ouro.bot/cli 0.1.0-alpha.480 → 0.1.0-alpha.482

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.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": [
+        "Hosted Blob message downloads now retry once on transient timeout or socket-close failures, so rerunning a delegated HEY archive import does not die on the first flaky duplicate-check read.",
+        "Azure Blob mail-store coverage now locks the real duplicate-dedupe retry path that failed in production, keeping historical import reruns resilient while preserving bounded timeout behavior for genuinely stalled blobs.",
+        "`@ouro.bot/cli` and the `ouro.bot` wrapper stay version-synced for the hosted mail import retry hardening release."
+      ]
+    },
     {
       "version": "0.1.0-alpha.480",
       "changes": [

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

@@ -84,6 +84,8 @@ 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 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 +3411,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"}.`,
@@ -3422,19 +3424,62 @@ function notifyMailOperation(agentName, record, deps) {
         "",
         "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;

package/dist/mailroom/blob-store.js

@@ -9,6 +9,7 @@ const MESSAGE_INDEX_SORT_MAX_MS = 9_999_999_999_999;
 const MESSAGE_INDEX_SORT_WIDTH = 13;
 const MESSAGE_INDEX_NO_SOURCE = "~";
 const DEFAULT_BLOB_OPERATION_TIMEOUT_MS = 20_000;
+const DEFAULT_BLOB_DOWNLOAD_ATTEMPTS = 2;
 const DEFAULT_MESSAGE_FETCH_CONCURRENCY = 20;
 const DEFAULT_MESSAGE_INDEX_BACKFILL_CONCURRENCY = 8;
 const MESSAGE_LIST_SCAN_CONCURRENCY = 32;
@@ -64,18 +65,32 @@ function normalizeBlobOperationError(action, blob, timeoutMs, error) {
     }
     return new Error(`${action} ${blobClientName(blob)} failed: ${message}`);
 }
+function isRetryableBlobDownloadError(error) {
+    const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+    return message.includes("timed out") ||
+        message.includes("abort") ||
+        message.includes("econnreset") ||
+        message.includes("etimedout") ||
+        message.includes("socket closed");
+}
 async function downloadJson(blob, timeoutMs) {
     if (!await blob.exists())
         return null;
-    try {
-        const buffer = await withBlobOperationTimeout(timeoutMs, (abortSignal) => {
-            return blob.downloadToBuffer(undefined, undefined, { abortSignal });
-        });
-        return JSON.parse(buffer.toString("utf-8"));
-    }
-    catch (error) {
-        throw normalizeBlobOperationError("download", blob, timeoutMs, error);
+    let lastError = null;
+    for (let attempt = 1; attempt <= DEFAULT_BLOB_DOWNLOAD_ATTEMPTS; attempt += 1) {
+        try {
+            const buffer = await withBlobOperationTimeout(timeoutMs, (abortSignal) => {
+                return blob.downloadToBuffer(undefined, undefined, { abortSignal });
+            });
+            return JSON.parse(buffer.toString("utf-8"));
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= DEFAULT_BLOB_DOWNLOAD_ATTEMPTS || !isRetryableBlobDownloadError(error))
+                break;
+        }
     }
+    throw normalizeBlobOperationError("download", blob, timeoutMs, lastError);
 }
 async function uploadJson(blob, value, timeoutMs) {
     try {
@@ -321,7 +336,28 @@ class AzureBlobMailroomStore {
     async putRawMessage(input) {
         await this.ensureContainer();
         const { message, rawPayload, candidate } = await (0, core_1.buildStoredMailMessage)(input);
-        const existing = await downloadJson(this.messageBlob(message.id), this.blobOperationTimeoutMs);
+        const messageBlob = this.messageBlob(message.id);
+        let existing = null;
+        try {
+            existing = await downloadJson(messageBlob, this.blobOperationTimeoutMs);
+        }
+        catch (error) {
+            if (isRetryableBlobDownloadError(error) && await messageBlob.exists().catch(() => false)) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.mail_blob_store_dedupe_degraded",
+                    message: "azure blob mailroom store treated an unreadable existing message as a duplicate",
+                    meta: {
+                        id: message.id,
+                        agentId: message.agentId,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
+                return { created: false, message };
+            }
+            throw error;
+        }
         if (existing) {
             await this.putMessageIndex(existing);
             (0, runtime_1.emitNervesEvent)({

package/package.json

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