@ouro.bot/cli 0.1.0-alpha.289 → 0.1.0-alpha.290

package/dist/senses/bluebubbles/attachment-download.js

@@ -0,0 +1,137 @@
+"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.isBlueBubblesImageAttachment = isBlueBubblesImageAttachment;
+exports.downloadBlueBubblesAttachment = downloadBlueBubblesAttachment;
+const path = __importStar(require("node:path"));
+const image_normalize_1 = require("../../heart/attachments/image-normalize");
+const runtime_1 = require("../../nerves/runtime");
+const MAX_NON_IMAGE_ATTACHMENT_BYTES = 8 * 1024 * 1024;
+const IMAGE_EXTENSIONS = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".heic", ".heif", ".tif", ".tiff", ".bmp"]);
+function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
+    const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const url = new URL(endpoint.replace(/^\//, ""), root);
+    url.searchParams.set("password", password);
+    return url.toString();
+}
+function inferContentType(attachment, responseType) {
+    const normalizedResponseType = responseType?.split(";")[0]?.trim().toLowerCase();
+    if (normalizedResponseType) {
+        return normalizedResponseType;
+    }
+    return attachment.mimeType?.trim().toLowerCase() || undefined;
+}
+function isBlueBubblesImageAttachment(attachment, contentType) {
+    if (contentType?.startsWith("image/"))
+        return true;
+    const normalizedMime = attachment.mimeType?.trim().toLowerCase();
+    if (normalizedMime?.startsWith("image/"))
+        return true;
+    const extension = path.extname(attachment.transferName ?? "").toLowerCase();
+    return IMAGE_EXTENSIONS.has(extension);
+}
+function maxDownloadBytesForAttachment(attachment, contentType) {
+    return isBlueBubblesImageAttachment(attachment, contentType)
+        ? image_normalize_1.MAX_ATTACHMENT_DOWNLOAD_BYTES_IMAGE
+        : MAX_NON_IMAGE_ATTACHMENT_BYTES;
+}
+async function downloadBlueBubblesAttachment(attachment, config, channelConfig, fetchImpl = fetch) {
+    const guid = attachment.guid?.trim();
+    if (!guid) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_attachment_download_error",
+            message: "bluebubbles attachment download failed",
+            meta: { reason: "missing_guid" },
+        });
+        throw new Error("attachment guid missing");
+    }
+    const advertisedLimit = maxDownloadBytesForAttachment(attachment);
+    if (typeof attachment.totalBytes === "number" && attachment.totalBytes > advertisedLimit) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_attachment_download_error",
+            message: "bluebubbles attachment download failed",
+            meta: { attachmentGuid: guid, reason: "advertised_limit_exceeded", advertisedLimit, totalBytes: attachment.totalBytes },
+        });
+        throw new Error(`attachment exceeds ${advertisedLimit} byte limit`);
+    }
+    const url = buildBlueBubblesApiUrl(config.serverUrl, `/api/v1/attachment/${encodeURIComponent(guid)}/download`, config.password);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_attachment_download_start",
+        message: "bluebubbles attachment download started",
+        meta: { attachmentGuid: guid, advertisedLimit },
+    });
+    const response = await fetchImpl(url, {
+        method: "GET",
+        signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+    });
+    if (!response.ok) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_attachment_download_error",
+            message: "bluebubbles attachment download failed",
+            meta: { attachmentGuid: guid, reason: "http_error", status: response.status },
+        });
+        throw new Error(`HTTP ${response.status}`);
+    }
+    const contentType = inferContentType(attachment, response.headers.get("content-type"));
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const actualLimit = maxDownloadBytesForAttachment(attachment, contentType);
+    if (buffer.length > actualLimit) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_attachment_download_error",
+            message: "bluebubbles attachment download failed",
+            meta: { attachmentGuid: guid, reason: "actual_limit_exceeded", actualLimit, byteCount: buffer.length, contentType: contentType ?? null },
+        });
+        throw new Error(`attachment exceeds ${actualLimit} byte limit`);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_attachment_download_end",
+        message: "bluebubbles attachment download completed",
+        meta: { attachmentGuid: guid, byteCount: buffer.length, contentType: contentType ?? null },
+    });
+    return {
+        buffer,
+        contentType,
+    };
+}

package/dist/senses/bluebubbles/media.js

@@ -33,8 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VLM_TEXT_WRAPPERS = void 0;
-exports.downloadBlueBubblesAttachment = downloadBlueBubblesAttachment;
+exports.downloadBlueBubblesAttachment = exports.VLM_TEXT_WRAPPERS = void 0;
 exports.hydrateBlueBubblesAttachments = hydrateBlueBubblesAttachments;
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs/promises"));
@@ -43,30 +42,23 @@ const path = __importStar(require("node:path"));
 const runtime_1 = require("../../nerves/runtime");
 const identity_1 = require("../../heart/identity");
 const model_capabilities_1 = require("../../heart/model-capabilities");
-const attachment_cache_1 = require("./attachment-cache");
+const image_normalize_1 = require("../../heart/attachments/image-normalize");
+const store_1 = require("../../heart/attachments/store");
+const types_1 = require("../../heart/attachments/types");
+const materialize_1 = require("../../heart/attachments/materialize");
+const attachment_download_1 = require("./attachment-download");
 // Pin the exact wrapper strings so tests and code read from one source.
 exports.VLM_TEXT_WRAPPERS = {
     description: (desc) => `[image description: ${desc}]`,
-    unsupported: (mimeType) => `[image attachment not shown: unsupported format ${mimeType}]`,
     failure: (reason) => `[image description failed: ${reason}]`,
 };
-// VLM supported formats for the /v1/coding_plan/vlm endpoint. The client in
-// minimax-vlm.ts enforces the same set — this helper lets the sense skip the
-// call entirely and emit a clearer `vision_format_unsupported` event instead
-// of letting the VLM client throw.
-const VLM_SUPPORTED_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/webp"]);
-function isSupportedVlmFormat(contentType) {
-    return VLM_SUPPORTED_MIME_TYPES.has(contentType.toLowerCase());
-}
 // D3 prompt template. Included here (not templated out) because the contract
 // is load-bearing — see planning doc section D3 and AX-4.
 function buildVlmPrompt(userText) {
     const body = userText ?? "";
     return `User message: "${body}"\n\nDescribe this image in detail, focusing on anything relevant to what the user said above.\nInclude any text visible in the image verbatim.`;
 }
-const MAX_ATTACHMENT_BYTES = 8 * 1024 * 1024;
 const AUDIO_EXTENSIONS = new Set([".mp3", ".wav", ".m4a", ".caf", ".ogg"]);
-const IMAGE_EXTENSIONS = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".heic", ".heif"]);
 const AUDIO_EXTENSION_BY_CONTENT_TYPE = {
     "audio/wav": ".wav",
     "audio/x-wav": ".wav",
@@ -100,28 +92,9 @@ function whisperCppPaths() {
     const modelPath = path.join(modelsDir, WHISPER_CPP_MODEL_NAME);
     return { toolsDir, modelsDir, modelPath };
 }
-function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
-    const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-    const url = new URL(endpoint.replace(/^\//, ""), root);
-    url.searchParams.set("password", password);
-    return url.toString();
-}
 function describeAttachment(attachment) {
     return attachment.transferName?.trim() || attachment.guid?.trim() || "attachment";
 }
-function inferContentType(attachment, responseType) {
-    const normalizedResponseType = responseType?.split(";")[0]?.trim().toLowerCase();
-    if (normalizedResponseType) {
-        return normalizedResponseType;
-    }
-    return attachment.mimeType?.trim().toLowerCase() || undefined;
-}
-function isImageAttachment(attachment, contentType) {
-    if (contentType?.startsWith("image/"))
-        return true;
-    const extension = path.extname(attachment.transferName ?? "").toLowerCase();
-    return IMAGE_EXTENSIONS.has(extension);
-}
 function isAudioAttachment(attachment, contentType) {
     if (contentType?.startsWith("audio/"))
         return true;
@@ -268,34 +241,8 @@ async function transcribeAudioWithWhisperCpp(params, modelFetchImpl = fetch) {
         await fs.rm(workDir, { recursive: true, force: true }).catch(() => undefined);
     }
 }
-async function downloadBlueBubblesAttachment(attachment, config, channelConfig, fetchImpl = fetch) {
-    return downloadAttachment(attachment, config, channelConfig, fetchImpl);
-}
-async function downloadAttachment(attachment, config, channelConfig, fetchImpl) {
-    const guid = attachment.guid?.trim();
-    if (!guid) {
-        throw new Error("attachment guid missing");
-    }
-    if (typeof attachment.totalBytes === "number" && attachment.totalBytes > MAX_ATTACHMENT_BYTES) {
-        throw new Error(`attachment exceeds ${MAX_ATTACHMENT_BYTES} byte limit`);
-    }
-    const url = buildBlueBubblesApiUrl(config.serverUrl, `/api/v1/attachment/${encodeURIComponent(guid)}/download`, config.password);
-    const response = await fetchImpl(url, {
-        method: "GET",
-        signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
-    });
-    if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-    }
-    const buffer = Buffer.from(await response.arrayBuffer());
-    if (buffer.length > MAX_ATTACHMENT_BYTES) {
-        throw new Error(`attachment exceeds ${MAX_ATTACHMENT_BYTES} byte limit`);
-    }
-    return {
-        buffer,
-        contentType: inferContentType(attachment, response.headers.get("content-type")),
-    };
-}
+var attachment_download_2 = require("./attachment-download");
+Object.defineProperty(exports, "downloadBlueBubblesAttachment", { enumerable: true, get: function () { return attachment_download_2.downloadBlueBubblesAttachment; } });
 async function hydrateBlueBubblesAttachments(attachments, config, channelConfig, deps = {}) {
     const fetchImpl = deps.fetchImpl ?? fetch;
     const modelFetchImpl = deps.modelFetchImpl ?? fetch;
@@ -303,19 +250,28 @@ async function hydrateBlueBubblesAttachments(attachments, config, channelConfig,
     const preferAudioInput = deps.preferAudioInput ?? false;
     const chatModel = deps.chatModel;
     const visionCapable = chatModel ? (0, model_capabilities_1.getModelCapabilities)(chatModel).vision === true : true;
+    const agentName = (0, identity_1.getAgentName)();
+    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
     const inputParts = [];
     const transcriptAdditions = [];
     const notices = [];
     for (const attachment of attachments) {
         const name = describeAttachment(attachment);
-        // Remember every attachment we see — the describe_image agent tool looks
-        // up guids against this cache later to re-fetch bytes on demand.
-        (0, attachment_cache_1.rememberBlueBubblesAttachment)(attachment);
+        const initialRecord = attachment.guid?.trim()
+            ? (0, store_1.rememberRecentAttachment)(agentName, (0, types_1.buildBlueBubblesAttachmentRecord)(attachment), agentRoot)
+            : null;
         try {
-            const downloaded = await downloadAttachment(attachment, config, channelConfig, fetchImpl);
+            const downloaded = await (0, attachment_download_1.downloadBlueBubblesAttachment)(attachment, config, channelConfig, fetchImpl);
             const base64 = downloaded.buffer.toString("base64");
             const byteCount = downloaded.buffer.length;
-            if (isImageAttachment(attachment, downloaded.contentType)) {
+            const persistedRecord = initialRecord && initialRecord.source === "bluebubbles"
+                ? await (0, materialize_1.persistBlueBubblesAttachmentSource)(agentName, initialRecord, {
+                    buffer: downloaded.buffer,
+                    mimeType: downloaded.contentType,
+                    byteCount,
+                }, agentRoot)
+                : null;
+            if ((0, attachment_download_1.isBlueBubblesImageAttachment)(attachment, downloaded.contentType)) {
                 const mimeType = downloaded.contentType ?? "application/octet-stream";
                 if (visionCapable) {
                     inputParts.push({
@@ -339,48 +295,27 @@ async function hydrateBlueBubblesAttachments(attachments, config, channelConfig,
                     });
                     continue;
                 }
-                // Non-vision chat model — try the VLM describe fallback.
-                if (!isSupportedVlmFormat(mimeType)) {
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "senses",
-                        event: "senses.bluebubbles_vision_format_unsupported",
-                        message: "bluebubbles vision format unsupported",
-                        meta: {
-                            mimeType,
-                            transferName: attachment.transferName,
-                            attachmentGuid: attachment.guid,
-                            chatModel,
-                        },
-                    });
-                    inputParts.push({
-                        type: "text",
-                        text: exports.VLM_TEXT_WRAPPERS.unsupported(mimeType),
-                    });
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "senses",
-                        event: "senses.bluebubbles_media_hydrate",
-                        message: "bluebubbles media hydrate",
-                        meta: {
-                            attachmentGuid: attachment.guid,
-                            mimeType,
-                            byteCount,
-                            hydrationPath: "skip-unsupported",
-                        },
-                    });
-                    continue;
-                }
-                const dataUrl = `data:${mimeType};base64,${base64}`;
                 try {
                     if (!deps.vlmDescribe) {
                         throw new Error("no VLM describer configured — wire a vlmDescribe dep or configure a vision-capable chat model");
                     }
+                    if (!persistedRecord?.sourceData.localPath) {
+                        throw new Error("image attachment could not be persisted for normalization");
+                    }
+                    const normalized = await (0, image_normalize_1.normalizeImageForVision)({
+                        attachment: persistedRecord,
+                        sourcePath: persistedRecord.sourceData.localPath,
+                        agentName,
+                        agentRoot,
+                    });
+                    const normalizedBuffer = await fs.readFile(normalized.path);
+                    const normalizedMime = normalized.mimeType ?? persistedRecord.mimeType ?? "image/jpeg";
+                    const dataUrl = `data:${normalizedMime};base64,${normalizedBuffer.toString("base64")}`;
                     const description = await deps.vlmDescribe({
                         prompt: buildVlmPrompt(deps.userText),
                         imageDataUrl: dataUrl,
                         attachmentGuid: attachment.guid,
-                        mimeType,
+                        mimeType: normalizedMime,
                         chatModel,
                     });
                     inputParts.push({
@@ -402,7 +337,7 @@ async function hydrateBlueBubblesAttachments(attachments, config, channelConfig,
                     message: "bluebubbles media hydrate",
                     meta: {
                         attachmentGuid: attachment.guid,
-                        mimeType,
+                        mimeType: persistedRecord?.mimeType ?? mimeType,
                         byteCount,
                         hydrationPath: "vlm-describe",
                     },

package/dist/senses/bluebubbles/model.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeBlueBubblesEvent = normalizeBlueBubblesEvent;
 const runtime_1 = require("../../nerves/runtime");
+const render_1 = require("../../heart/attachments/render");
+const types_1 = require("../../heart/attachments/types");
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -107,18 +109,14 @@ function extractAttachments(data) {
 function formatAttachmentText(attachments) {
     if (attachments.length === 0)
         return "";
+    const renderable = attachments
+        .filter((attachment) => typeof attachment.guid === "string" && attachment.guid.trim().length > 0)
+        .map((attachment) => (0, types_1.buildBlueBubblesAttachmentRecord)(attachment));
+    if (renderable.length > 0) {
+        return (0, render_1.renderAttachmentBlock)(renderable);
+    }
     const [first] = attachments;
-    const mime = first.mimeType ?? "";
-    const label = mime.startsWith("image/")
-        ? "image attachment"
-        : mime.startsWith("audio/")
-            ? "audio attachment"
-            : "attachment";
-    const name = first.transferName ? `: ${first.transferName}` : "";
-    const dimensions = typeof first.width === "number" && typeof first.height === "number" && first.width > 0 && first.height > 0
-        ? ` (${first.width}x${first.height})`
-        : "";
-    return `[${label}${name}${dimensions}]`;
+    return `[attachment: ${first.transferName?.trim() || "unknown"}]`;
 }
 function formatMessageText(data, attachments) {
     const text = readString(data, "text")?.trim() ?? "";

package/dist/senses/cli/image-paste.js

@@ -47,12 +47,19 @@ exports.resolveImageContent = resolveImageContent;
  * When a user drags an image file onto the terminal, macOS pastes the absolute
  * path (often with backslash-escaped spaces). This module detects image paths
  * in the input text, replaces them with `[Image #N]` references, reads the
- * files, and produces OpenAI-compatible `image_url` content blocks.
+ * files, registers them as shared attachments, and produces OpenAI-compatible
+ * `image_url` content blocks.
  */
+const node_crypto_1 = require("node:crypto");
 const promises_1 = require("fs/promises");
 const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../../heart/identity");
+const render_1 = require("../../heart/attachments/render");
+const store_1 = require("../../heart/attachments/store");
+const types_1 = require("../../heart/attachments/types");
+const materialize_1 = require("../../heart/attachments/materialize");
 /** Matches image file extensions (case-insensitive) */
 exports.IMAGE_EXTENSION_REGEX = /\.(png|jpe?g|gif|webp)$/i;
 /** Check whether a string (possibly backslash-escaped) ends with an image extension */
@@ -96,8 +103,10 @@ async function tryReadImage(absolutePath) {
         if (buffer.length > 0) {
             const ext = path.extname(absolutePath);
             return {
+                buffer: Buffer.from(buffer),
                 base64: Buffer.from(buffer).toString("base64"),
                 mediaType: extensionToMediaType(ext),
+                fromClipboard: false,
             };
         }
     }
@@ -142,8 +151,10 @@ async function getImageFromClipboard() {
         if (buffer.length === 0)
             return null;
         return {
+            buffer: Buffer.from(buffer),
             base64: Buffer.from(buffer).toString("base64"),
             mediaType: "image/png",
+            fromClipboard: true,
         };
     }
     catch {
@@ -179,6 +190,34 @@ function replacePathsWithRefs(input) {
 function processSubmitInput(text) {
     return replacePathsWithRefs(text);
 }
+function extensionForMediaType(mediaType) {
+    switch (mediaType) {
+        case "image/jpeg":
+            return ".jpg";
+        case "image/gif":
+            return ".gif";
+        case "image/webp":
+            return ".webp";
+        default:
+            return ".png";
+    }
+}
+async function pathExists(targetPath) {
+    try {
+        await (0, promises_1.access)(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function persistClipboardImage(agentRoot, originalPath, image) {
+    const hash = (0, node_crypto_1.createHash)("sha1").update(originalPath).digest("hex").slice(0, 16);
+    const targetPath = path.join(agentRoot, "state", "attachments", "imports", "cli", `${hash}${extensionForMediaType(image.mediaType)}`);
+    await (0, promises_1.mkdir)(path.dirname(targetPath), { recursive: true });
+    await (0, promises_1.writeFile)(targetPath, image.buffer);
+    return targetPath;
+}
 /**
  * Build OpenAI content parts from text + image map.
  * For each image in the map, reads the file and creates an `image_url` content part.
@@ -189,10 +228,45 @@ async function resolveImageContent(text, images) {
     if (images.size === 0) {
         return [{ type: "text", text }];
     }
+    const agentName = (0, identity_1.getAgentName)();
+    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
     const parts = [];
+    const rememberedAttachments = [];
     // Read all images in parallel
     const entries = Array.from(images.entries());
-    const results = await Promise.all(entries.map(async ([, absolutePath]) => tryReadImage(absolutePath)));
+    const results = await Promise.all(entries.map(async ([, absolutePath]) => {
+        const image = await tryReadImage(absolutePath);
+        if (!image)
+            return null;
+        const sourcePath = image.fromClipboard || !await pathExists(absolutePath)
+            ? await persistClipboardImage(agentRoot, absolutePath, image)
+            : absolutePath;
+        const attachment = (0, store_1.rememberRecentAttachment)(agentName, (0, types_1.buildCliLocalFileAttachmentRecord)({
+            path: sourcePath,
+            mimeType: image.mediaType,
+            byteCount: image.buffer.length,
+        }), agentRoot);
+        rememberedAttachments.push(attachment);
+        try {
+            const materialized = await (0, materialize_1.materializeAttachment)(agentName, attachment.id, {
+                agentRoot,
+                variant: "vision_safe",
+            });
+            const normalizedBuffer = await (0, promises_1.readFile)(materialized.path);
+            return {
+                attachment,
+                mediaType: materialized.mimeType ?? image.mediaType,
+                base64: Buffer.from(normalizedBuffer).toString("base64"),
+            };
+        }
+        catch {
+            return {
+                attachment,
+                mediaType: image.mediaType,
+                base64: image.base64,
+            };
+        }
+    }));
     for (const result of results) {
         if (result) {
             parts.push({
@@ -202,7 +276,9 @@ async function resolveImageContent(text, images) {
         }
     }
     // Always include the text part
-    parts.push({ type: "text", text });
+    const attachmentBlock = (0, render_1.renderAttachmentBlock)(rememberedAttachments);
+    const textWithAttachments = [text, attachmentBlock].filter(Boolean).join("\n");
+    parts.push({ type: "text", text: textWithAttachments || text });
     // If no images resolved, return just text
     if (parts.length === 1) {
         return [{ type: "text", text }];

package/dist/senses/inner-dialog.js

@@ -58,6 +58,7 @@ const bundle_manifest_1 = require("../mind/bundle-manifest");
 const pending_1 = require("../mind/pending");
 const obligations_1 = require("../arc/obligations");
 const attention_queue_1 = require("./attention-queue");
+const packets_1 = require("../arc/packets");
 const channel_1 = require("../mind/friends/channel");
 const trust_gate_1 = require("./trust-gate");
 const tokens_1 = require("../mind/friends/tokens");
@@ -714,6 +715,14 @@ async function runInnerDialogTurn(options) {
                             return null;
                         }
                     },
+                    packetResolver: (packetId) => {
+                        try {
+                            return (0, packets_1.readPonderPacket)((0, identity_1.getAgentRoot)(agentName), packetId);
+                        }
+                        catch {
+                            return null;
+                        }
+                    },
                 });
                 const summary = (0, attention_queue_1.buildAttentionQueueSummary)(attentionQueue);
                 return summary ? [summary] : [];

package/dist/senses/shared-turn.js

@@ -127,7 +127,7 @@ async function runSenseTurn(options) {
     };
     /* v8 ignore stop */
     // Run the pipeline
-    const result = await (0, pipeline_1.handleInboundTurn)({
+    await (0, pipeline_1.handleInboundTurn)({
         channel,
         sessionKey,
         capabilities,
@@ -159,14 +159,10 @@ async function runSenseTurn(options) {
         /* v8 ignore stop */
         accumulateFriendTokens: tokens_1.accumulateFriendTokens,
     });
-    // Detect ponder deferral
-    const ponderDeferred = result.turnOutcome === "pondered";
+    const ponderDeferred = false;
     // Build response
     let finalResponse;
-    if (ponderDeferred) {
-        finalResponse = "the agent is pondering this — check back shortly via check_response.";
-    }
-    else if (responseText.length === 0) {
+    if (responseText.length === 0) {
         // Agent settled but no text came through callbacks — check session transcript for the settle answer
         const postTurnSession = (0, context_1.loadSession)(sessPath);
         if (postTurnSession?.messages) {

package/package.json

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