arisa 5.1.13 → 5.1.24

package/src/runtime/doctor.js

@@ -87,16 +87,43 @@ function daemonLabel(record) {
   return `${record.toolName} (${record.instanceId || "global"})`;
 }
 
-function daemonResultSummary(results) {
-  const states = new Map();
+function daemonState(result) {
+  return result.diagnostic?.state || result.outcome;
+}
+
+function daemonStateLabel(state) {
+  return String(state || "unknown")
+    .split("-")
+    .map((part) => part ? `${part[0].toUpperCase()}${part.slice(1)}` : part)
+    .join(" ");
+}
+
+function daemonReportLines(results) {
+  const priority = ["ready", "starting", "degraded", "unhealthy", "restarting", "stopped", "failed"];
+  const groups = new Map();
   for (const result of results) {
-    const state = result.diagnostic?.state || result.outcome;
-    states.set(state, (states.get(state) || 0) + 1);
+    const state = daemonState(result);
+    if (!groups.has(state)) groups.set(state, []);
+    groups.get(state).push(result);
   }
-  return [...states.entries()]
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([state, count]) => `${count} ${state}`)
-    .join(", ");
+  const states = [...groups.keys()].sort((left, right) => {
+    const leftIndex = priority.indexOf(left);
+    const rightIndex = priority.indexOf(right);
+    if (leftIndex === -1 && rightIndex === -1) return left.localeCompare(right);
+    if (leftIndex === -1) return 1;
+    if (rightIndex === -1) return -1;
+    return leftIndex - rightIndex;
+  });
+  const lines = [];
+  for (const state of states) {
+    const group = groups.get(state);
+    lines.push(`  ${daemonStateLabel(state)} (${group.length})`);
+    for (const result of group.sort((left, right) => daemonLabel(left.record).localeCompare(daemonLabel(right.record)))) {
+      const scope = result.record.scope?.type || (result.record.instanceId === "global" ? "global" : "chat");
+      lines.push(...wrapReportText(`${result.record.toolName} [${scope}]`, { firstPrefix: "  - ", nextPrefix: "    " }));
+    }
+  }
+  return lines;
 }
 
 function formatTokenCount(tokens) {
@@ -123,6 +150,24 @@ function formatUptime(seconds) {
   return [days ? `${days}d` : "", hours ? `${hours}h` : "", `${minutes}m`].filter(Boolean).join(" ");
 }
 
+function masterSlaveMode(infrastructure) {
+  const parts = [infrastructure.role || "unknown", infrastructure.daemon?.state || "unknown"];
+  if (infrastructure.paired != null) parts.push(infrastructure.paired ? "paired" : "unpaired");
+  return parts.join(" · ");
+}
+
+function masterSlaveActivity(jobs) {
+  const active = jobs?.active;
+  const queued = jobs?.queued;
+  const failed = jobs?.failed;
+  if ([active, queued, failed].every((value) => value === 0)) return "idle";
+  return `${active ?? "?"} active · ${queued ?? "?"} queued · ${failed ?? "?"} failed`;
+}
+
+function compactEndpoint(endpoint) {
+  return String(endpoint || "not configured").replace(/^tcp:\/\//, "");
+}
+
 export async function inspectSystemResources({ diskPath = arisaHomeDir } = {}) {
   const [load1, load5, load15] = os.loadavg();
   const memoryTotal = os.totalmem();
@@ -221,22 +266,18 @@ export function formatDoctorReport(report) {
   lines.push(...reportRow("Large", large));
   lines.push(...reportRow("Ineff.", inefficient));
   if (measured.length) lines.push(...reportRow("Max", `${Math.max(...measured.map((context) => context.percent)).toFixed(1)}%`));
-  lines.push("", "Daemons");
-  lines.push(...reportRow("Checked", report.daemons.length));
-  if (report.daemons.length) lines.push(...reportRow("Status", daemonResultSummary(report.daemons)));
+  lines.push("", `Daemons (${report.daemons.length})`);
+  if (report.daemons.length) lines.push(...daemonReportLines(report.daemons));
   if (report.infrastructure) {
     lines.push("", "Master/Slave");
     if (report.infrastructure.error) {
       lines.push(...reportRow("Status", `unavailable: ${report.infrastructure.error}`));
     } else {
-      lines.push(...reportRow("Role", report.infrastructure.role || "unknown"));
-      lines.push(...reportRow("Daemon", report.infrastructure.daemon?.state || "unknown"));
-      lines.push(...reportRow("Endpoint", report.infrastructure.endpoint || "not configured"));
-      lines.push(...reportRow("Identity", report.infrastructure.identityFingerprint || "not configured"));
-      lines.push(...reportRow("Paired", report.infrastructure.paired == null ? "n/a" : report.infrastructure.paired ? "yes" : "no"));
+      lines.push(...reportRow("Mode", masterSlaveMode(report.infrastructure)));
+      lines.push(...reportRow("Endpoint", compactEndpoint(report.infrastructure.endpoint)));
+      lines.push(...reportRow("Activity", masterSlaveActivity(report.infrastructure.jobs)));
       lines.push(...reportRow("Tools", report.infrastructure.toolCount ?? "unknown"));
-      lines.push(...reportRow("Jobs", `active=${report.infrastructure.jobs?.active ?? "unknown"}, queued=${report.infrastructure.jobs?.queued ?? "unknown"}, failed=${report.infrastructure.jobs?.failed ?? "unknown"}`));
-      lines.push(...reportRow("Pending secrets", report.infrastructure.pendingSecrets ?? "unknown"));
+      lines.push(...reportRow("Secrets", `${report.infrastructure.pendingSecrets ?? "unknown"} pending`));
     }
   }
   if (report.system) {
@@ -273,7 +314,8 @@ export async function runDoctor({
   stopDaemon = stopManagedDaemon,
   unregisterDaemon = unregisterManagedDaemon,
   inspectResources = inspectSystemResources,
-  inspectInfrastructure = null
+  inspectInfrastructure = null,
+  inspectToolDependencies = null
 }) {
   assertDoctorPolicy(doctorPolicy);
   const runtime = await agentManager.getRuntimeDiagnostic({
@@ -290,6 +332,16 @@ export async function runDoctor({
     infrastructure: null
   };
   addContextAttention(report);
+  if (inspectToolDependencies) {
+    try {
+      for (const issue of await inspectToolDependencies()) {
+        const installed = issue.installedVersion ? `; installed ${issue.installedVersion}` : "";
+        report.attention.push(`Tool dependency ${issue.type}: ${issue.tool} requires ${issue.dependency}@${issue.range || "valid"}${installed}.`);
+      }
+    } catch (error) {
+      report.attention.push(`Tool dependency inspection failed: ${error?.message || error}`);
+    }
+  }
   if (inspectInfrastructure) {
     try {
       report.infrastructure = await inspectInfrastructure();

package/src/runtime/tool-usage-report.js

@@ -1,18 +1,33 @@
 import { renderTextReport } from "./report-format.js";
 
-export function formatToolUsageReport(tools) {
-  const lines = ["Arisa tools", "===========", "Usage count"];
-  if (!tools.length) lines.push("  (none installed)");
-
-  const sortedTools = [...tools].sort((left, right) =>
+function sortedTools(tools) {
+  return [...tools].sort((left, right) =>
     Number(right.count) - Number(left.count) || String(left.name).localeCompare(String(right.name))
   );
-  const nameWidth = Math.max(0, ...sortedTools.map((tool) => String(tool.name).length));
-  const countWidth = Math.max(1, ...sortedTools.map((tool) => String(tool.count).length));
-  for (const tool of sortedTools) {
+}
+
+function usageRows(tools, nameWidth, countWidth) {
+  if (!tools.length) return ["  (none)"];
+  return sortedTools(tools).map((tool) => {
     const name = String(tool.name).padEnd(nameWidth);
     const count = String(tool.count).padStart(countWidth);
-    lines.push(`- ${name}  ${count}`);
-  }
+    return `- ${name}  ${count}`;
+  });
+}
+
+export function formatToolUsageReport(tools) {
+  const official = tools.filter((tool) => tool.official);
+  const local = tools.filter((tool) => !tool.official);
+  const nameWidth = Math.max(0, ...tools.map((tool) => String(tool.name).length));
+  const countWidth = Math.max(1, ...tools.map((tool) => String(tool.count).length));
+  const lines = [
+    "Arisa tools",
+    "===========",
+    "Official",
+    ...usageRows(official, nameWidth, countWidth),
+    "",
+    "Local",
+    ...usageRows(local, nameWidth, countWidth)
+  ];
   return renderTextReport(lines);
 }

package/src/transport/telegram/bot.js

@@ -435,16 +435,30 @@ function sanitizeSessionHandoff(text) {
   return `${sanitized.slice(0, 3997).trim()}...`;
 }
 
-async function withTyping(ctx, work) {
-  await ctx.api.sendChatAction(ctx.chat.id, "typing");
+export async function startTelegramTyping(ctx) {
+  await ctx.api.sendChatAction(ctx.chat.id, "typing").catch(() => {});
   const timer = setInterval(() => {
     ctx.api.sendChatAction(ctx.chat.id, "typing").catch(() => {});
   }, 4000);
+  return () => clearInterval(timer);
+}
+
+export async function ensureQueuedTelegramTyping(chatState, ctx) {
+  if (chatState.stopQueuedTyping) return;
+  chatState.stopQueuedTyping = await startTelegramTyping(ctx);
+}
 
+export function stopQueuedTelegramTyping(chatState) {
+  chatState.stopQueuedTyping?.();
+  chatState.stopQueuedTyping = null;
+}
+
+async function withTyping(ctx, work) {
+  const stopTyping = await startTelegramTyping(ctx);
   try {
     return await work();
   } finally {
-    clearInterval(timer);
+    stopTyping();
   }
 }
 
@@ -460,7 +474,8 @@ export function createChatStateStore() {
       beforeNextPrompt: null,
       activeSession: null,
       activeSteers: [],
-      assistantMessages: new Map()
+      assistantMessages: new Map(),
+      stopQueuedTyping: null
     };
     states.set(String(chatId), state);
     return state;
@@ -559,6 +574,7 @@ export async function drainChatPromptQueue({
       chatState.continueAfterClose = false;
     }
   } finally {
+    stopQueuedTelegramTyping(chatState);
     chatState.processing = false;
     chatState.activeSession = null;
     chatState.activeSteers = [];
@@ -1069,6 +1085,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     const chatState = getChatState(ctx.chat.id);
 
     if (chatState.processing) {
+      await ensureQueuedTelegramTyping(chatState, ctx);
       const incomingPrompt = await buildIncomingPrompt(ctx);
       const busyMessageMode = typeof ctx.message?.text === "string"
         ? resolveTelegramBusyMessageMode(config, ctx.chat.id)
@@ -1115,6 +1132,13 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     timer.unref?.();
   }
 
+  async function enqueueAsyncPrompt({ chatId, prompt, label }) {
+    const ctx = { chat: { id: chatId }, api: bot.api };
+    const chatState = getChatState(chatId);
+    if (chatState.processing) await ensureQueuedTelegramTyping(chatState, ctx);
+    return enqueuePrompt({ chatId, prompt, label, ctx });
+  }
+
   async function dispatchTask(task) {
     const chatId = task.payload?.chatId;
     if (!chatId) {
@@ -1128,7 +1152,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
         return;
       }
       logger?.log("tasks", `running task ${task.id} for chat ${chatId}`);
-      await enqueuePrompt({
+      await enqueueAsyncPrompt({
         chatId,
         prompt: await buildAsyncTaskPrompt({ task, artifactStore, toolRegistry, resourceNotes, logger }),
         label: `scheduled task ${task.id}`
@@ -1139,7 +1163,15 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
 
     if (task.kind === "agent_event") {
       logger?.log("tasks", `agent event ${task.id} for chat ${chatId}`);
-      await enqueuePrompt({
+      const acknowledgement = String(task.payload?.acknowledgement || "").trim();
+      if (acknowledgement) {
+        try {
+          await bot.api.sendMessage(chatId, acknowledgement);
+        } catch (error) {
+          logger?.log("telegram", `agent event acknowledgement failed for chat ${chatId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      await enqueueAsyncPrompt({
         chatId,
         prompt: await buildAsyncEventPrompt(task, resourceNotes),
         label: `agent event ${task.id}`

package/test/capabilities-security.test.js

@@ -142,6 +142,27 @@ test("requires chatId for chat-scoped IPC methods", async () => {
   }
 });
 
+test("agent events preserve a bounded immediate acknowledgement", async () => {
+  const capabilities = createCapabilities();
+  const created = await capabilities.dispatch({
+    method: "agent.enqueueEvent",
+    toolName: "browser-session-bridge",
+    chatId: "chat-a",
+    params: {
+      prompt: "Continue the pending authorization flow",
+      acknowledgement: "Authorization received. Continuing now."
+    }
+  });
+
+  assert.equal(created.payload.acknowledgement, "Authorization received. Continuing now.");
+  await assert.rejects(() => capabilities.dispatch({
+    method: "agent.enqueueEvent",
+    toolName: "browser-session-bridge",
+    chatId: "chat-a",
+    params: { prompt: "Continue", acknowledgement: "x".repeat(501) }
+  }), /at most 500 characters/);
+});
+
 test("delivers only artifacts resolved from the requesting chat", async () => {
   const artifact = { id: "artifact-1", chatId: "chat-a", path: "/safe/chat-a/file.txt" };
   const deliveries = [];

package/test/context-and-task-bounds.test.js

@@ -4,13 +4,38 @@ import {
   collectText,
   createChatStateStore,
   drainChatPromptQueue,
+  ensureQueuedTelegramTyping,
   isSilentReply,
   queueChatPrompt,
   resolveTelegramBusyMessageMode,
-  routeBusyPrompt
+  routeBusyPrompt,
+  stopQueuedTelegramTyping
 } from "../src/transport/telegram/bot.js";
 import { selectScheduledTasks } from "../src/core/agent/agent-manager.js";
 
+test("queued Telegram prompts start typing immediately and share one indicator", async () => {
+  let actions = 0;
+  const chatState = { stopQueuedTyping: null };
+  const ctx = {
+    chat: { id: 879964957 },
+    api: {
+      async sendChatAction(chatId, action) {
+        assert.equal(chatId, 879964957);
+        assert.equal(action, "typing");
+        actions += 1;
+      }
+    }
+  };
+
+  await ensureQueuedTelegramTyping(chatState, ctx);
+  await ensureQueuedTelegramTyping(chatState, ctx);
+  assert.equal(actions, 1);
+  assert.equal(typeof chatState.stopQueuedTyping, "function");
+
+  stopQueuedTelegramTyping(chatState);
+  assert.equal(chatState.stopQueuedTyping, null);
+});
+
 function createSession(events) {
   const listeners = new Set();
   return {
@@ -134,7 +159,8 @@ test("chat state uses one queue for numeric and string chat IDs", () => {
     beforeNextPrompt: null,
     activeSession: null,
     activeSteers: [],
-    assistantMessages: new Map()
+    assistantMessages: new Map(),
+    stopQueuedTyping: null
   });
 });
 

package/test/doctor.test.js

@@ -87,6 +87,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({

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

@@ -0,0 +1,23 @@
+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("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/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), []);
+});

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

@@ -104,6 +104,7 @@ test("loads and lists installed tools from the user tools directory", async () =
     version: null,
     packageDigest: null,
     requirements: [],
+    toolDependencies: {},
     description: "Fake test tool",
     input: ["text/plain"],
     output: ["text/plain"],
@@ -144,6 +145,23 @@ test("shows semantic metadata in tool help", async () => {
   assert.match(help, /Assigned skills:/);
 });
 
+test("reports dependency status in help and blocks a tool with a missing dependency", async () => {
+  await resetHome();
+  await createFakeTool("dependent-tool", {
+    version: "1.0.0",
+    toolDependencies: { "base-tool": "^1.0.0" }
+  });
+
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  assert.match(await registry.help("dependent-tool"), /base-tool@\^1\.0\.0: missing/);
+  await assert.rejects(
+    () => registry.run({ name: "dependent-tool", request: { args: {} } }),
+    /Tool dependency missing/
+  );
+});
+
 test("runs a registered tool process with an enriched request and cleans up request files", async () => {
   await resetHome();
   await createFakeTool("fake-tool");
@@ -178,7 +196,7 @@ test("runs a registered tool process with an enriched request and cleans up requ
   });
   assert.equal(result.output.env.ARISA_PACKAGE_DIR, arisaPackageDir);
   assert.equal(result.output.env.ARISA_IPC_SOCKET, arisaIpcSocketFile);
-  assert.deepEqual(await registry.usage("chat-1"), [{ name: "fake-tool", count: 1 }]);
+  assert.deepEqual(await registry.usage("chat-1"), [{ name: "fake-tool", count: 1, official: false }]);
 
   const requestFile = result.output.requestFile;
   await assert.rejects(() => access(requestFile), { code: "ENOENT" });

package/test/tool-usage.test.js

@@ -3,6 +3,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
+import { ToolRegistry } from "../src/core/tools/tool-registry.js";
 import { ToolUsageStore } from "../src/core/tools/tool-usage-store.js";
 import { formatToolUsageReport } from "../src/runtime/tool-usage-report.js";
 
@@ -26,16 +27,37 @@ test("counts concurrent tool uses per chat", async () => {
   }
 });
 
+test("reports recorded usage for local tools not present in the startup registry", async () => {
+  const registry = new ToolRegistry({
+    usageStore: {
+      counts: async () => ({ "creator-scout": 4 })
+    },
+    resolveOfficialToolNames: async () => new Set(["gmail-workspace"])
+  });
+  registry.tools.set("gmail-workspace", {
+    name: "gmail-workspace",
+    input: ["application/json"],
+    output: ["application/json"]
+  });
+
+  assert.deepEqual(await registry.usage("chat-1"), [
+    { name: "creator-scout", count: 4, official: false },
+    { name: "gmail-workspace", count: 0, official: true }
+  ]);
+});
+
 test("formats narrow tool usage counts with bullets and right-aligned numbers", () => {
   const report = formatToolUsageReport([
-    { name: "gmail-workspace", count: 3 },
-    { name: "campaign-draft-runner", count: 12 }
+    { name: "gmail-workspace", count: 3, official: true },
+    { name: "campaign-draft-runner", count: 12, official: false }
   ]);
+  assert.match(report, /Official\n- gmail-workspace/);
+  assert.match(report, /Local\n- campaign-draft-runner/);
   assert.match(report, /- campaign-draft-runner  12/);
   assert.match(report, /- gmail-workspace\s+3/);
   const rows = report.split("\n").filter((line) => line.startsWith("- "));
-  assert.match(rows[0], /campaign-draft-runner/);
-  assert.match(rows[1], /gmail-workspace/);
+  assert.match(rows[0], /gmail-workspace/);
+  assert.match(rows[1], /campaign-draft-runner/);
   assert.deepEqual(rows.map((line) => line.match(/\d+$/).index + line.match(/\d+$/)[0].length), [27, 27]);
   assert.deepEqual(rows.map((line) => line.length), [27, 27]);
   assert.ok(report.split("\n").every((line) => [...line].length <= 35));