@qearlyao/familiar 0.2.2 → 0.2.4

package/dist/discord.js

@@ -1,19 +1,21 @@
 import { randomUUID } from "node:crypto";
 import { once } from "node:events";
 import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
 import { ApplicationCommandOptionType, ApplicationCommandType, ApplicationIntegrationType, ChannelType, Client, Events, GatewayIntentBits, InteractionContextType, MessageFlags, Partials, } from "discord.js";
 import { createAgentEventRecorder, storedAgentEventFromAgentEvent, thinkingDurationMs, updateAgentEventSummary, } from "./agent-events.js";
 import { chatChannelKey, createChatLog } from "./chat-log.js";
 import { materializeInboundAttachments, promptImagesFromAttachments } from "./inbound-attachments.js";
 import { ConversationRuntime } from "./runtime.js";
-import { appendSchedulerLog, buildCronInjectionText, buildHeartbeatInjectionText, dueCronSlot, isHeartbeatDue, loadSchedulerState, saveSchedulerState, } from "./scheduler.js";
+import { appendSchedulerLog, buildCronInjectionText, buildHeartbeatInjectionText, dueCronSlot, formatIdleDuration, isHeartbeatDue, loadSchedulerState, saveSchedulerState, } from "./scheduler.js";
+import { parseAgentReply as parseSilentMarker } from "./silent-marker.js";
 const FAMILIAR_COMMAND_NAME = "familiar";
 const THINKING_CHOICES = ["off", "minimal", "low", "medium", "high", "xhigh"];
 const CHANNEL_TRIGGER_CHOICES = ["mention", "always"];
 const EPHEMERAL_REPLY = MessageFlags.Ephemeral;
-const SILENT_RESPONSE_MARKER = "[[FAMILIAR_SILENT]]";
 const HEARTBEAT_SKIPPED = Symbol("heartbeat-skipped");
 const CRON_SKIPPED = Symbol("cron-skipped");
+const DISCORD_ATTACHMENT_SEND_TIMEOUT_MS = 20_000;
 async function withReadyClient(token) {
     const client = new Client({
         intents: [
@@ -327,12 +329,19 @@ async function delayBetweenBurstChunks(config, channel) {
 function normalizeOutboundText(text) {
     return text.trim() || "(empty response)";
 }
+function fallbackMimeType(name) {
+    return extname(name).toLowerCase() === ".mp3" ? "audio/mpeg" : "application/octet-stream";
+}
 async function discordAttachmentPayload(attachment) {
     if (!attachment.localPath)
         return undefined;
+    const data = await readFile(attachment.localPath);
+    const bytes = new Uint8Array(data.byteLength);
+    bytes.set(data);
     return {
-        attachment: await readFile(attachment.localPath),
+        bytes,
         name: attachment.name,
+        mimeType: attachment.mimeType || fallbackMimeType(attachment.name),
     };
 }
 async function discordAttachmentPayloads(attachments) {
@@ -344,19 +353,48 @@ async function discordAttachmentPayloads(attachments) {
     }
     return payloads;
 }
+async function postDiscordAttachments(config, channelId, attachments) {
+    const files = await discordAttachmentPayloads(attachments);
+    if (files.length === 0)
+        return [];
+    const form = new FormData();
+    form.set("payload_json", JSON.stringify({}));
+    for (const [index, file] of files.entries()) {
+        form.set(`files[${index}]`, new Blob([file.bytes], { type: file.mimeType }), file.name);
+    }
+    const response = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
+        method: "POST",
+        headers: { Authorization: `Bot ${config.discord.token}` },
+        body: form,
+    });
+    const data = (await response.json().catch(() => ({})));
+    if (!response.ok || !data.id)
+        throw new Error(data.message || `Discord attachment send failed (${response.status})`);
+    return [data.id];
+}
+async function withDiscordSendTimeout(operation, label, timeoutMs = DISCORD_ATTACHMENT_SEND_TIMEOUT_MS) {
+    let timeout;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([operation, timeoutPromise]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
 export const __test = {
     discordAttachmentPayloads,
+    postDiscordAttachments,
+    withDiscordSendTimeout,
 };
 function parseAgentReply(text) {
-    const normalized = text.replace(/\r\n/g, "\n").trim();
-    if (normalized === SILENT_RESPONSE_MARKER) {
-        return { text: "", silent: true };
-    }
-    if (normalized.startsWith(`${SILENT_RESPONSE_MARKER}\n`)) {
-        const reason = normalized.slice(SILENT_RESPONSE_MARKER.length).trim();
-        return { text: reason, silent: true };
-    }
-    return { text: normalizeOutboundText(text), silent: false };
+    const parsed = parseSilentMarker(text);
+    if (parsed.silent)
+        return parsed;
+    return { text: normalizeOutboundText(parsed.text), silent: false };
 }
 async function sendReply(config, message, text, replyToMessageId, attachments = []) {
     const normalizedText = normalizeOutboundText(text);
@@ -365,7 +403,6 @@ async function sendReply(config, message, text, replyToMessageId, attachments =
     for (const [index, chunk] of chunks.entries()) {
         if (index > 0)
             await delayBetweenBurstChunks(config, message.channel);
-        const files = index === 0 ? await discordAttachmentPayloads(attachments) : [];
         let sent;
         if (index === 0 && config.discord.replyMode === "reply") {
             try {
@@ -373,7 +410,7 @@ async function sendReply(config, message, text, replyToMessageId, attachments =
                 if (!message.channel.isSendable()) {
                     throw new Error(`Discord channel is not sendable: ${message.channelId}`);
                 }
-                const options = { content: chunk, reply: { messageReference: replyTarget }, files };
+                const options = { content: chunk, reply: { messageReference: replyTarget } };
                 sent = await message.channel.send(options);
                 sentIds.push(sent.id);
                 continue;
@@ -385,9 +422,10 @@ async function sendReply(config, message, text, replyToMessageId, attachments =
         if (!message.channel.isSendable()) {
             throw new Error(`Discord channel is not sendable: ${message.channelId}`);
         }
-        sent = await message.channel.send(files.length > 0 ? { content: chunk, files } : chunk);
+        sent = await message.channel.send(chunk);
         sentIds.push(sent.id);
     }
+    sendDiscordAttachmentsInBackground(config, message.channelId, attachments);
     return sentIds;
 }
 async function sendChannelMessage(config, channel, text, attachments = []) {
@@ -400,12 +438,19 @@ async function sendChannelMessage(config, channel, text, attachments = []) {
     for (const [index, chunk] of chunks.entries()) {
         if (index > 0)
             await delayBetweenBurstChunks(config, channel);
-        const files = index === 0 ? await discordAttachmentPayloads(attachments) : [];
-        const sent = await channel.send(files.length > 0 ? { content: chunk, files } : chunk);
+        const sent = await channel.send(chunk);
         sentIds.push(sent.id);
     }
+    sendDiscordAttachmentsInBackground(config, channel.id, attachments);
     return sentIds;
 }
+function sendDiscordAttachmentsInBackground(config, channelId, attachments) {
+    if (attachments.length === 0)
+        return;
+    void withDiscordSendTimeout(postDiscordAttachments(config, channelId, attachments), "Discord attachment send").catch((error) => {
+        console.error("Discord attachment send failed", error);
+    });
+}
 function buildChannelRef(channel, channelId) {
     const scope = channel.type === ChannelType.DM ? "dm" : channel.isThread() ? "thread" : "channel";
     const channelName = "name" in channel ? channel.name : undefined;
@@ -796,9 +841,13 @@ export async function startDiscordDaemon(config, familiarAgent, settings, memory
                     await recorder.flush();
                 }
                 const parsedReply = parseAgentReply(reply.text);
+                const replyAnchor = await fetchMessageAnchor(message, dispatch.triggerMessageId);
                 const messageIds = parsedReply.silent
                     ? []
-                    : await sendReply(config, await fetchMessageAnchor(message, dispatch.triggerMessageId), parsedReply.text, dispatch.triggerMessageId, reply.attachments);
+                    : await sendReply(config, replyAnchor, parsedReply.text, dispatch.triggerMessageId, reply.attachments);
+                if (parsedReply.silent) {
+                    sendDiscordAttachmentsInBackground(config, replyAnchor.channelId, reply.attachments);
+                }
                 await runtime.completeActiveJob({
                     text: parsedReply.text,
                     messageIds,
@@ -868,7 +917,7 @@ export async function startDiscordDaemon(config, familiarAgent, settings, memory
                     schedulerState.heartbeat = { lastFiredAt: new Date(queuedNow).toISOString() };
                     await saveScheduler();
                     const text = buildHeartbeatInjectionText({ now: queuedNow, idleSince: latestUserInteractionAt });
-                    await heartbeatRuntime.noteHeartbeat(`started after ${Math.floor((queuedNow - latestUserInteractionAt) / 60_000)} idle minute(s)`);
+                    await heartbeatRuntime.noteHeartbeat(`heartbeat stirred after ${formatIdleDuration(queuedNow - latestUserInteractionAt)}`);
                     return scheduledUserMessage(text, queuedNow);
                 }, async (event) => {
                     updateAgentEventSummary(summary, event);
@@ -888,6 +937,8 @@ export async function startDiscordDaemon(config, familiarAgent, settings, memory
             const messageIds = parsedReply.silent
                 ? []
                 : await sendChannelMessage(config, channel, parsedReply.text, reply.attachments);
+            if (parsedReply.silent)
+                sendDiscordAttachmentsInBackground(config, channel.id, reply.attachments);
             await heartbeatRuntime.noteOutbound({
                 text: parsedReply.text,
                 messageIds,
@@ -1000,6 +1051,8 @@ export async function startDiscordDaemon(config, familiarAgent, settings, memory
         const messageIds = parsedReply.silent
             ? []
             : await sendChannelMessage(config, channel, parsedReply.text, reply.attachments);
+        if (parsedReply.silent)
+            sendDiscordAttachmentsInBackground(config, channel.id, reply.attachments);
         await runtime.noteOutbound({
             text: parsedReply.text,
             messageIds,

package/dist/generated-media.js

@@ -1,5 +1,6 @@
 import { lstat, mkdir, readdir, rm } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
+import { isEnoent } from "./util/fs.js";
 export function createGeneratedMediaSink() {
     const attachments = [];
     return {
@@ -41,7 +42,7 @@ export async function cleanupGeneratedAttachments(config, now = Date.now()) {
         entries = await readdir(dir);
     }
     catch (error) {
-        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+        if (isEnoent(error))
             return 0;
         throw error;
     }
@@ -52,7 +53,7 @@ export async function cleanupGeneratedAttachments(config, now = Date.now()) {
         if (!fileStat?.isFile() || fileStat.mtimeMs > cutoff)
             continue;
         await rm(path).catch((error) => {
-            if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT"))
+            if (!isEnoent(error))
                 throw error;
         });
         removed++;

package/dist/hot-reload.js

@@ -2,6 +2,7 @@ import { watch } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { basename, relative, resolve, sep } from "node:path";
 import { refreshContactNote } from "./contact-note.js";
+import { isEnoent } from "./util/fs.js";
 const ROOT_FILES = new Set([
     "config.toml",
     ".env",
@@ -13,9 +14,6 @@ const ROOT_FILES = new Set([
     "HEARTBEAT.md",
 ]);
 const SKILLS_DIR = "skills";
-function isEnoent(error) {
-    return !!error && typeof error === "object" && error.code === "ENOENT";
-}
 function shouldReloadForPath(workspacePath, changedPath) {
     const relativePath = relative(workspacePath, resolve(changedPath));
     if (!relativePath || relativePath.startsWith("..") || relativePath.split(sep).includes(".."))

package/dist/image-gen.js

@@ -1,21 +1,15 @@
 import { randomUUID } from "node:crypto";
 import { lstat, writeFile } from "node:fs/promises";
-import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+import { basename, isAbsolute, relative, resolve } from "node:path";
 import { findEnvKeys, generateImages, getEnvApiKey, getImageModels, getImageProviders, } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
 import { ensureGeneratedAttachmentsDir } from "./generated-media.js";
 import { ensureInlineImageDerivative } from "./image-derivatives.js";
 import { promptImagesFromAttachments } from "./inbound-attachments.js";
 import { parseModelRef } from "./models.js";
+import { imageMimeTypeFromPath, sniffImageMimeType } from "./util/image-mime.js";
 const IMAGE_GEN_NOTICE_PREFIX = "Generated image attachment:";
 const OPENROUTER_IMAGE_BASE_URL = "https://openrouter.ai/api/v1";
-const IMAGE_MIME_BY_EXTENSION = {
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".png": "image/png",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-};
 const imageGenSchema = Type.Object({
     prompt: Type.String({ description: "Image generation prompt." }),
     referenceImages: Type.Optional(Type.Array(Type.String(), {
@@ -107,20 +101,6 @@ function textOutput(result) {
         .filter(Boolean)
         .join("\n");
 }
-function imageMimeTypeFromBytes(buffer) {
-    if (buffer.subarray(0, 3).equals(Buffer.from([0xff, 0xd8, 0xff])))
-        return "image/jpeg";
-    if (buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
-        return "image/png";
-    }
-    if (buffer.subarray(0, 6).toString("ascii") === "GIF87a" || buffer.subarray(0, 6).toString("ascii") === "GIF89a") {
-        return "image/gif";
-    }
-    if (buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
-        return "image/webp";
-    }
-    return undefined;
-}
 function recoveredImageFromBase64(value) {
     const data = value.trim();
     if (!/^[A-Za-z0-9+/]+={0,2}$/.test(data) || data.length % 4 !== 0)
@@ -128,7 +108,7 @@ function recoveredImageFromBase64(value) {
     const buffer = Buffer.from(data, "base64");
     if (!buffer.length)
         return undefined;
-    const detectedMimeType = imageMimeTypeFromBytes(buffer);
+    const detectedMimeType = sniffImageMimeType(buffer);
     if (!detectedMimeType)
         return undefined;
     return {
@@ -167,9 +147,6 @@ function normalizeCompatibleImageText(result) {
         return result;
     return { ...result, output };
 }
-function mimeTypeFromPath(path) {
-    return IMAGE_MIME_BY_EXTENSION[extname(path).toLowerCase()];
-}
 function resolveWorkspaceReferencePath(config, rawRef) {
     const path = isAbsolute(rawRef) ? resolve(rawRef) : resolve(config.workspacePath, rawRef);
     const workspaceRelative = relative(config.workspacePath, path);
@@ -190,7 +167,7 @@ async function collectWorkspaceReferenceImages(config, rawRef) {
     }
     if (!pathStat.isFile())
         throw new Error(`Reference image path is not a file or folder: ${rawRef}`);
-    const mimeType = mimeTypeFromPath(path);
+    const mimeType = imageMimeTypeFromPath(path);
     if (!mimeType)
         throw new Error(`Reference image path is not a supported image: ${rawRef}`);
     return [
@@ -338,11 +315,7 @@ async function tryGenerateImages(config, ref, prompt, references, workspaceRefs,
 }
 function attemptDetails(model, result) {
     return {
-        provider: model.provider,
-        model: model.id,
-        api: model.api,
-        baseUrl: model.baseUrl,
-        ...(result.responseId ? { responseId: result.responseId } : {}),
+        model: `${model.provider}/${model.id}`,
         stopReason: result.stopReason,
         ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),
     };
@@ -378,18 +351,8 @@ export function createImageGenTool(config, mediaSink, deps = {}) {
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
-                    let baseUrl = "";
-                    try {
-                        baseUrl = resolveImageModel(config, ref).baseUrl;
-                    }
-                    catch {
-                        baseUrl = "";
-                    }
                     attempts.push({
-                        provider: ref.provider,
-                        model: ref.id,
-                        api: config.imageGen.api,
-                        baseUrl,
+                        model: `${ref.provider}/${ref.id}`,
                         stopReason: "error",
                         errorMessage: message,
                     });
@@ -414,8 +377,10 @@ export function createImageGenTool(config, mediaSink, deps = {}) {
             if (!selected)
                 throw new Error(`Image generation failed: ${selectedError}`);
             const attachments = await writeGeneratedImages(config, mediaSink, selected.result);
+            const primaryAttachment = attachments[0];
             const notices = attachments.map((attachment) => formatImageGenNotice(attachment.name));
             const sideText = textOutput(selected.result);
+            const selectedAttempt = attempts.at(-1);
             return {
                 content: [
                     {
@@ -424,15 +389,11 @@ export function createImageGenTool(config, mediaSink, deps = {}) {
                     },
                 ],
                 details: {
-                    provider: selected.model.provider,
-                    model: selected.model.id,
-                    api: selected.model.api,
-                    baseUrl: selected.model.baseUrl,
-                    prompt,
-                    ...(selected.result.responseId ? { responseId: selected.result.responseId } : {}),
+                    model: `${selected.model.provider}/${selected.model.id}`,
                     ...(sideText ? { textOutput: sideText } : {}),
-                    attachments,
-                    attempts,
+                    ...(primaryAttachment ? { id: primaryAttachment.id, localPath: primaryAttachment.localPath } : {}),
+                    stopReason: selectedAttempt?.stopReason ?? selected.result.stopReason,
+                    ...(selectedAttempt?.errorMessage ? { errorMessage: selectedAttempt.errorMessage } : {}),
                 },
             };
         },

package/dist/inbound-attachments.js

@@ -1,13 +1,16 @@
 import { createHash, randomUUID } from "node:crypto";
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { basename, extname, resolve } from "node:path";
 import { attachmentsDir, publicAttachmentPath } from "./generated-media.js";
 import { ensureInlineImageDerivative, MAX_INLINE_IMAGE_BASE64_BYTES } from "./image-derivatives.js";
 import { deriveInboundAttachmentText } from "./media-understanding.js";
+import { IMAGE_EXTENSION_BY_MIME, sniffImageMimeType } from "./util/image-mime.js";
 export { MAX_INLINE_IMAGE_BASE64_BYTES } from "./image-derivatives.js";
 export const MAX_INBOUND_ATTACHMENTS = 4;
 export const MAX_INBOUND_ATTACHMENT_BYTES = 12 * 1024 * 1024;
 export const MAX_INBOUND_TOTAL_BYTES = 24 * 1024 * 1024;
+const TEXT_ATTACHMENT_PREVIEW_LINES = 2;
+const TEXT_ATTACHMENT_PREVIEW_CHARS = 1000;
 const ALLOWED_MIME_TYPES = new Set([
     "image/jpeg",
     "image/png",
@@ -23,10 +26,7 @@ const ALLOWED_MIME_TYPES = new Set([
     "text/plain",
 ]);
 const EXTENSIONS_BY_MIME = {
-    "image/jpeg": ".jpg",
-    "image/png": ".png",
-    "image/gif": ".gif",
-    "image/webp": ".webp",
+    ...IMAGE_EXTENSION_BY_MIME,
     "audio/mpeg": ".mp3",
     "audio/ogg": ".ogg",
     "audio/wav": ".wav",
@@ -51,32 +51,42 @@ function kindFromMime(mimeType) {
         return "video";
     return "file";
 }
+function textAttachmentPreview(buffer, mimeType) {
+    if (mimeType !== "text/plain")
+        return undefined;
+    const decoded = new TextDecoder("utf-8", { fatal: false }).decode(buffer);
+    const normalized = decoded.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+    if (!normalized || normalized.includes("\uFFFD"))
+        return undefined;
+    const lines = normalized.split("\n").slice(0, TEXT_ATTACHMENT_PREVIEW_LINES);
+    const preview = lines.join("\n").slice(0, TEXT_ATTACHMENT_PREVIEW_CHARS).trim();
+    return preview || undefined;
+}
 function sniffText(buffer) {
     if (buffer.length === 0)
         return "text/plain";
     const head = buffer.subarray(0, Math.min(buffer.length, 512));
     if (head.includes(0))
         return undefined;
-    return head.every((byte) => byte === 9 || byte === 10 || byte === 13 || (byte >= 32 && byte <= 126))
-        ? "text/plain"
-        : undefined;
-}
-function sniffMimeType(buffer, declared) {
-    let detected;
-    if (buffer.subarray(0, 3).equals(Buffer.from([0xff, 0xd8, 0xff])))
-        detected = "image/jpeg";
-    else if (buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
-        detected = "image/png";
+    let decoded;
+    try {
+        decoded = new TextDecoder("utf-8", { fatal: true }).decode(head);
     }
-    else if (buffer.subarray(0, 6).toString("ascii") === "GIF87a" ||
-        buffer.subarray(0, 6).toString("ascii") === "GIF89a") {
-        detected = "image/gif";
+    catch {
+        return undefined;
     }
-    else if (buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
-        buffer.subarray(8, 12).toString("ascii") === "WEBP") {
-        detected = "image/webp";
+    for (const char of decoded) {
+        const code = char.codePointAt(0) ?? 0;
+        if (code === 9 || code === 10 || code === 13)
+            continue;
+        if (code < 32 || code === 127)
+            return undefined;
     }
-    else if (buffer.subarray(0, 4).toString("ascii") === "%PDF")
+    return "text/plain";
+}
+function sniffMimeType(buffer, declared) {
+    let detected = sniffImageMimeType(buffer);
+    if (!detected && buffer.subarray(0, 4).toString("ascii") === "%PDF")
         detected = "application/pdf";
     else if (buffer.subarray(0, 3).toString("ascii") === "ID3" ||
         buffer.subarray(0, 2).equals(Buffer.from([0xff, 0xfb]))) {
@@ -184,6 +194,7 @@ export async function materializeInboundAttachments(config, inputs) {
     }
     const stored = [];
     const writtenPaths = [];
+    const existingDerivedPaths = await knownDerivedImagePaths(config);
     try {
         for (const attachment of prepared) {
             const dir = resolve(attachmentsDir(config), "inbound", attachment.source);
@@ -203,8 +214,24 @@ export async function materializeInboundAttachments(config, inputs) {
                 source: attachment.source,
                 sha256: attachment.sha256,
             };
+            const textPreview = textAttachmentPreview(attachment.buffer, attachment.mimeType);
+            if (textPreview) {
+                finalAttachment.derived = {
+                    ...finalAttachment.derived,
+                    text: {
+                        provider: "local",
+                        model: "text-preview",
+                        label: "preview",
+                        text: textPreview,
+                    },
+                };
+            }
             const derivedImage = await ensureInlineImageDerivative(config, finalAttachment);
             if (derivedImage) {
+                if (derivedImage.localPath && !existingDerivedPaths.has(derivedImage.localPath)) {
+                    writtenPaths.push(derivedImage.localPath);
+                    existingDerivedPaths.add(derivedImage.localPath);
+                }
                 finalAttachment.derived = {
                     ...finalAttachment.derived,
                     image: derivedImage,
@@ -219,6 +246,11 @@ export async function materializeInboundAttachments(config, inputs) {
         throw error;
     }
 }
+async function knownDerivedImagePaths(config) {
+    const dir = resolve(attachmentsDir(config), "derived", "image");
+    const entries = await readdir(dir).catch(() => []);
+    return new Set(entries.map((entry) => resolve(dir, entry)));
+}
 export async function promptImagesFromAttachments(attachments) {
     const images = [];
     const notes = [];
@@ -250,7 +282,16 @@ export async function promptImagesFromAttachments(attachments) {
 export function promptAttachmentNotes(attachments) {
     return attachments
         .map((attachment) => {
-        const attrs = `name="${attachment.name}" id="${attachment.id}" kind="${attachment.kind ?? "file"}" mime="${attachment.mimeType ?? "unknown"}" size="${attachment.size ?? "unknown"}"`;
+        const attrs = [
+            `name="${attachment.name}"`,
+            `id="${attachment.id}"`,
+            `kind="${attachment.kind ?? "file"}"`,
+            `mime="${attachment.mimeType ?? "unknown"}"`,
+            `size="${attachment.size ?? "unknown"}"`,
+            attachment.localPath ? `path="${attachment.localPath}"` : undefined,
+        ]
+            .filter(Boolean)
+            .join(" ");
         const derivedText = attachment.derived?.text?.text;
         if (derivedText) {
             const label = attachment.derived?.text?.label || (attachment.kind === "audio" ? "transcription" : "summary");

package/dist/memory/diary/ambient-injector.js

@@ -1,3 +1,4 @@
+import { positiveIntegerOrDefault } from "../util.js";
 import { retrieveAmbientDiary } from "./ambient.js";
 const INJECTED_MEMORY_OPEN = "<injected_memory>";
 const INJECTED_MEMORY_CLOSE = "</injected_memory>";
@@ -64,9 +65,6 @@ export class AmbientDiaryInjector {
         }
     }
 }
-function positiveIntegerOrDefault(value, fallback) {
-    return value !== undefined && Number.isInteger(value) && value > 0 ? value : fallback;
-}
 function nonNegativeIntegerOrDefault(value, fallback) {
     return value !== undefined && Number.isInteger(value) && value >= 0 ? value : fallback;
 }

package/dist/memory/diary/ambient.js

@@ -1,4 +1,5 @@
 import { retrieveMemory, } from "../index/retrieval.js";
+import { positiveIntegerOrDefault } from "../util.js";
 import { DIARY_CHUNK_CORPUS } from "./chunks.js";
 const DEFAULT_LIMIT = 4;
 const DEFAULT_CANDIDATE_MULTIPLIER = 5;
@@ -119,6 +120,3 @@ function normalizeUnit(value) {
     const absolute = Math.abs(value);
     return Math.max(0, Math.min(1, absolute > 1 ? absolute / 10 : absolute));
 }
-function positiveIntegerOrDefault(value, fallback) {
-    return value !== undefined && Number.isInteger(value) && value > 0 ? value : fallback;
-}

package/dist/memory/diary/chunks.js

@@ -1,4 +1,5 @@
 import { basename } from "node:path";
+import { positiveIntegerOrDefault } from "../util.js";
 export const DIARY_CHUNK_CORPUS = "diary_chunk";
 const DEFAULT_MAX_CHARS = 2400;
 const DIARY_DATE_RE = /^(\d{4}-\d{2}-\d{2})\.md$/;
@@ -226,6 +227,3 @@ function stripInlineMarkdown(value) {
 function isMarkdownHeading(line) {
     return /^#{1,6}\s+/.test(line);
 }
-function positiveIntegerOrDefault(value, fallback) {
-    return value !== undefined && Number.isInteger(value) && value > 0 ? value : fallback;
-}

package/dist/memory/diary/indexer.js

@@ -1,5 +1,6 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { basename, isAbsolute, join, resolve } from "node:path";
+import { isEnoent } from "../../util/fs.js";
 import { DIARY_CHUNK_CORPUS, indexDiaryMarkdown } from "./chunks.js";
 export const DIARY_INDEX_FILE_RE = /^\d{4}-\d{2}-\d{2}\.md$/;
 export function isDatedDiaryMarkdownFile(path) {
@@ -22,9 +23,6 @@ export async function listDiaryMarkdownFiles(config) {
         .map((entry) => join(config.memory.diariesDir, entry.name))
         .sort();
 }
-function isEnoent(error) {
-    return !!error && typeof error === "object" && "code" in error && error.code === "ENOENT";
-}
 export async function indexDiaryFile(options) {
     const path = resolveDiaryPath(options.config, options.path);
     const sourceId = basename(path);

package/dist/memory/doctor.js

@@ -1,3 +1,4 @@
+import { runInTransaction } from "./util.js";
 export function runDoctor(stores, opts = {}) {
     void opts;
     const findings = [];
@@ -32,10 +33,7 @@ export function applyDoctorFixes(stores, report) {
             fixed += before;
         }
     };
-    if (stores.index.db.inTransaction)
-        runIndexFixes();
-    else
-        stores.index.db.transaction(runIndexFixes).immediate();
+    runInTransaction(stores.index.db, runIndexFixes);
     const runLcmFixes = () => {
         fixed += stores.lcm.db
             .prepare(`DELETE FROM lcm_segments
@@ -63,10 +61,7 @@ export function applyDoctorFixes(stores, report) {
             }
         }
     };
-    if (stores.lcm.db.inTransaction)
-        runLcmFixes();
-    else
-        stores.lcm.db.transaction(runLcmFixes).immediate();
+    runInTransaction(stores.lcm.db, runLcmFixes);
     if (report.findings.some((finding) => finding.kind === "summary_fk_violation")) {
         warnings.push("summary FK violations were not modified; inspect LCM summary lineage manually");
     }