@ouro.bot/cli 0.1.0-alpha.69 → 0.1.0-alpha.691

package/dist/heart/agent-entry.js

@@ -1,16 +1,173 @@
 "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 });
 // Unified agent runtime entrypoint.
 // Requires --agent before importing runtime modules that rely on identity.
-if (!process.argv.includes("--agent")) {
+const agentArgIndex = process.argv.indexOf("--agent");
+const parsedAgentName = agentArgIndex >= 0 ? process.argv[agentArgIndex + 1] : undefined;
+if (!parsedAgentName) {
     // eslint-disable-next-line no-console -- pre-boot guard
     console.error("Missing required --agent <name> argument.\nUsage: node dist/heart/agent-entry.js --agent ouroboros");
     process.exit(1);
 }
-const inner_dialog_worker_1 = require("../senses/inner-dialog-worker");
+const agentName = parsedAgentName;
 const cli_logging_1 = require("../nerves/cli-logging");
+const runtime_1 = require("../nerves/runtime");
 (0, cli_logging_1.configureCliRuntimeLogger)("self");
-(0, inner_dialog_worker_1.startInnerDialogWorker)().catch((error) => {
+const ipcStateKey = Symbol.for("ouro.agentEntry.ipcState");
+const ipcState = (globalThis[ipcStateKey] ??= {
+    bufferedRuntimeCredentialMessages: [],
+    bufferedMessages: [],
+    installed: false,
+    workerMessageHandler: null,
+});
+ipcState.bufferedRuntimeCredentialMessages = [];
+ipcState.bufferedMessages = [];
+ipcState.workerMessageHandler = null;
+function isRuntimeCredentialBootstrapMessage(message) {
+    return !!message
+        && typeof message === "object"
+        && !Array.isArray(message)
+        && message.type === "ouro.runtimeCredentialBootstrap";
+}
+function isRuntimeCredentialBootstrapForAgent(message, expectedAgentName) {
+    return isRuntimeCredentialBootstrapMessage(message)
+        && message.agentName === expectedAgentName;
+}
+function drainBufferedRuntimeCredentialBootstrap(applyRuntimeCredentialBootstrapMessage) {
+    let bootstrapped = false;
+    const remainingMessages = [];
+    for (const message of ipcState.bufferedRuntimeCredentialMessages.splice(0)) {
+        if (isRuntimeCredentialBootstrapForAgent(message, agentName)) {
+            bootstrapped = applyRuntimeCredentialBootstrapMessage(message) || bootstrapped;
+        }
+        else {
+            remainingMessages.push(message);
+        }
+    }
+    ipcState.bufferedRuntimeCredentialMessages.push(...remainingMessages);
+    return bootstrapped;
+}
+function isPrivateRuntimeWorkMessage(message) {
+    if (!message || typeof message !== "object" || Array.isArray(message))
+        return false;
+    const type = message.type;
+    return type === "heartbeat"
+        || type === "habit"
+        || type === "await"
+        || type === "shutdown"
+        || type === "poke"
+        || type === "chat"
+        || type === "message";
+}
+function forwardOrBufferRuntimeMessage(message) {
+    if (isRuntimeCredentialBootstrapMessage(message)) {
+        ipcState.bufferedRuntimeCredentialMessages.push(message);
+        return;
+    }
+    if (!isPrivateRuntimeWorkMessage(message))
+        return;
+    if (ipcState.workerMessageHandler) {
+        ipcState.workerMessageHandler(message);
+        return;
+    }
+    ipcState.bufferedMessages.push(message);
+}
+if (!ipcState.installed) {
+    process.on("message", forwardOrBufferRuntimeMessage);
+    /* v8 ignore next 3 -- child-process disconnect exits the live worker; default worker listener covers this behavior in process-listener tests @preserve */
+    process.on("disconnect", () => {
+        process.exit(0);
+    });
+    ipcState.installed = true;
+}
+(0, runtime_1.emitNervesEvent)({
+    component: "senses",
+    event: "senses.entry_boot",
+    message: "starting private-runtime process entrypoint",
+    meta: { entry: "private-runtime", agentName },
+});
+// Dynamic import: agent-entry is process-start wiring that starts a sense process.
+// Using dynamic import avoids a static heart/ -> senses/ dependency.
+Promise.resolve().then(() => __importStar(require("./runtime-credentials"))).then(async ({ readMachineRuntimeCredentialConfig, readRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, refreshRuntimeCredentialConfig, applyRuntimeCredentialBootstrapMessage, waitForRuntimeCredentialBootstrap, }) => {
+    const { readProviderCredentialPool, refreshProviderCredentialPool } = await Promise.resolve().then(() => __importStar(require("./provider-credentials")));
+    const bootstrappedBeforeWait = drainBufferedRuntimeCredentialBootstrap(applyRuntimeCredentialBootstrapMessage);
+    const bootstrappedDuringWait = bootstrappedBeforeWait ? true : await waitForRuntimeCredentialBootstrap(agentName);
+    if (bootstrappedDuringWait) {
+        ipcState.bufferedRuntimeCredentialMessages = ipcState.bufferedRuntimeCredentialMessages.filter((message) => !isRuntimeCredentialBootstrapForAgent(message, agentName));
+    }
+    else {
+        drainBufferedRuntimeCredentialBootstrap(applyRuntimeCredentialBootstrapMessage);
+    }
+    if (!readRuntimeCredentialConfig(agentName).ok) {
+        void refreshRuntimeCredentialConfig(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+    }
+    const providerPool = readProviderCredentialPool(agentName);
+    if (!providerPool.ok || Object.keys(providerPool.pool.providers).length === 0) {
+        await refreshProviderCredentialPool(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+    }
+    /* v8 ignore next 7 -- process-start best-effort machine credential refresh runs in a child entrypoint and is covered operationally by daemon startup tests @preserve */
+    if (!readMachineRuntimeCredentialConfig(agentName).ok) {
+        void Promise.resolve().then(() => __importStar(require("./machine-identity"))).then(({ loadOrCreateMachineIdentity }) => {
+            const machine = loadOrCreateMachineIdentity();
+            return refreshMachineRuntimeCredentialConfig(agentName, machine.machineId, { preserveCachedOnFailure: true });
+        })
+            .catch(() => undefined);
+    }
+    const { startPrivateRuntimeWorker } = await Promise.resolve().then(() => __importStar(require("../senses/private-runtime-worker")));
+    const bufferedMessages = ipcState.bufferedMessages.splice(0);
+    const worker = await startPrivateRuntimeWorker({
+        attachProcessListeners: false,
+        bufferedMessages,
+    });
+    ipcState.workerMessageHandler = (message) => {
+        void worker.handleMessage(message);
+    };
+    const messagesBufferedDuringStart = ipcState.bufferedMessages.splice(0);
+    for (const message of messagesBufferedDuringStart) {
+        ipcState.workerMessageHandler(message);
+    }
+})
+    .catch((error) => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "senses",
+        event: "senses.entry_error",
+        message: "private-runtime entrypoint failed",
+        meta: { entry: "private-runtime", agentName, error: error instanceof Error ? error.message : String(error) },
+    });
     // eslint-disable-next-line no-console -- fatal startup guard for worker process
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);

package/dist/heart/attachments/image-normalize.js

@@ -0,0 +1,194 @@
+"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.MAX_VLM_IMAGE_BYTES = exports.MAX_ATTACHMENT_DOWNLOAD_BYTES_IMAGE = void 0;
+exports.normalizeImageForVision = normalizeImageForVision;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+exports.MAX_ATTACHMENT_DOWNLOAD_BYTES_IMAGE = 32 * 1024 * 1024;
+exports.MAX_VLM_IMAGE_BYTES = 5 * 1024 * 1024;
+const SAFE_VLM_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/webp"]);
+const SIZE_STEPS = [3072, 2560, 2048, 1600, 1280, 1024, 768];
+const JPEG_QUALITIES = ["best", "90", "80", "70", "60"];
+function materializedOutputDir(agentRoot, attachmentId) {
+    return path.join(agentRoot, "state", "attachments", "materialized", attachmentId.replace(/[:/]/g, "_"));
+}
+function execFileText(file, args) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(file, args, (error, stdout = "", stderr = "") => {
+            if (error) {
+                reject(new Error(stderr.trim() || stdout.trim() || error.message));
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
+async function defaultProbeImage(input) {
+    const output = await execFileText("/usr/bin/sips", ["-g", "hasAlpha", input.sourcePath]);
+    const hasAlpha = /hasAlpha:\s+(yes|1|true)/i.test(output);
+    return { hasAlpha };
+}
+async function defaultRasterizeWithQuickLook(input) {
+    await fs.mkdir(input.outputDir, { recursive: true });
+    await execFileText("/usr/bin/qlmanage", ["-t", "-s", "4096", "-o", input.outputDir, input.sourcePath]);
+    const entries = await fs.readdir(input.outputDir);
+    const candidate = entries
+        .filter((entry) => entry.startsWith(path.basename(input.sourcePath, path.extname(input.sourcePath))))
+        .sort()[0];
+    if (!candidate) {
+        throw new Error("Quick Look did not produce a rasterized image");
+    }
+    return path.join(input.outputDir, candidate);
+}
+async function defaultEncodeVariant(input) {
+    await fs.mkdir(input.outputDir, { recursive: true });
+    const extension = input.targetFormat === "png" ? ".png" : ".jpg";
+    const basename = path.basename(input.sourcePath, path.extname(input.sourcePath));
+    const outputPath = path.join(input.outputDir, `${basename}-${input.maxEdge}-${input.targetFormat}${input.quality ? `-${input.quality}` : ""}${extension}`);
+    const args = [
+        "-s",
+        "format",
+        input.targetFormat,
+        ...(input.targetFormat === "jpeg" && input.quality ? ["-s", "formatOptions", input.quality] : []),
+        "-Z",
+        String(input.maxEdge),
+        input.sourcePath,
+        "--out",
+        outputPath,
+    ];
+    await execFileText("/usr/bin/sips", args);
+    const stats = await fs.stat(outputPath);
+    return {
+        path: outputPath,
+        mimeType: input.targetFormat === "png" ? "image/png" : "image/jpeg",
+        byteCount: stats.size,
+    };
+}
+async function normalizeImageForVision(params) {
+    const maxVlmBytes = params.maxVlmBytes ?? exports.MAX_VLM_IMAGE_BYTES;
+    const originalMimeType = params.attachment.mimeType?.trim().toLowerCase();
+    const originalByteCount = params.attachment.byteCount;
+    const outputDir = materializedOutputDir(params.agentRoot, params.attachment.id);
+    if (originalMimeType
+        && SAFE_VLM_MIME_TYPES.has(originalMimeType)
+        && typeof originalByteCount === "number"
+        && originalByteCount <= maxVlmBytes) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.attachment_normalization_passthrough",
+            message: "attachment image normalization updated",
+            meta: {
+                attachmentId: params.attachment.id,
+                mimeType: originalMimeType,
+                byteCount: originalByteCount,
+            },
+        });
+        return {
+            path: path.resolve(params.sourcePath),
+            mimeType: originalMimeType,
+            byteCount: originalByteCount,
+        };
+    }
+    const probeImage = params.probeImage ?? defaultProbeImage;
+    const rasterizeWithQuickLook = params.rasterizeWithQuickLook ?? defaultRasterizeWithQuickLook;
+    const encodeVariant = params.encodeVariant ?? defaultEncodeVariant;
+    let workingSourcePath = path.resolve(params.sourcePath);
+    let probe;
+    try {
+        probe = await probeImage({ sourcePath: workingSourcePath });
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.attachment_normalization_rasterize",
+            message: "attachment image normalization updated",
+            meta: {
+                attachmentId: params.attachment.id,
+                sourcePath: workingSourcePath,
+            },
+        });
+        workingSourcePath = await rasterizeWithQuickLook({
+            sourcePath: workingSourcePath,
+            outputDir,
+        });
+        probe = await probeImage({ sourcePath: workingSourcePath });
+    }
+    const targetFormats = probe.hasAlpha ? ["png", "jpeg"] : ["jpeg"];
+    for (const targetFormat of targetFormats) {
+        for (const maxEdge of SIZE_STEPS) {
+            const qualities = targetFormat === "jpeg" ? JPEG_QUALITIES : [undefined];
+            for (const quality of qualities) {
+                const variant = await encodeVariant({
+                    sourcePath: workingSourcePath,
+                    outputDir,
+                    targetFormat,
+                    maxEdge,
+                    ...(quality ? { quality } : {}),
+                });
+                if ((variant.byteCount ?? Number.POSITIVE_INFINITY) <= maxVlmBytes) {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "engine",
+                        event: "engine.attachment_normalization_succeeded",
+                        message: "attachment image normalization updated",
+                        meta: {
+                            attachmentId: params.attachment.id,
+                            sourceMimeType: originalMimeType ?? "unknown",
+                            outputMimeType: variant.mimeType ?? `image/${targetFormat}`,
+                            byteCount: variant.byteCount,
+                            maxEdge,
+                            quality: quality ?? null,
+                        },
+                    });
+                    return variant;
+                }
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.attachment_normalization_failed",
+        message: "attachment image normalization updated",
+        meta: {
+            attachmentId: params.attachment.id,
+            sourceMimeType: originalMimeType ?? "unknown",
+            sourceByteCount: originalByteCount ?? null,
+            maxVlmBytes,
+        },
+    });
+    throw new Error(`Attachment ${params.attachment.id} could not be normalized under the VLM byte budget`);
+}

package/dist/heart/attachments/materialize.js

@@ -0,0 +1,97 @@
+"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.materializeAttachment = materializeAttachment;
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+const image_normalize_1 = require("./image-normalize");
+const store_1 = require("./store");
+const sources_1 = require("./sources");
+async function materializeOriginalAttachment(agentName, attachment, agentRoot) {
+    const adapter = (0, sources_1.getAttachmentSourceAdapter)(attachment.source);
+    const materialized = await adapter.materializeOriginal({ agentName, attachment, agentRoot });
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.attachment_materialized",
+        message: "attachment materialization updated",
+        meta: {
+            attachmentId: attachment.id,
+            variant: "original",
+            source: attachment.source,
+        },
+    });
+    return materialized;
+}
+async function materializeAttachment(agentName, attachmentId, options = {}) {
+    const agentRoot = options.agentRoot ?? (0, identity_1.getAgentRoot)(agentName);
+    const variant = options.variant ?? "original";
+    const attachment = (0, store_1.getRecentAttachment)(agentName, attachmentId, agentRoot);
+    if (!attachment) {
+        throw new Error(`Attachment not found: ${attachmentId}`);
+    }
+    if (variant === "original") {
+        return await materializeOriginalAttachment(agentName, attachment, agentRoot);
+    }
+    if (attachment.kind !== "image") {
+        throw new Error(`Attachment ${attachmentId} is not an image and cannot produce a vision_safe variant`);
+    }
+    const original = await materializeOriginalAttachment(agentName, attachment, agentRoot);
+    const normalizeImage = options.normalizeImage ?? image_normalize_1.normalizeImageForVision;
+    const normalized = await normalizeImage({
+        attachment,
+        sourcePath: original.path,
+        agentName,
+        agentRoot,
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.attachment_materialized",
+        message: "attachment materialization updated",
+        meta: {
+            attachmentId: attachment.id,
+            variant: "vision_safe",
+            source: attachment.source,
+        },
+    });
+    return {
+        attachmentId: attachment.id,
+        variant: "vision_safe",
+        path: path.resolve(normalized.path),
+        displayName: attachment.displayName,
+        mimeType: normalized.mimeType ?? attachment.mimeType,
+        byteCount: normalized.byteCount,
+    };
+}

package/dist/heart/attachments/originals.js

@@ -0,0 +1,88 @@
+"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.ensureReadableFile = ensureReadableFile;
+exports.extensionForAttachment = extensionForAttachment;
+exports.originalStoragePath = originalStoragePath;
+exports.buildOriginalMaterializedAttachment = buildOriginalMaterializedAttachment;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+async function ensureReadableFile(filePath) {
+    await fs.access(filePath);
+}
+function extensionForAttachment(displayName, mimeType) {
+    const explicit = path.extname(displayName).trim();
+    if (explicit)
+        return explicit;
+    switch (mimeType?.trim().toLowerCase()) {
+        case "image/jpeg":
+            return ".jpg";
+        case "image/png":
+            return ".png";
+        case "image/webp":
+            return ".webp";
+        case "image/gif":
+            return ".gif";
+        case "image/tiff":
+            return ".tiff";
+        case "image/bmp":
+            return ".bmp";
+        case "image/heic":
+            return ".heic";
+        case "application/pdf":
+            return ".pdf";
+        case "audio/mp3":
+        case "audio/mpeg":
+            return ".mp3";
+        case "audio/mp4":
+            return ".m4a";
+        default:
+            return "";
+    }
+}
+function originalStoragePath(agentRoot, attachment, mimeType) {
+    const extension = extensionForAttachment(attachment.displayName, mimeType ?? attachment.mimeType);
+    return path.join(agentRoot, "state", "attachments", "materialized", attachment.source, attachment.sourceId, `original${extension}`);
+}
+function buildOriginalMaterializedAttachment(attachment, filePath, mimeType, byteCount) {
+    return {
+        attachmentId: attachment.id,
+        variant: "original",
+        path: filePath,
+        displayName: attachment.displayName,
+        mimeType: mimeType ?? attachment.mimeType,
+        byteCount: byteCount ?? attachment.byteCount,
+    };
+}

package/dist/heart/attachments/render.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderAttachmentBlock = renderAttachmentBlock;
+const runtime_1 = require("../../nerves/runtime");
+function formatBytes(byteCount) {
+    if (typeof byteCount !== "number" || !Number.isFinite(byteCount) || byteCount < 0) {
+        return "unknown size";
+    }
+    if (byteCount >= 1024 * 1024) {
+        return `${(byteCount / (1024 * 1024)).toFixed(1)} MB`;
+    }
+    if (byteCount >= 1024) {
+        return `${Math.round(byteCount / 1024)} KB`;
+    }
+    return `${byteCount} B`;
+}
+function renderAttachmentBlock(attachments) {
+    if (attachments.length === 0)
+        return "";
+    const body = attachments.map((attachment) => `- ${attachment.id} | ${attachment.kind} | ${attachment.displayName} | ${attachment.mimeType ?? "unknown mime"} | ${formatBytes(attachment.byteCount)}`);
+    const rendered = ["[attachments]", ...body].join("\n");
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.attachment_block_rendered",
+        message: "attachment transcript block rendered",
+        meta: { count: attachments.length },
+    });
+    return rendered;
+}