arisa 5.1.13 → 5.1.49

package/test/doctor.test.js

@@ -4,7 +4,6 @@ import { formatDoctorReport, runDoctor } from "../src/runtime/doctor.js";
 import { serviceEntryFile } from "../src/runtime/service-manager.js";
 
 const doctorPolicy = {
-  contextInspectionTimeoutMs: 1_000,
   contextWarningPercent: 70,
   contextCriticalPercent: 90,
   contextInefficientMinTokens: 32_000,
@@ -22,7 +21,6 @@ function runtime(overrides = {}) {
     harness: "pi",
     sessions: 1,
     closingSessions: 0,
-    managedProcessIds: [],
     contexts: [],
     ...overrides
   };
@@ -87,6 +85,61 @@ test("reports Pi context size and retained-content inefficiency", async () => {
   assert.ok(formatted.split("\n").every((line) => [...line].length <= 35));
 });
 
+test("lists each checked daemon with its scope and state", async () => {
+  const { report } = await run({
+    repairs: [
+      {
+        record: { toolName: "master-slave", instanceId: "global", scope: { type: "global" } },
+        diagnostic: { state: "ready" },
+        outcome: "healthy"
+      },
+      {
+        record: { toolName: "context-vault", instanceId: "chat-1", scope: { type: "chat" } },
+        diagnostic: { state: "stopped" },
+        outcome: "stopped"
+      }
+    ]
+  });
+
+  report.infrastructure = {
+    role: "master",
+    daemon: { state: "ready" },
+    endpoint: "tcp://198.74.61.48:4719",
+    paired: null,
+    identityFingerprint: "unnecessarily-long-fingerprint",
+    toolCount: 0,
+    jobs: { active: 0, queued: 0, failed: 0 },
+    pendingSecrets: 0
+  };
+  const formatted = formatDoctorReport(report);
+  assert.match(formatted, /Daemons \(2\)\n  Ready \(1\)\n  - master-slave \[global\]/);
+  assert.match(formatted, /  Stopped \(1\)\n  - context-vault \[chat\]/);
+  assert.match(formatted, /Master\/Slave\n  Mode       master · ready/);
+  assert.match(formatted, /Endpoint   198\.74\.61\.48:4719/);
+  assert.match(formatted, /Activity   idle/);
+  assert.doesNotMatch(formatted, /Identity|fingerprint|Paired/);
+  assert.ok(formatted.split("\n").every((line) => [...line].length <= 35));
+});
+
+test("reports missing tool dependencies as attention items", async () => {
+  const report = await runDoctor({
+    agentManager: { getRuntimeDiagnostic: async () => runtime() },
+    toolProcessSupervisor: { repair: async () => [] },
+    daemonPolicy,
+    doctorPolicy,
+    listProcesses: async () => [],
+    serviceStatus: async () => ({ running: false }),
+    inspectResources: async () => system,
+    inspectToolDependencies: async () => [{
+      tool: "magnific-mcp",
+      type: "missing",
+      dependency: "mcp-client",
+      range: "^0.1.0"
+    }]
+  });
+  assert.match(report.attention.join("\n"), /magnific-mcp requires mcp-client@\^0\.1\.0/);
+});
+
 test("stops only a registered duplicate Arisa service with verified identity", async () => {
   const duplicatePid = 321;
   const { report, stopped } = await run({
@@ -104,8 +157,8 @@ test("requires complete positive doctor context policy", async () => {
       agentManager: { getRuntimeDiagnostic: async () => runtime() },
       toolProcessSupervisor: { repair: async () => [] },
       daemonPolicy,
-      doctorPolicy: { ...doctorPolicy, contextInspectionTimeoutMs: 0 }
+      doctorPolicy: { ...doctorPolicy, contextWarningPercent: 0 }
     }),
-    /positive contextInspectionTimeoutMs/
+    /positive contextWarningPercent/
   );
 });

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

@@ -0,0 +1,25 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+
+async function manifest(name) {
+  return JSON.parse(await readFile(new URL(`../../tools/${name}/tool.manifest.json`, import.meta.url), "utf8"));
+}
+
+test("official orchestrators declare their hard tool dependencies", async () => {
+  assert.deepEqual((await manifest("magnific-mcp")).toolDependencies, { "mcp-client": "^0.1.0" });
+  assert.deepEqual((await manifest("campaign-draft-runner")).toolDependencies, {
+    "pr-campaign": "^0.1.0",
+    "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" });
+});
+
+test("optional tool integrations do not become hard dependencies", async () => {
+  assert.deepEqual((await manifest("whatsapp-web")).toolDependencies, undefined);
+  assert.deepEqual((await manifest("pr-campaign")).toolDependencies, undefined);
+  assert.deepEqual((await manifest("master-slave")).toolDependencies, undefined);
+});

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

@@ -60,14 +60,16 @@ test("verifies the exact file set and digests", async (t) => {
   await assert.rejects(() => verifyOfficialToolTree(source, files), /unexpected=extra.js/);
 });
 
-test("bundled master-slave lock matches the catalog source", async () => {
+test("every bundled official tool lock matches the catalog source", async () => {
   const lock = JSON.parse(await readFile(new URL("../src/official-tools.lock.json", import.meta.url), "utf8"));
-  const source = fileURLToPath(new URL("../../tools/master-slave/", import.meta.url));
-
-  assert.deepEqual(
-    await verifyOfficialToolTree(source, lock.tools["master-slave"].files),
-    { files: Object.keys(lock.tools["master-slave"].files).length }
-  );
+  for (const [name, entry] of Object.entries(lock.tools)) {
+    const source = fileURLToPath(new URL(`../../tools/${name}/`, import.meta.url));
+    assert.deepEqual(
+      await verifyOfficialToolTree(source, entry.files),
+      { files: Object.keys(entry.files).length },
+      name
+    );
+  }
 });
 
 test("rejects symbolic links before deployment", async (t) => {
@@ -83,15 +85,18 @@ test("installs a verified staged tree without overwriting an existing tool", asy
     await mkdir(path.join(checkoutDir, "tools"), { recursive: true });
     await cp(source, path.join(checkoutDir, "tools", "master-slave"), { recursive: true });
   };
+  const lifecycle = [];
   const result = await installLockedOfficialTool({
     toolName: "master-slave",
     lock: lock(files),
     destination,
     scratchRoot: root,
     checkout,
-    validate: async () => {}
+    installDependencies: async () => { lifecycle.push("dependencies"); },
+    validate: async () => { lifecycle.push("validate"); }
   });
   assert.equal(result.commit, "a".repeat(40));
+  assert.deepEqual(lifecycle, ["dependencies", "validate"]);
   assert.equal(await readFile(path.join(destination, "index.js"), "utf8"), "process.stdout.write('ok');\n");
   await assert.rejects(
     () => installLockedOfficialTool({ toolName: "master-slave", lock: lock(files), destination, scratchRoot: root, checkout }),
@@ -111,8 +116,31 @@ test("loads the bundled lock before selecting the canonical tool destination", a
       return { installed: true };
     }
   });
-  assert.deepEqual(result, { installed: true });
+  assert.deepEqual(result, { installed: true, dependencies: [] });
   assert.equal(calls[0].toolName, "master-slave");
   assert.deepEqual(calls[0].lock, lock(files));
   assert.match(calls[0].destination, /tools\/master-slave$/);
 });
+
+test("installs locked tool dependencies before the requested tool", async (t) => {
+  const { root, files } = await fixture(t);
+  const dependencyLock = lock(files);
+  dependencyLock.tools = {
+    "mcp-client": { version: "0.1.0", toolDependencies: {}, files },
+    "magnific-mcp": { version: "0.1.0", toolDependencies: { "mcp-client": "^0.1.0" }, files }
+  };
+  const lockFile = path.join(root, "dependency-lock.json");
+  await writeFile(lockFile, `${JSON.stringify(dependencyLock)}\n`);
+  const calls = [];
+  const result = await installBundledOfficialTool("magnific-mcp", {
+    lockFile,
+    resolveInstalledVersion: async () => undefined,
+    install: async ({ toolName }) => {
+      calls.push(toolName);
+      return { toolName, installed: true };
+    }
+  });
+  assert.deepEqual(calls, ["mcp-client", "magnific-mcp"]);
+  assert.equal(result.toolName, "magnific-mcp");
+  assert.deepEqual(result.dependencies, [{ name: "mcp-client", version: "0.1.0", status: "installed" }]);
+});

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-dependencies.test.js

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  inspectToolDependencies,
+  normalizeToolDependencies,
+  resolveToolDependencyPlan,
+  satisfiesToolVersion
+} from "../src/core/tools/tool-dependencies.js";
+
+test("normalizes strict tool dependency maps and supports exact and caret versions", () => {
+  assert.deepEqual(normalizeToolDependencies({ "mcp-client": "^0.1.0" }), { "mcp-client": "^0.1.0" });
+  assert.equal(satisfiesToolVersion("0.1.9", "^0.1.0"), true);
+  assert.equal(satisfiesToolVersion("0.2.0", "^0.1.0"), false);
+  assert.equal(satisfiesToolVersion("1.4.0", "^1.2.3"), true);
+  assert.equal(satisfiesToolVersion("2.0.0", "^1.2.3"), false);
+  assert.throws(() => normalizeToolDependencies({ "../bad": "^1.0.0" }), /Invalid tool dependency name/);
+  assert.throws(() => normalizeToolDependencies({ valid: ">=1.0.0" }), /Unsupported tool dependency range/);
+});
+
+test("resolves dependencies before dependents and detects invalid graphs", () => {
+  const entries = {
+    "mcp-client": { version: "0.1.0", toolDependencies: {} },
+    "magnific-mcp": { version: "0.1.0", toolDependencies: { "mcp-client": "^0.1.0" } }
+  };
+  assert.deepEqual(resolveToolDependencyPlan(entries, "magnific-mcp"), ["mcp-client", "magnific-mcp"]);
+  assert.throws(
+    () => resolveToolDependencyPlan({ a: { version: "1.0.0", toolDependencies: { b: "^1.0.0" } } }, "a"),
+    /not locked/
+  );
+  assert.throws(
+    () => resolveToolDependencyPlan({
+      a: { version: "1.0.0", toolDependencies: { b: "^1.0.0" } },
+      b: { version: "1.0.0", toolDependencies: { a: "^1.0.0" } }
+    }, "a"),
+    /Circular/
+  );
+});
+
+test("reports missing and incompatible installed tool dependencies", () => {
+  const tools = new Map([
+    ["magnific-mcp", { name: "magnific-mcp", version: "0.1.0", toolDependencies: { "mcp-client": "^0.1.0" } }]
+  ]);
+  assert.deepEqual(inspectToolDependencies(tools), [{
+    tool: "magnific-mcp",
+    type: "missing",
+    dependency: "mcp-client",
+    range: "^0.1.0"
+  }]);
+  tools.set("mcp-client", { name: "mcp-client", version: "0.2.0", toolDependencies: {} });
+  assert.equal(inspectToolDependencies(tools)[0].type, "incompatible");
+  tools.get("mcp-client").version = "0.1.4";
+  assert.deepEqual(inspectToolDependencies(tools), []);
+});