arisa 4.1.10 → 4.1.14

package/AGENTS.md

@@ -123,7 +123,7 @@ Example manual pipe:
 2. take the returned text `artifactId`
 3. `run_tool(openai-tts, artifact text)` to generate audio, then `send_artifact(artifactId)` to deliver it (or `run_tool(openai-tts, artifact text, deliver: true)` to generate and send in one step)
 
-Delivery is generic: any `run_tool` output that produces a file becomes an artifact, and `send_artifact(artifactId)` delivers it to the chat. The delivery method and caption are derived from the artifact (its `delivery` hint, `kind`, and stored name); internal local paths are never exposed. Tools declare their delivery intent by returning `delivery: { method }` in their output; they do not deliver to the transport themselves. As a shortcut, `run_tool` accepts `deliver: true` to generate and deliver in a single step; use it only when the user should receive the file now, not for intermediate pipe steps.
+Delivery is generic: any `run_tool` output that produces a file becomes an artifact, and `send_artifact(artifactId)` delivers it to the chat. The delivery method and filename are derived from the artifact (its `delivery` hint, `kind`, and stored name); internal local paths are never exposed. No caption is sent by default: the filename already appears on the attachment, so it is never duplicated into the caption text (which would let Telegram autolink a filename like `example.md` as a URL). A caption is shown only when an explicit one is passed. Tools declare their delivery intent by returning `delivery: { method }` in their output; they do not deliver to the transport themselves. As a shortcut, `run_tool` accepts `deliver: true` to generate and deliver in a single step; use it only when the user should receive the file now, not for intermediate pipe steps.
 
 ## Async event queue flow
 Beyond time-based scheduling, tools can drive an event queue that wakes the agent only when there is something to evaluate. Everything goes through the `asyncTask` (single) or `asyncTasks` (array) field the pipeline already supports; no new Pi tools are needed. The 1s poller drains tasks by `kind`:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "4.1.10",
+  "version": "4.1.14",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

package/src/core/agent/agent-manager.js

@@ -57,6 +57,8 @@ async function promptAndThrowOnAssistantError(session, prompt) {
 
 function inferDeliveryMethod(artifact) {
   if (artifact.kind === "audio" || (artifact.mimeType || "").startsWith("audio/")) return "audio";
+  if (artifact.kind === "image" || (artifact.mimeType || "").startsWith("image/")) return "photo";
+  if (artifact.kind === "video" || (artifact.mimeType || "").startsWith("video/")) return "video";
   return "document";
 }
 
@@ -65,18 +67,15 @@ function containsAbsolutePath(value) {
   return /(^|\s)(\/[^\s]|[A-Za-z]:[\\/])/.test(value);
 }
 
-function resolveMediaCaption({ caption, output, method }) {
+export function resolveMediaCaption(caption) {
   if (caption && !containsAbsolutePath(caption)) return caption;
-  if (method === "document" && output?.fileName) return output.fileName;
-  if (output?.text && !containsAbsolutePath(output.text)) return output.text;
-  if (output?.fileName) return output.fileName;
   return undefined;
 }
 
 async function deliverArtifactToChat({ artifact, telegram, caption, method, logger }) {
   const resolvedMethod = method || artifact.metadata?.delivery?.method || inferDeliveryMethod(artifact);
   const fileName = path.basename(artifact.path);
-  const resolvedCaption = resolveMediaCaption({ caption, output: { fileName }, method: resolvedMethod });
+  const resolvedCaption = resolveMediaCaption(caption);
   logger?.log("agent", `deliver artifact ${artifact.id} as ${resolvedMethod}`);
   await telegram.sendMedia(artifact.path, { method: resolvedMethod, caption: resolvedCaption, filename: fileName });
   return { method: resolvedMethod, fileName, artifactId: artifact.id };
@@ -428,7 +427,7 @@ export class AgentManager {
       defineTool({
         name: "send_artifact",
         label: "Send artifact",
-        description: "Deliver an existing chat artifact to the current Telegram chat. Pass the `artifactId` returned by run_tool or from an inbound file. The delivery method, caption, and filename are derived from the artifact (its delivery hint, kind, and stored name); internal local paths are never exposed. Set `caption` for a visible label, or `method` to override the delivery method. The artifact is not deleted.",
+        description: "Deliver an existing chat artifact to the current Telegram chat. Pass the `artifactId` returned by run_tool or from an inbound file. The delivery method and filename are derived from the artifact (its delivery hint, kind, and stored name); internal local paths are never exposed. No caption is shown by default, since the filename already appears on the attachment; set `caption` only to add a separate visible label, or `method` to override the delivery method. The artifact is not deleted.",
         parameters: Type.Object({
           artifactId: Type.String(),
           caption: Type.Optional(Type.String()),

package/src/transport/telegram/bot.js

@@ -48,7 +48,23 @@ function getIncomingMessageText(message) {
   return message?.text || message?.caption || "";
 }
 
-function buildPrompt({ ctx, artifact, transcript, toolResult }) {
+function baseMimeType(mimeType = "") {
+  return mimeType.split(";")[0].trim().toLowerCase();
+}
+
+function isInlineTextArtifact(artifact, messageText) {
+  return artifact?.kind === "text"
+    && baseMimeType(artifact.mimeType) === "text/plain"
+    && typeof artifact.text === "string"
+    && artifact.text === messageText;
+}
+
+export function shouldIncludeArtifactReference({ artifact, messageText = "" } = {}) {
+  if (!artifact) return false;
+  return !isInlineTextArtifact(artifact, messageText);
+}
+
+export function buildPrompt({ ctx, artifact, transcript, toolResult }) {
   const parts = [
     `Incoming Telegram message.`,
     `chatId: ${ctx.chat.id}`,
@@ -60,10 +76,12 @@ function buildPrompt({ ctx, artifact, transcript, toolResult }) {
   const messageText = getIncomingMessageText(ctx.message);
   if (messageText) parts.push(`text: ${messageText}`);
   parts.push(...quotedMessageSummary(ctx.message?.reply_to_message));
-  if (artifact?.path) parts.push(`artifactPath: ${artifact.path}`);
-  if (artifact?.id) parts.push(`artifactId: ${artifact.id}`);
-  if (artifact?.mimeType) parts.push(`mimeType: ${artifact.mimeType}`);
-  if (artifact?.kind) parts.push(`kind: ${artifact.kind}`);
+  if (shouldIncludeArtifactReference({ artifact, messageText })) {
+    if (artifact?.path) parts.push(`artifactPath: ${artifact.path}`);
+    if (artifact?.id) parts.push(`artifactId: ${artifact.id}`);
+    if (artifact?.mimeType) parts.push(`mimeType: ${artifact.mimeType}`);
+    if (artifact?.kind) parts.push(`kind: ${artifact.kind}`);
+  }
   if (transcript) {
     parts.push(`transcriptArtifactId: ${transcript.id}`);
     parts.push(`transcriptText: ${transcript.text}`);
@@ -91,21 +109,24 @@ function buildNewSessionPrompt(ctx) {
 }
 
 async function buildAsyncTaskPrompt({ task, artifactStore, toolRegistry, logger }) {
+  const taskText = task.payload.prompt || "";
   const parts = [
     "Scheduled task fired.",
     `taskId: ${task.id}`,
     `chatId: ${task.payload.chatId}`,
-    task.payload.prompt ? `text: ${task.payload.prompt}` : null
+    taskText ? `text: ${taskText}` : null
   ];
 
   if (task.payload.artifactId) {
     const chatArtifactStore = artifactStore.forChat(task.payload.chatId);
     const artifact = await chatArtifactStore.get(task.payload.artifactId);
     if (artifact) {
-      parts.push(`artifactPath: ${artifact.path || ""}`);
-      parts.push(`artifactId: ${artifact.id}`);
-      parts.push(`mimeType: ${artifact.mimeType}`);
-      parts.push(`kind: ${artifact.kind}`);
+      if (shouldIncludeArtifactReference({ artifact, messageText: taskText })) {
+        parts.push(`artifactPath: ${artifact.path || ""}`);
+        parts.push(`artifactId: ${artifact.id}`);
+        parts.push(`mimeType: ${artifact.mimeType}`);
+        parts.push(`kind: ${artifact.kind}`);
+      }
 
       const { normalizedArtifact, toolResult } = await normalizeArtifactForReasoning({
         artifact,
@@ -431,6 +452,8 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
         const input = new InputFile(filePath, filename || undefined);
         if (method === "voice") return bot.api.sendVoice(chatId, input, { caption });
         if (method === "document") return bot.api.sendDocument(chatId, input, { caption });
+        if (method === "photo" || method === "image") return bot.api.sendPhoto(chatId, input, { caption });
+        if (method === "video") return bot.api.sendVideo(chatId, input, { caption });
         return bot.api.sendAudio(chatId, input, { caption });
       }
     };

package/src/transport/telegram/media.js

@@ -128,7 +128,7 @@ export async function captureIncomingArtifact(ctx, artifactStore) {
     return store.createText({
       text: ctx.message.text,
       source: baseSource,
-      metadata: {}
+      metadata: { visibility: "internal", representation: "inline-message" }
     });
   }
 

package/test/artifact-store.test.js

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+const homeDir = await mkdtemp(path.join(os.tmpdir(), "arisa-artifact-store-home-"));
+process.env.HOME = homeDir;
+process.env.USERPROFILE = homeDir;
+
+const { ArtifactStore } = await import("../src/core/artifacts/artifact-store.js");
+const { arisaHomeDir } = await import("../src/runtime/paths.js");
+
+async function resetHome() {
+  await rm(arisaHomeDir, { recursive: true, force: true });
+}
+
+test("creates, persists, reads, and lists text artifacts by recency", async () => {
+  await resetHome();
+  const store = new ArtifactStore();
+  const chatStore = store.forChat("chat-1");
+
+  const first = await chatStore.createText({
+    text: "first",
+    source: { type: "telegram" },
+    metadata: { index: 1 }
+  });
+  const second = await chatStore.createText({
+    text: "second",
+    mimeType: "text/markdown",
+    source: { type: "tool", toolName: "writer" },
+    metadata: { index: 2 }
+  });
+  const third = await chatStore.createText({
+    text: "third",
+    source: { type: "tool", toolName: "writer" }
+  });
+
+  assert.equal(first.chatId, "chat-1");
+  assert.equal(first.kind, "text");
+  assert.equal(first.mimeType, "text/plain");
+  assert.deepEqual(await chatStore.get(second.id), second);
+  assert.deepEqual((await chatStore.listRecent(2)).map((artifact) => artifact.id), [third.id, second.id]);
+
+  const reloadedStore = new ArtifactStore().forChat("chat-1");
+  assert.deepEqual(await reloadedStore.get(first.id), first);
+});
+
+test("copies file artifacts into the chat artifact directory", async () => {
+  await resetHome();
+  const originalDir = await mkdtemp(path.join(os.tmpdir(), "arisa-source-file-"));
+  const originalPath = path.join(originalDir, "voice.ogg");
+  await writeFile(originalPath, "audio-bytes", "utf8");
+
+  const artifact = await new ArtifactStore().forChat("chat-1").createFromFile({
+    originalPath,
+    fileName: "voice.ogg",
+    kind: "audio",
+    mimeType: "audio/ogg",
+    source: { type: "telegram", fileId: "telegram-file" },
+    metadata: { duration: 3 }
+  });
+
+  assert.equal(artifact.chatId, "chat-1");
+  assert.equal(artifact.kind, "audio");
+  assert.equal(artifact.mimeType, "audio/ogg");
+  assert.equal(path.basename(artifact.path), "voice.ogg");
+  assert.equal(await readFile(artifact.path, "utf8"), "audio-bytes");
+});
+
+test("creates generated file artifacts", async () => {
+  await resetHome();
+  const artifact = await new ArtifactStore().forChat("chat-1").createGeneratedFile({
+    fileName: "reply.md",
+    content: "# Hello\n",
+    kind: "document",
+    mimeType: "text/markdown",
+    source: { type: "assistant" }
+  });
+
+  assert.equal(await readFile(artifact.path, "utf8"), "# Hello\n");
+  assert.equal(artifact.kind, "document");
+  assert.equal(artifact.mimeType, "text/markdown");
+});
+
+test("keeps artifact indexes isolated by chat", async () => {
+  await resetHome();
+  const store = new ArtifactStore();
+  const chatA = store.forChat("chat-a");
+  const chatB = store.forChat("chat-b");
+
+  const aArtifact = await chatA.createText({ text: "for A", source: { type: "test" } });
+  const bArtifact = await chatB.createText({ text: "for B", source: { type: "test" } });
+
+  assert.deepEqual((await chatA.listRecent()).map((artifact) => artifact.id), [aArtifact.id]);
+  assert.deepEqual((await chatB.listRecent()).map((artifact) => artifact.id), [bArtifact.id]);
+  assert.equal(await chatA.get(bArtifact.id), null);
+  assert.equal(await chatB.get(aArtifact.id), null);
+});

package/test/auth-flow.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { getErrorMessage, getPiAuthIssue } from "../src/core/agent/auth-flow.js";
+
+test("extracts messages from Error instances and other thrown values", () => {
+  assert.equal(getErrorMessage(new Error("boom")), "boom");
+  assert.equal(getErrorMessage("plain failure"), "plain failure");
+  assert.equal(getErrorMessage(404), "404");
+});
+
+test("classifies invalidated Pi authentication tokens", () => {
+  for (const error of [
+    new Error("authentication token has been invalidated"),
+    new Error("Token invalidated by provider"),
+    new Error("Please try signing in again"),
+    new Error("auth token expired")
+  ]) {
+    assert.deepEqual(getPiAuthIssue(error), {
+      kind: "invalidated-token",
+      message: error.message
+    });
+  }
+});
+
+test("classifies missing Pi authentication", () => {
+  for (const error of [
+    new Error("No auth found for provider"),
+    new Error("authentication credentials are missing")
+  ]) {
+    assert.deepEqual(getPiAuthIssue(error), {
+      kind: "missing-auth",
+      message: error.message
+    });
+  }
+});
+
+test("ignores unrelated Pi errors", () => {
+  assert.equal(getPiAuthIssue(new Error("model rate limit exceeded")), null);
+  assert.equal(getPiAuthIssue(new Error("")), null);
+});

package/test/auth.test.js

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { authorizeChat } from "../src/transport/telegram/auth.js";
+
+function createConfig(overrides = {}) {
+  return {
+    telegram: {
+      authorizedChatIds: [],
+      maxChatIds: 2,
+      chatMeta: {},
+      ...(overrides.telegram || {})
+    }
+  };
+}
+
+function createSaveConfigSpy() {
+  const calls = [];
+  const saveConfig = async (config) => {
+    calls.push(JSON.parse(JSON.stringify(config)));
+  };
+  return { saveConfig, calls };
+}
+
+test("authorizes a new chat below the configured limit", async () => {
+  const config = createConfig();
+  const { saveConfig, calls } = createSaveConfigSpy();
+
+  const result = await authorizeChat({ config, chatId: 123, saveConfig });
+
+  assert.deepEqual(result, { ok: true, firstTime: true });
+  assert.deepEqual(config.telegram.authorizedChatIds, [123]);
+  assert.equal(calls.length, 1);
+  assert.deepEqual(calls[0].telegram.authorizedChatIds, [123]);
+});
+
+test("keeps an authorized chat id unique", async () => {
+  const config = createConfig({
+    telegram: { authorizedChatIds: [123] }
+  });
+  const { saveConfig, calls } = createSaveConfigSpy();
+
+  const result = await authorizeChat({ config, chatId: 123, saveConfig });
+
+  assert.deepEqual(result, { ok: true, firstTime: false });
+  assert.deepEqual(config.telegram.authorizedChatIds, [123]);
+  assert.equal(calls.length, 0);
+});
+
+test("rejects a new chat when the chat id limit is reached", async () => {
+  const config = createConfig({
+    telegram: { authorizedChatIds: [123, 456], maxChatIds: 2 }
+  });
+  const { saveConfig, calls } = createSaveConfigSpy();
+
+  const result = await authorizeChat({ config, chatId: 789, saveConfig });
+
+  assert.deepEqual(result, { ok: false, reason: "max-chat-ids" });
+  assert.deepEqual(config.telegram.authorizedChatIds, [123, 456]);
+  assert.equal(calls.length, 0);
+});
+
+test("enforces the maxChatIds off-by-one boundary", async () => {
+  const config = createConfig({
+    telegram: { authorizedChatIds: [123], maxChatIds: 1 }
+  });
+  const { saveConfig, calls } = createSaveConfigSpy();
+
+  const result = await authorizeChat({ config, chatId: 456, saveConfig });
+
+  assert.deepEqual(result, { ok: false, reason: "max-chat-ids" });
+  assert.deepEqual(config.telegram.authorizedChatIds, [123]);
+  assert.equal(calls.length, 0);
+});
+
+test("merges chat metadata for an existing authorized chat and persists it", async () => {
+  const config = createConfig({
+    telegram: {
+      authorizedChatIds: [123],
+      chatMeta: {
+        123: { username: "old-name", firstName: "Ada" }
+      }
+    }
+  });
+  const { saveConfig, calls } = createSaveConfigSpy();
+
+  const result = await authorizeChat({
+    config,
+    chatId: 123,
+    saveConfig,
+    chatMeta: { username: "new-name", lastName: "Lovelace" }
+  });
+
+  assert.deepEqual(result, { ok: true, firstTime: false });
+  assert.deepEqual(config.telegram.chatMeta[123], {
+    username: "new-name",
+    firstName: "Ada",
+    lastName: "Lovelace"
+  });
+  assert.equal(calls.length, 1);
+  assert.deepEqual(calls[0].telegram.chatMeta[123], config.telegram.chatMeta[123]);
+});

package/test/capabilities-security.test.js

@@ -0,0 +1,249 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createArisaCapabilities } from "../src/runtime/arisa-capabilities.js";
+
+function createFakeArtifactStore() {
+  const stores = new Map();
+  return {
+    forChat(chatId) {
+      const key = String(chatId);
+      if (!stores.has(key)) {
+        const items = [];
+        stores.set(key, {
+          createText: async ({ text, mimeType, source, metadata }) => {
+            const artifact = {
+              id: `artifact-${items.length + 1}`,
+              chatId: key,
+              kind: "text",
+              mimeType,
+              text,
+              source,
+              metadata
+            };
+            items.push(artifact);
+            return artifact;
+          },
+          listRecent: async (limit) => [...items].slice(-limit).reverse(),
+          get: async (artifactId) => items.find((item) => item.id === artifactId) || null
+        });
+      }
+      return stores.get(key);
+    }
+  };
+}
+
+function createFakeTaskStore(initialTasks = []) {
+  const tasks = [...initialTasks];
+  return {
+    add: async (task, defaults = {}) => {
+      const created = {
+        id: `task-${tasks.length + 1}`,
+        ...task,
+        payload: { ...(defaults.payload || {}), ...(task.payload || {}) },
+        source: { ...(defaults.source || {}), ...(task.source || {}) }
+      };
+      tasks.push(created);
+      return created;
+    },
+    list: async (filter = {}) => tasks.filter((task) => {
+      if (filter.chatId && task.payload?.chatId !== filter.chatId) return false;
+      if (filter.status && task.status !== filter.status) return false;
+      if (filter.kind && task.kind !== filter.kind) return false;
+      return true;
+    }),
+    get: async (taskId) => tasks.find((task) => task.id === taskId) || null,
+    cancel: async (taskId) => {
+      const index = tasks.findIndex((task) => task.id === taskId);
+      if (index === -1) return null;
+      const [removed] = tasks.splice(index, 1);
+      return removed;
+    }
+  };
+}
+
+function createCapabilities(overrides = {}) {
+  return createArisaCapabilities({
+    artifactStore: overrides.artifactStore || createFakeArtifactStore(),
+    taskStore: overrides.taskStore || createFakeTaskStore(),
+    agentManager: overrides.agentManager
+  });
+}
+
+test("rejects cancellation of tasks from another chat", async () => {
+  const capabilities = createCapabilities({
+    taskStore: createFakeTaskStore([
+      { id: "task-1", status: "pending", payload: { chatId: "chat-a" } }
+    ])
+  });
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "tasks.cancel",
+      toolName: "poller",
+      chatId: "chat-b",
+      params: { taskId: "task-1" }
+    }),
+    /task does not belong to chatId/
+  );
+});
+
+test("requires a non-empty toolName for all IPC dispatches", async () => {
+  const capabilities = createCapabilities();
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "paths.getToolStateDir",
+      toolName: "  ",
+      params: {}
+    }),
+    /toolName is required/
+  );
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "paths.getToolStateDir",
+      toolName: null,
+      params: {}
+    }),
+    /toolName is required/
+  );
+});
+
+test("requires chatId for chat-scoped IPC methods", async () => {
+  const capabilities = createCapabilities({
+    agentManager: {
+      runTool: async () => ({ ok: true, status: "ok" })
+    }
+  });
+
+  for (const method of [
+    "artifacts.createText",
+    "artifacts.listRecent",
+    "artifacts.get",
+    "tasks.add",
+    "tasks.list",
+    "tasks.cancel",
+    "agent.enqueueEvent",
+    "paths.getChatToolStateDir",
+    "paths.getChatToolTmpDir",
+    "paths.getChatArtifactsDir",
+    "tools.run"
+  ]) {
+    await assert.rejects(
+      () => capabilities.dispatch({
+        method,
+        toolName: "ipc-tool",
+        params: method === "tasks.cancel" ? { taskId: "task-1" } : {}
+      }),
+      new RegExp(`${method.replace(".", "\\.")} requires chatId`)
+    );
+  }
+});
+
+test("normalizes tool run args and rejects arrays", async () => {
+  const calls = [];
+  const capabilities = createCapabilities({
+    agentManager: {
+      runTool: async (request) => {
+        calls.push(request);
+        return { ok: true, status: "ok" };
+      }
+    }
+  });
+
+  await capabilities.dispatch({
+    method: "tools.run",
+    toolName: "caller",
+    chatId: "chat-1",
+    params: { name: "worker", args: null }
+  });
+  assert.deepEqual(calls.at(-1).request.args, {});
+
+  await capabilities.dispatch({
+    method: "tools.run",
+    toolName: "caller",
+    chatId: "chat-1",
+    params: { name: "worker", args: { bpm: 128 } }
+  });
+  assert.deepEqual(calls.at(-1).request.args, { bpm: 128 });
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "tools.run",
+      toolName: "caller",
+      chatId: "chat-1",
+      params: { name: "worker", args: ["not", "an", "object"] }
+    }),
+    /args must be an object/
+  );
+});
+
+test("rejects missing artifact input before running a tool", async () => {
+  const calls = [];
+  const capabilities = createCapabilities({
+    agentManager: {
+      runTool: async (request) => {
+        calls.push(request);
+        return { ok: true, status: "ok" };
+      }
+    }
+  });
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "tools.run",
+      toolName: "caller",
+      chatId: "chat-1",
+      params: { name: "worker", artifactId: "missing" }
+    }),
+    /Artifact not found: missing/
+  );
+  assert.equal(calls.length, 0);
+});
+
+test("normalizes list limits for artifact reads", async () => {
+  const observedLimits = [];
+  const artifactStore = {
+    forChat: () => ({
+      listRecent: async (limit) => {
+        observedLimits.push(limit);
+        return [];
+      }
+    })
+  };
+  const capabilities = createCapabilities({ artifactStore });
+
+  await capabilities.dispatch({
+    method: "artifacts.listRecent",
+    toolName: "viewer",
+    chatId: "chat-1",
+    params: { limit: 0 }
+  });
+  await capabilities.dispatch({
+    method: "artifacts.listRecent",
+    toolName: "viewer",
+    chatId: "chat-1",
+    params: { limit: "not-a-number" }
+  });
+  await capabilities.dispatch({
+    method: "artifacts.listRecent",
+    toolName: "viewer",
+    chatId: "chat-1",
+    params: { limit: 1000 }
+  });
+
+  assert.deepEqual(observedLimits, [20, 20, 100]);
+});
+
+test("rejects unknown IPC methods", async () => {
+  const capabilities = createCapabilities();
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "unknown.method",
+      toolName: "caller",
+      params: {}
+    }),
+    /unknown IPC method: unknown\.method/
+  );
+});

package/test/media-caption.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { resolveMediaCaption } from "../src/core/agent/agent-manager.js";
+
+test("does not turn a domain-like filename into a caption", () => {
+  assert.equal(resolveMediaCaption(undefined), undefined);
+});
+
+test("keeps an explicit caption that is not a local path", () => {
+  assert.equal(resolveMediaCaption("Here is the report"), "Here is the report");
+});
+
+test("drops an explicit caption that leaks an absolute path", () => {
+  assert.equal(resolveMediaCaption("/Users/me/.arisa/artifacts/report.md"), undefined);
+});