arisa 5.1.24 → 5.1.49

package/test/model-selection.test.js

@@ -27,7 +27,7 @@ import {
   parseSpeedPickerAction,
   reverseModelOrder
 } from "../src/transport/telegram/model-picker.js";
-import { closeModelPicker } from "../src/transport/telegram/bot.js";
+import { closeModelPicker, createTelegramModelCallbackHandler } from "../src/transport/telegram/model-callback.js";
 
 function createConfig() {
   return applyConfigDefaults({
@@ -221,6 +221,52 @@ test("closes the picker after selecting the already active model and effort", as
   ]);
 });
 
+test("model callback handler delegates unrelated callbacks", async () => {
+  let delegated = false;
+  const handler = createTelegramModelCallbackHandler({
+    config: createConfig(),
+    authorizeContext: async () => { throw new Error("must not authorize"); },
+    contextRoute: () => ({ sessionId: "123" }),
+    getChatState: () => ({ processing: false }),
+    logger: null
+  });
+
+  await handler({ callbackQuery: { data: "other:action" } }, async () => { delegated = true; });
+  assert.equal(delegated, true);
+});
+
+test("model callback handler persists a non-reasoning model selection", async () => {
+  const config = createConfig();
+  const calls = [];
+  const handler = createTelegramModelCallbackHandler({
+    config,
+    authorizeContext: async () => ({ ok: true }),
+    contextRoute: () => ({ sessionId: "123" }),
+    getChatState: () => ({ processing: false }),
+    getProviderModels: async () => [{ provider: "openai-codex", id: "gpt-next", reasoning: false }],
+    showModelPicker: async () => {},
+    showEffortPicker: async () => {},
+    persistChatModel: async (...args) => calls.push(["persist", ...args]),
+    persistChatEffort: async () => {},
+    persistChatSpeed: async () => {},
+    logger: null
+  });
+  const ctx = {
+    chat: { id: 123 },
+    callbackQuery: { data: "model:0", message: { message_id: 456 } },
+    api: { async editMessageText(...args) { calls.push(["edit", ...args]); } },
+    async answerCallbackQuery(...args) { calls.push(["answer", ...args]); }
+  };
+
+  await handler(ctx, async () => {});
+
+  assert.deepEqual(calls, [
+    ["persist", "123", { provider: "openai-codex", id: "gpt-next", reasoning: false }, "off"],
+    ["edit", 123, 456, "Model changed to openai-codex/gpt-next.\nA new chat context will start with your next message."],
+    ["answer", { text: "Using gpt-next." }]
+  ]);
+});
+
 test("parses only model picker callback data", () => {
   assert.deepEqual(parseModelPickerAction("model:12"), { type: "select", value: 12 });
   assert.deepEqual(parseModelPickerAction("model-page:2"), { type: "page", value: 2 });

package/test/official-tool-dependencies.test.js

@@ -13,6 +13,8 @@ test("official orchestrators declare their hard tool dependencies", async () =>
     "gmail-workspace": "^0.1.0"
   });
   assert.deepEqual((await manifest("x-campaign-runner")).toolDependencies, { "x-dm": "^0.2.0" });
+  assert.deepEqual((await manifest("x-dm")).toolDependencies, { "browser-session-bridge": "^0.1.0" });
+  assert.deepEqual((await manifest("x-session-reader")).toolDependencies, { "browser-session-bridge": "^0.1.0" });
   assert.deepEqual((await manifest("official-tool-sync")).toolDependencies, { trash: "^1.0.0" });
 });
 

package/test/paths.test.js

@@ -9,7 +9,7 @@ import {
   chatsDir,
   createIpcSocketPath,
   getChatArtifactsDir,
-  getChatConversationHistoryFile,
+  getChatSessionSeedFile,
   getChatToolConfigPath,
   getChatToolUsageFile,
   getChatToolStateDir,
@@ -25,10 +25,10 @@ test("keeps chat artifact paths scoped below the chat directory", () => {
   assert.equal(artifactsDir, path.join(chatsDir, "chat-1", "artifacts"));
 });
 
-test("keeps portable conversation history scoped below the chat state directory", () => {
+test("keeps pending session seeds scoped below the chat state directory", () => {
   assert.equal(
-    getChatConversationHistoryFile("chat-1"),
-    path.join(chatsDir, "chat-1", "state", "conversation.jsonl")
+    getChatSessionSeedFile("chat-1"),
+    path.join(chatsDir, "chat-1", "state", "session-seed.jsonl")
   );
 });
 

package/test/restart-receipt.test.js

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { access, mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { cancelRestartReceipt, deliverRestartReceipt, prepareRestartReceipt } from "../src/runtime/restart-receipt.js";
+
+const identity = async () => ({ version: "5.1.30", commit: "abc123" });
+
+test("restart receipt returns to the originating Telegram topic exactly once", async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "arisa-restart-receipt-"));
+  const receiptFile = path.join(directory, "receipt.json");
+  try {
+    await prepareRestartReceipt({ transportChatId: -1001, threadId: 23 }, { reason: "test" }, { receiptFile, getIdentity: identity });
+    const sent = [];
+    const result = await deliverRestartReceipt((...args) => sent.push(args), { receiptFile, getIdentity: identity });
+    assert.equal(result.verified, true);
+    assert.deepEqual(sent[0].slice(0, 1), [-1001]);
+    assert.equal(sent[0][2].message_thread_id, 23);
+    assert.match(sent[0][1], /Restart completed\.\ntest\nArisa 5\.1\.30 is running/);
+    assert.match(sent[0][1], /at commit abc123/);
+    assert.equal(await deliverRestartReceipt(() => {}, { receiptFile, getIdentity: identity }), null);
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("a failed handoff can cancel only its own restart receipt", async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "arisa-restart-cancel-"));
+  const receiptFile = path.join(directory, "receipt.json");
+  try {
+    const receipt = await prepareRestartReceipt({ transportChatId: 42 }, {}, { receiptFile, getIdentity: identity });
+    assert.equal(await cancelRestartReceipt("another-id", { receiptFile }), false);
+    assert.equal(await cancelRestartReceipt(receipt.id, { receiptFile }), true);
+    await assert.rejects(access(receiptFile));
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});

package/test/session-start-operational-notes.test.js

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+async function loadNotesWithHome(homeDir, notesPayload) {
+  await writeFile(
+    path.join(homeDir, "state", "session-start-operational-notes.json"),
+    JSON.stringify(notesPayload),
+    "utf8"
+  );
+
+  const script = `
+const mod = await import(${JSON.stringify(new URL("../src/core/agent/agent-manager.js", import.meta.url).href)});
+process.stdout.write(JSON.stringify(mod.loadSessionStartOperationalNotes()));
+`;
+  const { stdout } = await execFileAsync(process.execPath, ["--input-type=module", "--eval", script], {
+    env: { ...process.env, ARISA_HOME: homeDir }
+  });
+  return JSON.parse(stdout);
+}
+
+test("loads bounded durable operational notes at session start", async (t) => {
+  const homeDir = await mkdtemp(path.join(os.tmpdir(), "arisa-operational-notes-"));
+  t.after(() => rm(homeDir, { recursive: true, force: true }));
+  await rm(path.join(homeDir, "state"), { recursive: true, force: true }).catch(() => {});
+  await mkdir(path.join(homeDir, "state"), { recursive: true });
+
+  const notes = await loadNotesWithHome(homeDir, {
+    notes: [
+      "  Responde   al owner en español por defecto.  ",
+      { text: "Incluye reportes CBPR y tareas programadas." },
+      "",
+      null
+    ]
+  });
+
+  assert.deepEqual(notes, [
+    "Responde al owner en español por defecto.",
+    "Incluye reportes CBPR y tareas programadas."
+  ]);
+});

package/test/telegram-prompt-builders.test.js

@@ -0,0 +1,33 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  buildStartupMessage,
+  normalizeIncomingArtifact
+} from "../src/transport/telegram/prompt-builders.js";
+
+test("builds localized Telegram startup messages", () => {
+  assert.equal(buildStartupMessage({ languageCode: "es-AR" }), "Arisa esta en linea de nuevo.");
+  assert.equal(buildStartupMessage({ languageCode: "pt-BR" }), "Arisa esta online de novo.");
+  assert.equal(buildStartupMessage({ languageCode: "en" }), "Arisa is back online.");
+});
+
+test("reports whether an incoming artifact required normalization", async () => {
+  const result = await normalizeIncomingArtifact({
+    artifact: { id: "voice-1", mimeType: "audio/ogg" },
+    toolRegistry: { list: () => [] },
+    chatArtifactStore: {},
+    chatId: "chat-1"
+  });
+
+  assert.equal(result.normalizationRequired, true);
+  assert.equal(result.transcript, null);
+  assert.match(result.toolResult.error, /No registered tool can normalize audio\/ogg to text\/plain/);
+});
+
+test("skips normalization metadata when there is no incoming artifact", async () => {
+  assert.deepEqual(await normalizeIncomingArtifact({}), {
+    transcript: null,
+    toolResult: null,
+    normalizationRequired: false
+  });
+});

package/test/telegram-task-dispatcher.test.js

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createTelegramTaskDispatcher } from "../src/transport/telegram/task-dispatcher.js";
+
+function createHarness(overrides = {}) {
+  const calls = [];
+  const taskStore = {
+    async fail(...args) { calls.push(["fail", ...args]); },
+    async complete(...args) { calls.push(["complete", ...args]); },
+    async claimDue() { return []; },
+    ...overrides.taskStore
+  };
+  const dispatcher = createTelegramTaskDispatcher({
+    taskStore,
+    sendMessage: async (...args) => calls.push(["send", ...args]),
+    enqueueAsyncPrompt: async (input) => calls.push(["enqueue", input]),
+    artifactStore: { forChat() { throw new Error("unexpected artifact access"); } },
+    toolRegistry: {},
+    resourceNotes: { async get() { return ""; } },
+    agentManager: { async runTool(input) { calls.push(["runTool", input]); } },
+    logger: null,
+    ...overrides.dependencies
+  });
+  return { calls, taskStore, dispatcher };
+}
+
+test("dispatches an agent task into the Telegram prompt queue", async () => {
+  const { calls, dispatcher } = createHarness();
+  await dispatcher.dispatchTask({
+    id: "task-1",
+    kind: "agent_task",
+    payload: { chatId: 123, prompt: "do the thing", telegramContext: { messageThreadId: 9 } }
+  });
+
+  assert.equal(calls[0][0], "enqueue");
+  assert.equal(calls[0][1].chatId, 123);
+  assert.match(calls[0][1].prompt, /taskId: task-1/);
+  assert.match(calls[0][1].prompt, /text: do the thing/);
+  assert.deepEqual(calls[1], ["complete", "task-1"]);
+});
+
+test("acknowledges an agent event before queueing it", async () => {
+  const { calls, dispatcher } = createHarness();
+  await dispatcher.dispatchTask({
+    id: "event-1",
+    kind: "agent_event",
+    payload: { chatId: 123, prompt: "something happened", acknowledgement: "received" }
+  });
+
+  assert.deepEqual(calls[0], ["send", 123, "received"]);
+  assert.equal(calls[1][0], "enqueue");
+  assert.match(calls[1][1].prompt, /event: something happened/);
+  assert.match(calls[1][1].prompt, /return exactly NO_REPLY/);
+  assert.deepEqual(calls[2], ["complete", "event-1"]);
+});
+
+test("runs poll tools headlessly and completes the checker task", async () => {
+  const { calls, dispatcher } = createHarness();
+  await dispatcher.dispatchTask({
+    id: "poll-1",
+    kind: "poll_tool",
+    payload: { chatId: 123, toolName: "checker", args: { cursor: "4" } }
+  });
+
+  assert.deepEqual(calls, [
+    ["runTool", { name: "checker", request: { args: { cursor: "4" } }, chatId: 123 }],
+    ["complete", "poll-1"]
+  ]);
+});
+
+test("fails malformed and unsupported tasks without enqueueing them", async () => {
+  const { calls, dispatcher } = createHarness();
+  await dispatcher.dispatchTask({ id: "bad-1", kind: "agent_task", payload: {} });
+  await dispatcher.dispatchTask({ id: "bad-2", kind: "other", payload: { chatId: 123 } });
+
+  assert.deepEqual(calls, [
+    ["fail", "bad-1", "Task missing chatId: agent_task"],
+    ["fail", "bad-2", "Unsupported task: other"]
+  ]);
+});
+
+test("due-task dispatch isolates failures between claimed tasks", async () => {
+  const tasks = [
+    { id: "bad", kind: "agent_task", payload: { chatId: 123, prompt: "fail" } },
+    { id: "good", kind: "poll_tool", payload: { chatId: 123, toolName: "checker" } }
+  ];
+  const { calls, dispatcher } = createHarness({
+    taskStore: { async claimDue(limit) { calls.push(["claimDue", limit]); return tasks; } },
+    dependencies: {
+      enqueueAsyncPrompt: async () => { throw new Error("queue unavailable"); }
+    }
+  });
+
+  await dispatcher.dispatchDueTasks();
+
+  assert.deepEqual(calls, [
+    ["claimDue", 10],
+    ["fail", "bad", "queue unavailable"],
+    ["runTool", { name: "checker", request: { args: {} }, chatId: 123 }],
+    ["complete", "good"]
+  ]);
+});

package/test/telegram-workspace-group.test.js

@@ -0,0 +1,76 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  resolveTelegramWorkspaceRoute,
+  topicSessionId,
+  verifyOwnerWorkspaceGroup
+} from "../src/transport/telegram/workspace-group.js";
+
+function api({ count = 2, ownerId = 42, botAdmin = true } = {}) {
+  return {
+    getChatMemberCount: async () => count,
+    getChatAdministrators: async () => [
+      { status: "creator", user: { id: ownerId } },
+      ...(botAdmin ? [{ status: "administrator", user: { id: 99 } }] : [])
+    ],
+    getMe: async () => ({ id: 99 })
+  };
+}
+
+test("general topic reuses the owner session while other topics stay separate", () => {
+  assert.equal(topicSessionId({ ownerChatId: 42, groupChatId: -100123, threadId: 1 }), "42");
+  assert.equal(
+    topicSessionId({ ownerChatId: 42, groupChatId: -100123, threadId: 7 }),
+    "42--telegram-group-100123--topic-7"
+  );
+});
+
+test("general topic omits Telegram's non-addressable thread id for replies", async () => {
+  const route = await resolveTelegramWorkspaceRoute({
+    config: { telegram: { ownerWorkspaceGroups: { "-100123": { ownerChatId: 42, generalTopicId: 1 } } } },
+    api: api(),
+    ctx: {
+      chat: { id: -100123, type: "supergroup", is_forum: true },
+      from: { id: 42 },
+      message: { message_thread_id: 1 }
+    }
+  });
+  assert.equal(route.sessionId, "42");
+  assert.equal(route.topicThreadId, 1);
+  assert.equal(route.threadId, null);
+});
+
+test("owner workspace gate accepts bot service events but still blocks a third member", async () => {
+  assert.deepEqual(
+    await verifyOwnerWorkspaceGroup({ api: api(), groupChatId: -100123, ownerChatId: 42, senderId: 99 }),
+    { ok: true, memberCount: 2 }
+  );
+  assert.deepEqual(
+    await verifyOwnerWorkspaceGroup({ api: api({ count: 3 }), groupChatId: -100123, ownerChatId: 42, senderId: 99 }),
+    { ok: false, reason: "member-count", memberCount: 3 }
+  );
+});
+
+test("workspace route shares owner scope and isolates topic session", async () => {
+  const config = {
+    telegram: {
+      ownerWorkspaceGroups: {
+        "-100123": { ownerChatId: 42, generalTopicId: 1 }
+      }
+    }
+  };
+  const route = await resolveTelegramWorkspaceRoute({
+    config,
+    api: api(),
+    ctx: {
+      chat: { id: -100123, type: "supergroup", is_forum: true },
+      from: { id: 42 },
+      message: { message_thread_id: 8 }
+    }
+  });
+  assert.equal(route.ok, true);
+  assert.equal(route.scopeChatId, 42);
+  assert.equal(route.transportChatId, -100123);
+  assert.equal(route.threadId, 8);
+  assert.equal(route.sessionId, "42--telegram-group-100123--topic-8");
+});

package/test/tool-registry-run.test.js

@@ -89,6 +89,15 @@ for (const frame of frames) {
   return dir;
 }
 
+async function createHangingTool(name = "hanging-tool") {
+  const dir = await createFakeTool(name);
+  await writeFile(path.join(dir, "index.js"), `
+process.on("SIGTERM", () => {});
+setInterval(() => {}, 1_000);
+`, "utf8");
+  return dir;
+}
+
 test("loads and lists installed tools from the user tools directory", async () => {
   await resetHome();
   await createFakeTool("fake-tool", {
@@ -117,6 +126,28 @@ test("loads and lists installed tools from the user tools directory", async () =
   }]);
 });
 
+test("keeps the previous complete snapshot visible while a reload is in progress", async () => {
+  const registry = new ToolRegistry();
+  const previous = { name: "stable-tool" };
+  const replacement = { name: "replacement-tool" };
+  registry.tools = new Map([[previous.name, previous]]);
+
+  let releaseSnapshot;
+  registry.buildSnapshot = () => new Promise((resolve) => {
+    releaseSnapshot = () => resolve(new Map([[replacement.name, replacement]]));
+  });
+
+  const loading = registry.load();
+  for (let attempt = 0; attempt < 1_000; attempt += 1) {
+    assert.equal(registry.get(previous.name), previous);
+  }
+  releaseSnapshot();
+  await loading;
+
+  assert.equal(registry.get(previous.name), null);
+  assert.equal(registry.get(replacement.name), replacement);
+});
+
 test("lists optional semantic metadata with stable defaults", async () => {
   await resetHome();
   await createFakeTool("fake-tool");
@@ -234,6 +265,37 @@ test("rejects unknown tools", async () => {
   );
 });
 
+test("terminates timed-out tool runs and requires a status check before retry", async () => {
+  await resetHome();
+  await createHangingTool();
+  const registry = new ToolRegistry({ runTimeoutMs: 20, killGraceMs: 20 });
+  await registry.load();
+
+  const result = await registry.run({
+    name: "hanging-tool",
+    chatId: "chat-1",
+    request: { args: {} }
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.status, "outcome_uncertain");
+  assert.equal(result.resolution.type, "status_check_required");
+  assert.equal(result.resolution.retry, false);
+  assert.match(result.error, /timed out after 20ms/);
+});
+
+test("terminates timed-out tool help processes", async () => {
+  await resetHome();
+  await createHangingTool();
+  const registry = new ToolRegistry({ helpTimeoutMs: 20, killGraceMs: 20 });
+  await registry.load();
+
+  await assert.rejects(
+    () => registry.help("hanging-tool"),
+    /Tool help for hanging-tool timed out after 20ms/
+  );
+});
+
 test("parses fragmented NDJSON incrementally and keeps stderr diagnostic-only", async () => {
   await resetHome();
   await createStreamingTool();

package/test/topic-initialization.test.js

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { buildTopicInitializationHandoff, isProcessableTelegramMessage, startTelegramTyping } from "../src/transport/telegram/bot.js";
+import { SessionSeedStore } from "../src/core/conversation/session-seed-store.js";
+
+test("Telegram typing action stays inside the message topic", async () => {
+  const calls = [];
+  const stop = await startTelegramTyping({
+    chat: { id: "chat-1" },
+    message: { message_thread_id: 42 },
+    api: {
+      sendChatAction: async (chatId, action, options) => {
+        calls.push({ chatId, action, options });
+      }
+    }
+  });
+  stop();
+
+  assert.deepEqual(calls, [
+    { chatId: "chat-1", action: "typing", options: { message_thread_id: 42 } }
+  ]);
+});
+
+test("Telegram service messages do not become empty agent prompts", () => {
+  assert.equal(isProcessableTelegramMessage({ forum_topic_created: { name: "Stories" } }), false);
+  assert.equal(isProcessableTelegramMessage({ forum_topic_edited: { name: "Stories" } }), false);
+  assert.equal(isProcessableTelegramMessage({ text: "hello" }), true);
+  assert.equal(isProcessableTelegramMessage({ voice: { file_id: "voice" } }), true);
+});
+
+test("topic initialization context is explicit and bounded to the topic", () => {
+  const handoff = buildTopicInitializationHandoff({ name: "Stories", context: "Draft first-person development stories for arisa.sh." });
+  assert.match(handoff, /Telegram topic: Stories/);
+  assert.match(handoff, /isolated conversation session/);
+  assert.match(handoff, /Draft first-person development stories/);
+});
+
+test("a persisted session seed is consumed exactly once and can be replaced", async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "arisa-topic-seed-"));
+  const seedFile = (chatId) => path.join(directory, `${chatId}.jsonl`);
+  const legacyFile = (chatId) => path.join(directory, `${chatId}.legacy.jsonl`);
+  const store = new SessionSeedStore({ seedFile, legacyFile });
+  try {
+    await store.set("topic", "Stories context");
+    assert.equal(await store.consume("topic"), "Stories context");
+    assert.equal(await store.consume("topic"), "");
+
+    await store.set("topic", "Replacement context");
+    assert.equal(await store.consume("topic"), "Replacement context");
+
+    await writeFile(legacyFile("pending-legacy"), `${JSON.stringify({ kind: "seed", history: "Pending legacy context" })}\n`, "utf8");
+    assert.equal(await store.consume("pending-legacy"), "Pending legacy context");
+
+    await writeFile(legacyFile("legacy"), [
+      JSON.stringify({ kind: "seed", history: "Old portable context" }),
+      JSON.stringify({ kind: "turn", prompt: "stale", response: "stale" }),
+      ""
+    ].join("\n"), "utf8");
+    assert.equal(await store.consume("legacy"), "");
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});