arisa 5.1.49 → 5.1.64

package/src/transport/telegram/telegram-session-bridge.js

@@ -0,0 +1,177 @@
+import path from "node:path";
+import { InputFile } from "grammy";
+import { cancelRestartReceipt, prepareRestartReceipt } from "../../runtime/restart-receipt.js";
+import { isSilentReply } from "./prompt-builders.js";
+import { renderTelegramHtml } from "./text-format.js";
+import { resolveTelegramWorkspaceRoute, topicSessionId } from "./workspace-group.js";
+
+function deliveryMethod(artifact, method) {
+  if (method) return method;
+  if (artifact.metadata?.delivery?.method) return artifact.metadata.delivery.method;
+  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";
+}
+
+function safeCaption(caption) {
+  return caption && !/(^|\s)(\/[^\s]|[A-Za-z]:[\\/])/.test(caption) ? caption : undefined;
+}
+
+export function createTelegramSessionBridgeController({
+  config,
+  api,
+  agentManager,
+  artifactStore,
+  sessionSeeds,
+  workspaceTopics,
+  getChatState,
+  buildTopicInitializationHandoff,
+  logger
+}) {
+  function createWorkspaceAccessGuard(route) {
+    return async () => {
+      if (!route.workspace) return;
+      const current = await resolveTelegramWorkspaceRoute({
+        config,
+        api,
+        ctx: {
+          chat: { id: route.transportChatId, type: "supergroup", is_forum: true },
+          from: { id: route.ownerChatId },
+          message: { message_thread_id: route.threadId }
+        }
+      });
+      if (!current.ok) throw new Error("Owner-only workspace access is paused.");
+    };
+  }
+
+  function createSessionBridge(route) {
+    const messageOptions = (extra = {}) => route.workspace && route.threadId
+      ? { ...extra, message_thread_id: route.threadId }
+      : extra;
+    const initializeForumTopic = async ({ messageThreadId, name, context }) => {
+      if (!route.workspace) throw new Error("Telegram topic initialization is only available from the owner workspace forum.");
+      await createWorkspaceAccessGuard(route)();
+      const initializedSessionId = topicSessionId({
+        ownerChatId: route.ownerChatId,
+        groupChatId: route.transportChatId,
+        threadId: messageThreadId,
+        generalTopicId: route.generalTopicId
+      });
+      if (initializedSessionId === String(route.ownerChatId)) {
+        throw new Error("The General topic already uses the owner's private session and cannot be reinitialized here.");
+      }
+      const handoff = buildTopicInitializationHandoff({ name, context });
+      await workspaceTopics.upsertTopic(route.ownerChatId, route.transportChatId, {
+        threadId: messageThreadId,
+        name,
+        description: context,
+        source: "arisa-initialized"
+      });
+      await sessionSeeds.set(initializedSessionId, handoff);
+      agentManager.resetSession(initializedSessionId, { handoff });
+      await agentManager.waitForSessionClose(initializedSessionId);
+      return {
+        ok: true,
+        chatId: route.transportChatId,
+        messageThreadId,
+        sessionId: initializedSessionId,
+        name,
+        initialized: true
+      };
+    };
+    return {
+      sendMedia: async (filePath, { method = "audio", caption, filename } = {}) => {
+        logger?.log("telegram", `sending ${method} reply for chat ${route.transportChatId}`);
+        const input = new InputFile(filePath, filename || undefined);
+        const options = messageOptions({ caption });
+        if (method === "voice") return api.sendVoice(route.transportChatId, input, options);
+        if (method === "document") return api.sendDocument(route.transportChatId, input, options);
+        if (method === "photo" || method === "image") return api.sendPhoto(route.transportChatId, input, options);
+        if (method === "video") return api.sendVideo(route.transportChatId, input, options);
+        return api.sendAudio(route.transportChatId, input, options);
+      },
+      createForumTopic: async (name, context) => {
+        if (!route.workspace) throw new Error("Telegram topic creation is only available from the owner workspace forum.");
+        await createWorkspaceAccessGuard(route)();
+        const topic = await api.createForumTopic(route.transportChatId, name);
+        return initializeForumTopic({
+          messageThreadId: topic.message_thread_id,
+          name: topic.name,
+          context
+        });
+      },
+      initializeForumTopic,
+      prepareRestartReceipt: (summary) => prepareRestartReceipt({
+        transportChatId: route.transportChatId,
+        threadId: route.threadId
+      }, { reason: String(summary || "Agent-requested restart").trim() }),
+      cancelRestartReceipt,
+      getTaskContext: () => route.workspace ? {
+        transport: "telegram",
+        destination: {
+          chatId: route.transportChatId,
+          threadId: route.topicThreadId
+        }
+      } : null
+    };
+  }
+
+  async function sendTextReply({ sendText, sendDocument, chatId, artifactChatId = chatId, text }) {
+    const maxInlineReplyLength = 3500;
+    if (isSilentReply(text)) {
+      logger?.log("telegram", `suppressing silent reply for chat ${chatId}`);
+      return;
+    }
+
+    if (text.length > maxInlineReplyLength) {
+      logger?.log("telegram", `sending long reply as markdown attachment for chat ${chatId}`);
+      const chatArtifactStore = artifactStore.forChat(artifactChatId);
+      const artifact = await chatArtifactStore.createGeneratedFile({
+        fileName: `reply-${Date.now()}.md`,
+        content: text,
+        kind: "document",
+        mimeType: "text/markdown",
+        source: { type: "assistant", chatId },
+        metadata: { delivery: "telegram-document" }
+      });
+      await sendDocument(new InputFile(artifact.path, path.basename(artifact.path)), {
+        caption: "Response attached as Markdown."
+      });
+      return;
+    }
+
+    logger?.log("telegram", `sending text reply for chat ${chatId}`);
+    const sent = await sendText(renderTelegramHtml(text), { parse_mode: "HTML" });
+    if (sent?.message_id) {
+      const messages = getChatState(chatId).assistantMessages;
+      messages.set(sent.message_id, text);
+      while (messages.size > 50) messages.delete(messages.keys().next().value);
+    }
+  }
+
+  function installArtifactDeliveryHandler() {
+    agentManager.setArtifactDeliveryHandler?.(async ({ chatId, artifact, caption, method }) => {
+      const resolvedMethod = deliveryMethod(artifact, method);
+      await createSessionBridge({
+        workspace: false,
+        sessionId: String(chatId),
+        scopeChatId: chatId,
+        transportChatId: chatId,
+        threadId: null
+      }).sendMedia(artifact.path, {
+        method: resolvedMethod,
+        caption: safeCaption(caption),
+        filename: path.basename(artifact.path)
+      });
+      return { ok: true, artifactId: artifact.id, method: resolvedMethod };
+    });
+  }
+
+  return {
+    createSessionBridge,
+    createWorkspaceAccessGuard,
+    installArtifactDeliveryHandler,
+    sendTextReply
+  };
+}

package/src/transport/telegram/telegram-tools-command.js

@@ -0,0 +1,28 @@
+import { getErrorMessage } from "../../core/agent/auth-flow.js";
+import { formatToolUsageReport } from "../../runtime/tool-usage-report.js";
+import { renderTelegramHtml } from "./text-format.js";
+
+export function createTelegramToolsCommandHandler({
+  authorize,
+  contextRoute,
+  toolRegistry,
+  withTyping,
+  logger
+}) {
+  return async (ctx) => {
+    logger?.log("telegram", `/tools command received in chat ${ctx.chat.id}`);
+    return withTyping(ctx, async () => {
+      const auth = await authorize(ctx);
+      if (!auth.ok) return;
+      try {
+        const report = await toolRegistry.usage(contextRoute(ctx).scopeChatId);
+        await ctx.reply(renderTelegramHtml(formatToolUsageReport(report)), { parse_mode: "HTML" });
+        logger?.log("telegram", `/tools command completed in chat ${ctx.chat.id}`);
+      } catch (error) {
+        const message = getErrorMessage(error);
+        logger?.error("telegram", `/tools command failed in chat ${ctx.chat.id}: ${message}`);
+        await ctx.reply(`Tool usage report failed: ${message}`);
+      }
+    });
+  };
+}

package/src/transport/telegram/telegram-workspace-controller.js

@@ -0,0 +1,66 @@
+import { authorizeChat } from "./auth.js";
+import { resolveTelegramWorkspaceRoute } from "./workspace-group.js";
+
+function incomingChatMeta(ctx) {
+  return {
+    languageCode: ctx.from?.language_code || "",
+    username: ctx.from?.username || "",
+    firstName: ctx.from?.first_name || "",
+    lastName: ctx.from?.last_name || ""
+  };
+}
+
+export function createTelegramWorkspaceController({ config, api, saveConfig }) {
+  const routes = new WeakMap();
+  const gateStates = new Map();
+
+  async function authorizeContext(ctx) {
+    const route = await resolveTelegramWorkspaceRoute({ config, api: ctx.api || api, ctx });
+    if (!route.workspace) {
+      const authorization = await authorizeChat({
+        config,
+        chatId: ctx.chat.id,
+        saveConfig,
+        chatMeta: incomingChatMeta(ctx)
+      });
+      if (authorization.ok) routes.set(ctx, route);
+      return authorization;
+    }
+
+    const gateKey = String(ctx.chat.id);
+    const previous = gateStates.get(gateKey);
+    if (!route.ok) {
+      gateStates.set(gateKey, route.reason || "locked");
+      if (previous !== (route.reason || "locked")) {
+        await ctx.reply("Private workspace access is paused because this forum is no longer owner-only.").catch(() => {});
+      }
+      return { ok: false, reason: route.reason || "workspace-locked" };
+    }
+    if (!(config.telegram.authorizedChatIds || []).includes(route.ownerChatId)) {
+      return { ok: false, reason: "owner-not-authorized" };
+    }
+    routes.set(ctx, route);
+    gateStates.set(gateKey, "ready");
+    if (previous && previous !== "ready") {
+      await ctx.reply("Private workspace access restored.").catch(() => {});
+    }
+    return { ok: true, firstTime: false, workspace: true };
+  }
+
+  function contextRoute(ctx) {
+    return routes.get(ctx) || {
+      ok: true,
+      workspace: false,
+      sessionId: String(ctx.chat.id),
+      scopeChatId: ctx.chat.id,
+      transportChatId: ctx.chat.id,
+      threadId: null
+    };
+  }
+
+  return {
+    authorizeContext,
+    contextRoute,
+    registerRoute: (ctx, route) => routes.set(ctx, route)
+  };
+}

package/src/transport/telegram/workspace-topic-store.js

@@ -0,0 +1,228 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getChatTelegramWorkspacesFile } from "../../runtime/paths.js";
+
+const recentProposalWindowMs = 30 * 24 * 60 * 60 * 1000;
+
+function emptyState() {
+  return { version: 1, groups: {} };
+}
+
+function integer(value, label) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) throw new Error(`${label} must be an integer`);
+  return parsed;
+}
+
+function oneLine(value, maxLength) {
+  return String(value || "").replace(/\s+/g, " ").trim().slice(0, maxLength);
+}
+
+function normalizeState(parsed) {
+  if (!parsed || parsed.version !== 1 || !parsed.groups || typeof parsed.groups !== "object") {
+    throw new Error("Unsupported Telegram workspace topic state");
+  }
+  return parsed;
+}
+
+async function readState(file) {
+  try {
+    return normalizeState(JSON.parse(await readFile(file, "utf8")));
+  } catch (error) {
+    if (error?.code === "ENOENT") return emptyState();
+    throw error;
+  }
+}
+
+async function writeState(file, state) {
+  await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  await rename(temporary, file);
+}
+
+function workspace(state, groupChatId) {
+  const groupKey = String(groupChatId);
+  state.groups[groupKey] ||= { topics: {}, proposals: {} };
+  state.groups[groupKey].topics ||= {};
+  state.groups[groupKey].proposals ||= {};
+  return state.groups[groupKey];
+}
+
+function normalizeTopic(threadId, topic) {
+  return {
+    threadId: Number(threadId),
+    name: oneLine(topic?.name, 80),
+    description: oneLine(topic?.description, 240),
+    status: topic?.status === "closed" ? "closed" : "open",
+    source: oneLine(topic?.source, 40),
+    createdAt: oneLine(topic?.createdAt, 40),
+    updatedAt: oneLine(topic?.updatedAt, 40)
+  };
+}
+
+export async function migrateLegacyReplyTopics(config, store) {
+  let migratedGroups = 0;
+  for (const [groupChatId, workspaceConfig] of Object.entries(config.telegram?.ownerWorkspaceGroups || {})) {
+    const configured = workspaceConfig?.replyTopics;
+    if (!configured || typeof configured !== "object" || Array.isArray(configured)) continue;
+    const generalTopicId = Number(workspaceConfig.generalTopicId) || 1;
+    for (const [threadId, topic] of Object.entries(configured)) {
+      const numericThreadId = Number(threadId);
+      const name = oneLine(topic?.name, 80);
+      if (!Number.isSafeInteger(numericThreadId) || numericThreadId <= 0 || numericThreadId === generalTopicId || !name) continue;
+      await store.upsertTopic(workspaceConfig.ownerChatId, Number(groupChatId), {
+        threadId: numericThreadId,
+        name,
+        description: topic?.description,
+        source: "legacy-config-migration"
+      });
+    }
+    delete workspaceConfig.replyTopics;
+    migratedGroups += 1;
+  }
+  return migratedGroups;
+}
+
+export class WorkspaceTopicStore {
+  constructor({ resolveFile = getChatTelegramWorkspacesFile, now = () => Date.now() } = {}) {
+    this.resolveFile = resolveFile;
+    this.now = now;
+    this.queues = new Map();
+  }
+
+  async withOwnerLock(ownerChatId, work) {
+    const key = String(ownerChatId);
+    const previous = this.queues.get(key) || Promise.resolve();
+    const current = previous.catch(() => {}).then(work);
+    this.queues.set(key, current);
+    try {
+      return await current;
+    } finally {
+      if (this.queues.get(key) === current) this.queues.delete(key);
+    }
+  }
+
+  async read(ownerChatId) {
+    await (this.queues.get(String(ownerChatId)) || Promise.resolve()).catch(() => {});
+    return readState(this.resolveFile(ownerChatId));
+  }
+
+  async listTopics(ownerChatId, groupChatId, { includeClosed = false } = {}) {
+    const state = await this.read(ownerChatId);
+    const group = state.groups[String(groupChatId)];
+    if (!group?.topics) return [];
+    return Object.entries(group.topics)
+      .map(([threadId, topic]) => normalizeTopic(threadId, topic))
+      .filter((topic) => Number.isSafeInteger(topic.threadId)
+        && topic.threadId > 0
+        && topic.name
+        && (includeClosed || topic.status === "open"))
+      .sort((left, right) => left.threadId - right.threadId);
+  }
+
+  async upsertTopic(ownerChatId, groupChatId, { threadId, name, description, status = "open", source = "observed" }) {
+    const scopedOwner = integer(ownerChatId, "ownerChatId");
+    const scopedGroup = integer(groupChatId, "groupChatId");
+    const scopedThread = integer(threadId, "threadId");
+    const scopedName = oneLine(name, 80);
+    if (scopedThread <= 0) throw new Error("threadId must be positive");
+    if (!scopedName) throw new Error("topic name is required");
+
+    return this.withOwnerLock(scopedOwner, async () => {
+      const file = this.resolveFile(scopedOwner);
+      const state = await readState(file);
+      const group = workspace(state, scopedGroup);
+      const key = String(scopedThread);
+      const existing = group.topics[key] || {};
+      const timestamp = new Date(this.now()).toISOString();
+      group.topics[key] = {
+        ...existing,
+        name: scopedName,
+        description: description === undefined ? oneLine(existing.description, 240) : oneLine(description, 240),
+        status: status === "closed" ? "closed" : "open",
+        source: oneLine(source, 40) || oneLine(existing.source, 40) || "observed",
+        createdAt: existing.createdAt || timestamp,
+        updatedAt: timestamp
+      };
+      await writeState(file, state);
+      return normalizeTopic(key, group.topics[key]);
+    });
+  }
+
+  async setTopicStatus(ownerChatId, groupChatId, threadId, status) {
+    const scopedOwner = integer(ownerChatId, "ownerChatId");
+    const scopedGroup = integer(groupChatId, "groupChatId");
+    const scopedThread = integer(threadId, "threadId");
+    return this.withOwnerLock(scopedOwner, async () => {
+      const file = this.resolveFile(scopedOwner);
+      const state = await readState(file);
+      const topic = state.groups[String(scopedGroup)]?.topics?.[String(scopedThread)];
+      if (!topic) return null;
+      topic.status = status === "closed" ? "closed" : "open";
+      topic.updatedAt = new Date(this.now()).toISOString();
+      await writeState(file, state);
+      return normalizeTopic(scopedThread, topic);
+    });
+  }
+
+  async observeMessage(route, message = {}) {
+    if (!route?.workspace || !route.ownerChatId || !route.transportChatId) return null;
+    const threadId = route.topicThreadId;
+    if (!Number.isSafeInteger(threadId) || threadId === route.generalTopicId) return null;
+    if (message.forum_topic_created?.name) {
+      return this.upsertTopic(route.ownerChatId, route.transportChatId, {
+        threadId,
+        name: message.forum_topic_created.name,
+        source: "telegram-created"
+      });
+    }
+    if (message.forum_topic_edited?.name) {
+      return this.upsertTopic(route.ownerChatId, route.transportChatId, {
+        threadId,
+        name: message.forum_topic_edited.name,
+        source: "telegram-edited"
+      });
+    }
+    if (message.forum_topic_closed) {
+      return this.setTopicStatus(route.ownerChatId, route.transportChatId, threadId, "closed");
+    }
+    if (message.forum_topic_reopened) {
+      return this.setTopicStatus(route.ownerChatId, route.transportChatId, threadId, "open");
+    }
+    return null;
+  }
+
+  async recordProposal(ownerChatId, groupChatId, name) {
+    const scopedOwner = integer(ownerChatId, "ownerChatId");
+    const scopedGroup = integer(groupChatId, "groupChatId");
+    const scopedName = oneLine(name, 80);
+    if (!scopedName) return null;
+    return this.withOwnerLock(scopedOwner, async () => {
+      const file = this.resolveFile(scopedOwner);
+      const state = await readState(file);
+      const group = workspace(state, scopedGroup);
+      const key = scopedName.toLocaleLowerCase("en-US");
+      group.proposals[key] = {
+        name: scopedName,
+        proposedAt: new Date(this.now()).toISOString()
+      };
+      const ordered = Object.entries(group.proposals)
+        .sort((left, right) => String(right[1]?.proposedAt || "").localeCompare(String(left[1]?.proposedAt || "")))
+        .slice(0, 50);
+      group.proposals = Object.fromEntries(ordered);
+      await writeState(file, state);
+      return group.proposals[key];
+    });
+  }
+
+  async listRecentProposals(ownerChatId, groupChatId) {
+    const state = await this.read(ownerChatId);
+    const proposals = state.groups[String(groupChatId)]?.proposals || {};
+    const cutoff = this.now() - recentProposalWindowMs;
+    return Object.values(proposals)
+      .filter((proposal) => Date.parse(proposal?.proposedAt || "") >= cutoff)
+      .sort((left, right) => String(right.proposedAt).localeCompare(String(left.proposedAt)))
+      .slice(0, 12);
+  }
+}

package/test/agent-session-lifecycle.test.js

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { AgentSessionLifecycle } from "../src/core/agent/agent-session-lifecycle.js";
+
+test("session lifecycle owns cache closure and pending handoffs", async () => {
+  let closes = 0;
+  const lifecycle = new AgentSessionLifecycle({
+    logger: null,
+    summarizeContext: () => ({ messages: 0, estimatedTokens: 0 })
+  });
+  lifecycle.sessions.set("chat", {
+    session: {
+      async close() { closes += 1; }
+    }
+  });
+
+  lifecycle.resetSession("chat", { handoff: "continue here", parentSession: "parent.jsonl" });
+  await lifecycle.waitForClose("chat");
+
+  assert.equal(closes, 1);
+  assert.equal(lifecycle.sessions.has("chat"), false);
+  assert.equal(lifecycle.pendingNewSessions.has("chat"), true);
+  assert.deepEqual(lifecycle.pendingSessionHandoffs.get("chat"), {
+    text: "continue here",
+    parentSession: "parent.jsonl"
+  });
+
+  lifecycle.completeNewSession("chat");
+  assert.equal(lifecycle.pendingNewSessions.has("chat"), false);
+  assert.equal(lifecycle.pendingSessionHandoffs.has("chat"), false);
+});
+
+test("session lifecycle diagnostics remain available after extraction", async () => {
+  const lifecycle = new AgentSessionLifecycle({
+    logger: null,
+    summarizeContext: () => ({ messages: 2, estimatedTokens: 42 })
+  });
+  lifecycle.sessions.set("123", {
+    session: {
+      messages: [{ role: "user" }, { role: "assistant" }],
+      getSessionStats: () => ({ contextUsage: { tokens: 42, contextWindow: 1000, percent: 4.2 } })
+    }
+  });
+
+  assert.deepEqual(await lifecycle.getDiagnostic(), {
+    harness: "pi",
+    sessions: 1,
+    closingSessions: 0,
+    contexts: [{
+      chatId: "123",
+      messages: 2,
+      estimatedTokens: 42,
+      tokens: 42,
+      contextWindow: 1000,
+      percent: 4.2
+    }]
+  });
+});

package/test/artifact-store.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -9,7 +9,7 @@ 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");
+const { arisaHomeDir, getChatArtifactsIndexFile } = await import("../src/runtime/paths.js");
 
 async function resetHome() {
   await rm(arisaHomeDir, { recursive: true, force: true });
@@ -46,6 +46,42 @@ test("creates, persists, reads, and lists text artifacts by recency", async () =
   assert.deepEqual(await reloadedStore.get(first.id), first);
 });
 
+test("serializes 100 concurrent artifact writes across store instances", async () => {
+  await resetHome();
+  const chatId = "concurrent-chat";
+  const stores = Array.from({ length: 5 }, () => new ArtifactStore().forChat(chatId));
+  const artifacts = await Promise.all(Array.from({ length: 100 }, (_, index) => (
+    stores[index % stores.length].createText({
+      text: `message ${index}`,
+      source: { type: "test", index }
+    })
+  )));
+
+  const persisted = JSON.parse(await readFile(getChatArtifactsIndexFile(chatId), "utf8"));
+  assert.equal(persisted.length, 100);
+  assert.equal(new Set(persisted.map((artifact) => artifact.id)).size, 100);
+  assert.deepEqual(
+    new Set(persisted.map((artifact) => artifact.id)),
+    new Set(artifacts.map((artifact) => artifact.id))
+  );
+  const stateFiles = await readdir(path.dirname(getChatArtifactsIndexFile(chatId)));
+  assert.equal(stateFiles.some((name) => name.endsWith(".tmp")), false);
+});
+
+test("refuses to overwrite a corrupt artifact index", async () => {
+  await resetHome();
+  const chatId = "corrupt-chat";
+  const indexFile = getChatArtifactsIndexFile(chatId);
+  await new ArtifactStore().forChat(chatId).createText({ text: "safe", source: { type: "test" } });
+  await writeFile(indexFile, "{truncated", "utf8");
+
+  await assert.rejects(
+    new ArtifactStore().forChat(chatId).createText({ text: "must not replace", source: { type: "test" } }),
+    /Artifact index is unreadable/
+  );
+  assert.equal(await readFile(indexFile, "utf8"), "{truncated");
+});
+
 test("copies file artifacts into the chat artifact directory", async () => {
   await resetHome();
   const originalDir = await mkdtemp(path.join(os.tmpdir(), "arisa-source-file-"));

package/test/capabilities-security.test.js

@@ -142,6 +142,64 @@ test("requires chatId for chat-scoped IPC methods", async () => {
   }
 });
 
+test("tool-emitted tasks cannot override trusted chat routing", async () => {
+  const capabilities = createCapabilities();
+  const created = await capabilities.dispatch({
+    method: "tasks.add",
+    toolName: "poller",
+    chatId: "trusted-chat",
+    params: {
+      task: {
+        kind: "agent_task",
+        route: { transport: "telegram", destination: { chatId: "attacker-chat" } },
+        payload: {
+          chatId: "attacker-chat",
+          telegramContext: { transportChatId: "attacker-chat" },
+          prompt: "Safe payload"
+        }
+      }
+    }
+  });
+
+  assert.equal(created.route, undefined);
+  assert.equal(created.payload.chatId, "trusted-chat");
+  assert.equal(created.payload.telegramContext, undefined);
+  assert.equal(created.payload.prompt, "Safe payload");
+});
+
+test("IPC resource notes remain scoped to the calling tool", async () => {
+  const calls = [];
+  const capabilities = createArisaCapabilities({
+    artifactStore: createFakeArtifactStore(),
+    taskStore: createFakeTaskStore(),
+    resourceNotes: {
+      set: async (...args) => {
+        calls.push(args);
+        return { ok: true };
+      }
+    }
+  });
+
+  await capabilities.dispatch({
+    method: "tools.setResourceNote",
+    toolName: "caller-tool",
+    chatId: "chat-1",
+    params: { name: "other-tool", resourceId: "resource-1", note: "watch" }
+  });
+
+  assert.deepEqual(calls, [["chat-1", "caller-tool", "resource-1", "watch"]]);
+});
+
+test("IPC does not expose Telegram-only capability methods", async () => {
+  const capabilities = createCapabilities();
+  await assert.rejects(() => capabilities.dispatch({
+    method: "telegram.createTopic",
+    toolName: "caller-tool",
+    chatId: "chat-1",
+    params: { name: "Unsafe", context: "No" }
+  }), /unknown IPC method: telegram\.createTopic/);
+});
+
 test("agent events preserve a bounded immediate acknowledgement", async () => {
   const capabilities = createCapabilities();
   const created = await capabilities.dispatch({