arisa 5.0.2 → 5.1.4

package/AGENTS.md

@@ -49,9 +49,10 @@ Each tool declares in `tool.manifest.json`:
 - `skillHints`: optional skills to apply when using or editing the tool
 
 ## Text encoding
-All textual content generated or sent by Arisa or its tools must use UTF-8. This includes text files, assistant-created attachments, tool exports, email bodies, messages, HTTP responses, and API payloads.
+All textual content generated or sent by Arisa or its tools must use UTF-8.
 
-- Text files must start with a UTF-8 byte-order mark (BOM).
+- User-facing text documents and exports in `.txt`, `.md`, or `.csv` format must start with a UTF-8 byte-order mark (BOM).
+- Source code, repository documentation, configuration, manifests, and structured data must use UTF-8 without BOM.
 - Protocol payloads must declare UTF-8 through the protocol's standard mechanism and encode their bytes as UTF-8. For example, email and HTTP text content must use a `Content-Type` with `charset=UTF-8`.
 
 ## Tool-to-Arisa IPC

package/README.md

@@ -114,14 +114,14 @@ Automatic context compaction uses Pi's native implementation and can be tuned in
   "pi": {
     "compaction": {
       "enabled": true,
-      "reserveTokens": 16384,
+      "reserveTokens": 120000,
       "keepRecentTokens": 20000
     }
   }
 }
 ```
 
-Pi compacts when the context exceeds the model's context window minus `reserveTokens`. Arisa does not add Telegram commands or compaction notifications.
+Pi compacts when the context exceeds the model's context window minus `reserveTokens`. The default keeps a large reserve so compaction occurs before Arisa Doctor's context warning on the default model. Set a smaller reserve when using models with substantially smaller context windows. Arisa does not add Telegram commands or compaction notifications.
 
 ## Install globally
 

package/package.json

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

package/src/core/config/config-defaults.js

@@ -43,7 +43,7 @@ export const piConfigDefaults = Object.freeze({
   speed: 1,
   compaction: Object.freeze({
     enabled: true,
-    reserveTokens: 16_384,
+    reserveTokens: 120_000,
     keepRecentTokens: 20_000
   })
 });

package/src/core/tools/tool-registry.js

@@ -1,11 +1,13 @@
 import { mkdir, readdir, readFile, rmdir, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { arisaIpcSocketFile, arisaPackageDir, getToolConfigPath, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
 import { loadToolConfig, parseConfigModule, writeToolConfig } from "./tool-config.js";
 import { normalizeToolResult } from "./tool-result.js";
 import { readDaemonDiagnostic } from "./daemon-processes.js";
 import { SkillRegistry } from "../skills/skill-registry.js";
+import { ToolUsageStore } from "./tool-usage-store.js";
 
 function toolEnv() {
   return { ...process.env, ARISA_PACKAGE_DIR: arisaPackageDir, ARISA_IPC_SOCKET: arisaIpcSocketFile };
@@ -45,10 +47,11 @@ function formatSemanticMetadata(tool) {
 }
 
 export class ToolRegistry {
-  constructor({ logger } = {}) {
+  constructor({ logger, usageStore = new ToolUsageStore() } = {}) {
     this.logger = logger;
     this.tools = new Map();
     this.skillRegistry = new SkillRegistry();
+    this.usageStore = usageStore;
   }
 
   async load() {
@@ -193,13 +196,23 @@ export class ToolRegistry {
     return { ok: true, tool: name, field, configPath };
   }
 
+  async usage(chatId) {
+    const counts = await this.usageStore.counts(chatId);
+    return this.list()
+      .map((tool) => ({ name: tool.name, count: counts[tool.name] || 0 }))
+      .sort((left, right) => left.name.localeCompare(right.name));
+  }
+
   async run({ name, request, chatId = null }) {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
+    await this.usageStore.record(chatId, name).catch((error) => {
+      this.logger?.error("tools", `could not record ${name} usage: ${error?.message || String(error)}`);
+    });
     this.logger?.log("tools", `running ${name}`);
     const tmpDir = chatId != null ? getChatToolTmpDir(chatId, name) : getToolTmpDir(name);
     await mkdir(tmpDir, { recursive: true });
-    const requestFile = path.join(tmpDir, `.request-${Date.now()}.json`);
+    const requestFile = path.join(tmpDir, `.request-${Date.now()}-${randomUUID()}.json`);
     const skills = await this.resolveSkills(name);
     const enrichedRequest = { ...request, chatId, skills };
     await writeFile(requestFile, `${JSON.stringify(enrichedRequest, null, 2)}\n`, "utf8");

package/src/core/tools/tool-usage-store.js

@@ -0,0 +1,59 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getChatToolUsageFile } from "../../runtime/paths.js";
+
+function emptyUsage() {
+  return { version: 1, tools: {} };
+}
+
+async function readUsage(file) {
+  try {
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    return parsed?.version === 1 && parsed.tools && typeof parsed.tools === "object"
+      ? parsed
+      : emptyUsage();
+  } catch (error) {
+    if (error?.code === "ENOENT") return emptyUsage();
+    throw error;
+  }
+}
+
+async function writeUsage(file, usage) {
+  await mkdir(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(usage, null, 2)}\n`, "utf8");
+  await rename(temporary, file);
+}
+
+export class ToolUsageStore {
+  constructor({ resolveFile = getChatToolUsageFile } = {}) {
+    this.resolveFile = resolveFile;
+    this.queues = new Map();
+  }
+
+  async record(chatId, toolName) {
+    if (chatId == null || chatId === "") return;
+    const key = String(chatId);
+    const previous = this.queues.get(key) || Promise.resolve();
+    const current = previous.catch(() => {}).then(async () => {
+      const file = this.resolveFile(chatId);
+      const usage = await readUsage(file);
+      const count = Number(usage.tools[toolName]?.count) || 0;
+      usage.tools[toolName] = { count: count + 1 };
+      await writeUsage(file, usage);
+    });
+    this.queues.set(key, current);
+    try {
+      await current;
+    } finally {
+      if (this.queues.get(key) === current) this.queues.delete(key);
+    }
+  }
+
+  async counts(chatId) {
+    if (chatId == null || chatId === "") return {};
+    await (this.queues.get(String(chatId)) || Promise.resolve()).catch(() => {});
+    const usage = await readUsage(this.resolveFile(chatId));
+    return Object.fromEntries(Object.entries(usage.tools).map(([name, value]) => [name, Number(value?.count) || 0]));
+  }
+}

package/src/runtime/create-app.js

@@ -11,6 +11,7 @@ import { createIpcServer } from "./ipc/ipc-server.js";
 import { getAgentConfig } from "../core/agent/model-selection.js";
 import { normalizeModelSpeed } from "../core/agent/model-speed.js";
 import { runDoctor } from "./doctor.js";
+import { checkForUpdates, formatUpdateReport } from "./update-manager.js";
 
 function normalizeString(value) {
   const text = String(value ?? "").trim();
@@ -136,6 +137,7 @@ export async function createApp({ logger, runtimeOverrides, requestRestart } = {
       doctorPolicy: config.doctor,
       logger
     }),
+    checkUpdates: async (chatId) => formatUpdateReport(await checkForUpdates({ chatId, toolRegistry })),
     requestRestart,
     logger
   });

package/src/runtime/doctor.js

@@ -1,8 +1,12 @@
 import { execFile } from "node:child_process";
+import { statfs } from "node:fs/promises";
+import os from "node:os";
 import process from "node:process";
 import { promisify } from "node:util";
 import { stopManagedDaemon, unregisterManagedDaemon } from "../core/tools/daemon-processes.js";
 import { getServiceStatus, serviceEntryFile } from "./service-manager.js";
+import { arisaHomeDir } from "./paths.js";
+import { renderTextReport, reportRow, wrapReportText } from "./report-format.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -99,6 +103,49 @@ function formatTokenCount(tokens) {
   return new Intl.NumberFormat("en-US", { maximumFractionDigits: 0 }).format(tokens);
 }
 
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) return "unknown";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let index = 0;
+  while (value >= 1024 && index < units.length - 1) {
+    value /= 1024;
+    index += 1;
+  }
+  return `${value.toFixed(index < 2 ? 0 : 1)} ${units[index]}`;
+}
+
+function formatUptime(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "unknown";
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  return [days ? `${days}d` : "", hours ? `${hours}h` : "", `${minutes}m`].filter(Boolean).join(" ");
+}
+
+export async function inspectSystemResources({ diskPath = arisaHomeDir } = {}) {
+  const [load1, load5, load15] = os.loadavg();
+  const memoryTotal = os.totalmem();
+  const memoryFree = os.freemem();
+  const filesystem = await statfs(diskPath);
+  const blockSize = Number(filesystem.bsize);
+  const diskTotal = Number(filesystem.blocks) * blockSize;
+  const diskFree = Number(filesystem.bavail) * blockSize;
+  return {
+    platform: `${os.platform()} ${os.arch()}`,
+    cpuCores: os.cpus().length,
+    loadAverage: [load1, load5, load15],
+    memoryTotal,
+    memoryFree,
+    memoryUsed: memoryTotal - memoryFree,
+    diskTotal,
+    diskFree,
+    diskUsed: diskTotal - diskFree,
+    uptimeSeconds: os.uptime(),
+    processRss: process.memoryUsage().rss
+  };
+}
+
 function assertDoctorPolicy(policy) {
   const positiveValues = [
     "contextInspectionTimeoutMs",
@@ -138,25 +185,6 @@ function evaluateContext(context, policy) {
   return { ...context, level, inefficiencies };
 }
 
-function contextSummary(contexts) {
-  if (!contexts.length) return "Contexts: no active contexts.";
-  const measured = contexts.filter((context) => Number.isFinite(context.percent));
-  const oversized = contexts.filter((context) => context.level === "warning" || context.level === "critical").length;
-  const inefficient = contexts.filter((context) => context.inefficiencies.length).length;
-  const unavailable = contexts.length - measured.length;
-  const details = [
-    `${contexts.length} active`,
-    `${measured.length} measured`,
-    `${oversized} large`,
-    `${inefficient} inefficient`
-  ];
-  if (unavailable) details.push(`${unavailable} unavailable`);
-  if (measured.length) {
-    details.push(`max ${Math.max(...measured.map((context) => context.percent)).toFixed(1)}%`);
-  }
-  return `Contexts: ${details.join(", ")}.`;
-}
-
 function addContextAttention(report) {
   for (const context of report.contexts) {
     const label = `Chat ${context.chatId}`;
@@ -181,20 +209,41 @@ export function formatDoctorReport(report) {
   const status = report.attention.length
     ? "attention needed"
     : report.repairs.length ? "repaired" : "healthy";
-  const lines = [
-    `Arisa Doctor: ${status}`,
-    `Core: Pi, ${report.runtime.sessions} active session(s), ${report.runtime.closingSessions} closing.`,
-    contextSummary(report.contexts),
-    `Daemons: ${report.daemons.length} checked${report.daemons.length ? ` (${daemonResultSummary(report.daemons)})` : ""}.`
-  ];
-  if (!report.repairs.length) lines.push("Processes: no unnecessary managed processes found.");
-  if (report.repairs.length) {
-    lines.push("", "Repairs:", ...report.repairs.map((item) => `- ${item}`));
+  const measured = report.contexts.filter((context) => Number.isFinite(context.percent));
+  const large = report.contexts.filter((context) => context.level === "warning" || context.level === "critical").length;
+  const inefficient = report.contexts.filter((context) => context.inefficiencies.length).length;
+  const lines = ["Arisa Doctor", "============"];
+  lines.push(...reportRow("Status", status));
+  lines.push("", "Core");
+  lines.push(...reportRow("Runtime", "Pi"));
+  lines.push(...reportRow("Sessions", `${report.runtime.sessions} active / ${report.runtime.closingSessions} closing`));
+  lines.push(...reportRow("Contexts", `${report.contexts.length} active / ${measured.length} measured`));
+  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)));
+  if (report.system) {
+    const memoryPercent = report.system.memoryTotal ? (report.system.memoryUsed / report.system.memoryTotal) * 100 : 0;
+    const diskPercent = report.system.diskTotal ? (report.system.diskUsed / report.system.diskTotal) * 100 : 0;
+    lines.push("", "System");
+    lines.push(...reportRow("Host", report.system.platform));
+    lines.push(...reportRow("Uptime", formatUptime(report.system.uptimeSeconds)));
+    lines.push(...reportRow("CPU", `${report.system.cpuCores} cores`));
+    lines.push(...reportRow("Load", report.system.loadAverage.map((value) => value.toFixed(2)).join(" / ")));
+    lines.push(...reportRow("Memory", `${memoryPercent.toFixed(1)}% / ${formatBytes(report.system.memoryFree)} free`));
+    lines.push(...reportRow("Disk", `${diskPercent.toFixed(1)}% / ${formatBytes(report.system.diskFree)} free`));
+    lines.push(...reportRow("Arisa RSS", formatBytes(report.system.processRss)));
+  } else if (report.systemError) {
+    lines.push("", "System");
+    lines.push(...reportRow("Status", `unavailable: ${report.systemError}`));
   }
-  if (report.attention.length) {
-    lines.push("", "Attention:", ...report.attention.map((item) => `- ${item}`));
-  }
-  return lines.join("\n");
+  lines.push("", `Repairs (${report.repairs.length})`);
+  for (const item of report.repairs) lines.push(...wrapReportText(item, { firstPrefix: "  - ", nextPrefix: "    " }));
+  lines.push("", `Attention (${report.attention.length})`);
+  for (const item of report.attention) lines.push(...wrapReportText(item, { firstPrefix: "  - ", nextPrefix: "    " }));
+  return renderTextReport(lines);
 }
 
 export async function runDoctor({
@@ -207,7 +256,8 @@ export async function runDoctor({
   stopProcess = terminateProcess,
   serviceStatus = getServiceStatus,
   stopDaemon = stopManagedDaemon,
-  unregisterDaemon = unregisterManagedDaemon
+  unregisterDaemon = unregisterManagedDaemon,
+  inspectResources = inspectSystemResources
 }) {
   assertDoctorPolicy(doctorPolicy);
   const runtime = await agentManager.getRuntimeDiagnostic({
@@ -218,9 +268,17 @@ export async function runDoctor({
     contexts: runtime.contexts.map((context) => evaluateContext(context, doctorPolicy)),
     daemons: [],
     repairs: [],
-    attention: []
+    attention: [],
+    system: null,
+    systemError: null
   };
   addContextAttention(report);
+  try {
+    report.system = await inspectResources();
+  } catch (error) {
+    report.systemError = error?.message || String(error);
+    report.attention.push(`System resource inspection failed: ${report.systemError}`);
+  }
   let processes = [];
   try {
     processes = await listProcesses({ timeoutMs: daemonPolicy.healthTimeoutMs });

package/src/runtime/paths.js

@@ -43,6 +43,10 @@ export function getChatConversationHistoryFile(chatId) {
   return path.join(getChatDir(chatId), "state", "conversation.jsonl");
 }
 
+export function getChatToolUsageFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "tool-usage.json");
+}
+
 export function getChatToolStateDir(chatId, toolName) {
   return path.join(getChatDir(chatId), "state", "tools", toolName);
 }

package/src/runtime/report-format.js

@@ -0,0 +1,51 @@
+export const reportWidth = 35;
+
+function splitLongWord(word, width) {
+  const parts = [];
+  for (let index = 0; index < word.length; index += width) parts.push(word.slice(index, index + width));
+  return parts;
+}
+
+export function wrapReportText(text, { firstPrefix = "", nextPrefix = firstPrefix } = {}) {
+  const words = String(text ?? "").trim().split(/\s+/).filter(Boolean);
+  if (!words.length) return [firstPrefix.trimEnd()];
+  const lines = [];
+  let prefix = firstPrefix;
+  let content = "";
+  for (const originalWord of words) {
+    const width = Math.max(1, reportWidth - prefix.length);
+    const parts = originalWord.length > width ? splitLongWord(originalWord, width) : [originalWord];
+    for (const word of parts) {
+      if (content && content.length + 1 + word.length > width) {
+        lines.push(prefix + content);
+        prefix = nextPrefix;
+        content = "";
+      }
+      if (!content && word.length > Math.max(1, reportWidth - prefix.length)) {
+        const fragments = splitLongWord(word, Math.max(1, reportWidth - prefix.length));
+        lines.push(prefix + fragments.shift());
+        prefix = nextPrefix;
+        content = fragments.join("");
+      } else {
+        content += `${content ? " " : ""}${word}`;
+      }
+    }
+  }
+  if (content) lines.push(prefix + content);
+  return lines;
+}
+
+export function reportRow(label, value, { indent = "  ", labelWidth = 10 } = {}) {
+  const firstPrefix = `${indent}${String(label).padEnd(labelWidth)} `;
+  return wrapReportText(value, {
+    firstPrefix,
+    nextPrefix: " ".repeat(firstPrefix.length)
+  });
+}
+
+export function renderTextReport(lines) {
+  for (const line of lines) {
+    if ([...line].length > reportWidth) throw new Error(`Report line exceeds ${reportWidth} characters: ${line}`);
+  }
+  return `\`\`\`text\n${lines.join("\n")}\n\`\`\``;
+}

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

@@ -0,0 +1,18 @@
+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) =>
+    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) {
+    const name = String(tool.name).padEnd(nameWidth);
+    const count = String(tool.count).padStart(countWidth);
+    lines.push(`- ${name}  ${count}`);
+  }
+  return renderTextReport(lines);
+}

package/src/runtime/update-manager.js

@@ -0,0 +1,206 @@
+import { spawn } from "node:child_process";
+import { access, cp, mkdir, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { arisaPackageDir, getToolDir } from "./paths.js";
+import { renderTextReport, reportRow, wrapReportText } from "./report-format.js";
+
+const defaultRepoUrl = "https://github.com/clasen/Arisa.git";
+const defaultBranch = "main";
+const bootstrapToolNames = ["trash", "official-tool-sync"];
+
+function exists(target) {
+  return access(target).then(() => true, () => false);
+}
+
+function runCommand(command, args, { cwd, timeoutMs = 300_000, env = process.env } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    child.stdout.on("data", (chunk) => { stdout += chunk.toString("utf8"); });
+    child.stderr.on("data", (chunk) => { stderr += chunk.toString("utf8"); });
+    child.once("error", (error) => { clearTimeout(timer); reject(error); });
+    child.once("close", (code, signal) => {
+      clearTimeout(timer);
+      if (code === 0) resolve({ stdout, stderr });
+      else reject(new Error(`${command} ${args.join(" ")} failed (${signal || code}): ${(stderr || stdout).trim().slice(-2000)}`));
+    });
+  });
+}
+
+function parseSemver(value) {
+  const match = String(value || "").trim().replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+  return match ? match.slice(1).map(Number) : null;
+}
+
+export function compareVersions(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  if (!a || !b) return null;
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
+  }
+  return 0;
+}
+
+async function readCurrentVersion() {
+  const packageJson = JSON.parse(await readFile(path.join(arisaPackageDir, "package.json"), "utf8"));
+  return packageJson.version;
+}
+
+async function fetchLatestVersion() {
+  const { stdout } = await runCommand("npm", ["view", "arisa", "version", "--json"], { timeoutMs: 60_000 });
+  const parsed = JSON.parse(stdout);
+  const version = Array.isArray(parsed) ? parsed.at(-1) : parsed;
+  if (!parseSemver(version)) throw new Error(`npm returned an invalid Arisa version: ${version}`);
+  return version;
+}
+
+async function cloneCatalog(scratchRoot) {
+  const repoDir = path.join(scratchRoot, "repo");
+  await runCommand("git", ["clone", "--depth", "1", "--branch", defaultBranch, "--", defaultRepoUrl, repoDir], { cwd: scratchRoot, timeoutMs: 180_000 });
+  return repoDir;
+}
+
+async function installDependencies(toolDir) {
+  if (!(await exists(path.join(toolDir, "package.json")))) return null;
+  try {
+    await runCommand("pnpm", ["install", "--lockfile=false"], { cwd: toolDir, timeoutMs: 300_000 });
+    return "pnpm";
+  } catch {
+    await runCommand("npm", ["install", "--no-package-lock"], { cwd: toolDir, timeoutMs: 300_000 });
+    return "npm";
+  }
+}
+
+async function validateTool(toolDir, expectedName) {
+  const manifest = JSON.parse(await readFile(path.join(toolDir, "tool.manifest.json"), "utf8"));
+  if (manifest.name !== expectedName) throw new Error(`Bootstrap manifest mismatch for ${expectedName}`);
+  const entry = manifest.entry || "index.js";
+  const env = { ...process.env, ARISA_PACKAGE_DIR: arisaPackageDir };
+  await runCommand(process.execPath, ["--check", entry], { cwd: toolDir, timeoutMs: 30_000, env });
+  await runCommand(process.execPath, [entry, "--help"], { cwd: toolDir, timeoutMs: 30_000, env });
+}
+
+async function stageBootstrapTool(repoDir, scratchRoot, name) {
+  const sourceDir = path.join(repoDir, "tools", name);
+  const stageDir = path.join(scratchRoot, `stage-${name}`);
+  if (!(await exists(path.join(sourceDir, "tool.manifest.json")))) throw new Error(`Official catalog is missing required bootstrap tool: ${name}`);
+  await cp(sourceDir, stageDir, { recursive: true });
+  await installDependencies(stageDir);
+  await validateTool(stageDir, name);
+  return { name, stageDir, destination: getToolDir(name) };
+}
+
+export async function ensureOfficialUpdateTools({ toolRegistry }) {
+  const missing = bootstrapToolNames.filter((name) => !toolRegistry.get(name));
+  if (!missing.length) return { installed: [] };
+  const scratchRoot = path.join(os.tmpdir(), `arisa-update-${process.pid}-${Date.now()}`);
+  await mkdir(scratchRoot, { recursive: true });
+  const deployed = [];
+  try {
+    const repoDir = await cloneCatalog(scratchRoot);
+    const staged = [];
+    for (const name of missing) staged.push(await stageBootstrapTool(repoDir, scratchRoot, name));
+    for (const item of staged) {
+      await mkdir(path.dirname(item.destination), { recursive: true });
+      await cp(item.stageDir, item.destination, { recursive: true, errorOnExist: true, force: false });
+      deployed.push(item.destination);
+    }
+    await toolRegistry.load();
+    return { installed: staged.map((item) => item.name) };
+  } catch (error) {
+    for (const destination of deployed.reverse()) await rm(destination, { recursive: true, force: true }).catch(() => {});
+    await toolRegistry.load().catch(() => {});
+    throw error;
+  } finally {
+    await rm(scratchRoot, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+function parseToolSyncOutput(result) {
+  if (!result?.ok) throw new Error(result?.error || "official-tool-sync failed");
+  const text = result.output?.text;
+  if (typeof text !== "string") return result.output?.json || {};
+  return JSON.parse(text);
+}
+
+function summarizeTools(sync, installedTools) {
+  const tools = sync.tools || [];
+  const officialNames = new Set(tools.map((tool) => tool.name));
+  const counts = {};
+  for (const tool of tools) counts[tool.status] = (counts[tool.status] || 0) + 1;
+  const updateable = tools.filter((tool) => tool.safeToUpdate && !["up-to-date", "baseline-refresh"].includes(tool.status));
+  const blocked = tools.filter((tool) => !tool.safeToUpdate && !["up-to-date", "baseline-refresh"].includes(tool.status));
+  return {
+    installedOfficial: sync.installedOfficialCount || tools.length,
+    official: tools.map(({ name, status }) => ({ name, status })).sort((left, right) => left.name.localeCompare(right.name)),
+    nonOfficial: installedTools.map((tool) => tool.name).filter((name) => !officialNames.has(name)).sort(),
+    counts,
+    updateable: updateable.map((tool) => tool.name),
+    blocked: blocked.map((tool) => ({ name: tool.name, status: tool.status }))
+  };
+}
+
+export async function checkForUpdates({ chatId, toolRegistry }) {
+  const [currentVersion, latestVersion] = await Promise.all([readCurrentVersion(), fetchLatestVersion()]);
+  const bootstrapped = await ensureOfficialUpdateTools({ toolRegistry });
+  const result = await toolRegistry.run({ name: "official-tool-sync", chatId, request: { args: { action: "check" } } });
+  const sync = parseToolSyncOutput(result);
+  return {
+    core: { currentVersion, latestVersion, updateAvailable: compareVersions(currentVersion, latestVersion) === -1 },
+    bootstrapInstalled: bootstrapped.installed,
+    tools: summarizeTools(sync, toolRegistry.list())
+  };
+}
+
+function shortToolStatus(status) {
+  return ({
+    "locally-modified": "local",
+    "untracked-difference": "untracked",
+    "update-available": "update",
+    "baseline-refresh": "refresh",
+    "up-to-date": "current"
+  })[status] || status;
+}
+
+export function formatUpdateReport(report) {
+  const lines = ["Arisa update", "============", "Core"];
+  lines.push(...reportRow("Current", report.core.currentVersion));
+  lines.push(...reportRow("Latest", report.core.latestVersion));
+  lines.push(...reportRow("Status", report.core.updateAvailable ? "update available" : "up to date"));
+  lines.push("", "Official tools");
+  lines.push(...reportRow("Installed", report.tools.installedOfficial));
+  for (const [status, count] of Object.entries(report.tools.counts)) {
+    lines.push(...reportRow(status, count, { labelWidth: 20 }));
+  }
+  lines.push("", `Official (${report.tools.official.length})`);
+  for (const item of report.tools.official) {
+    const status = shortToolStatus(item.status);
+    const suffix = status === "current" ? "" : ` [${status}]`;
+    lines.push(...wrapReportText(`${item.name}${suffix}`, { firstPrefix: "  - ", nextPrefix: "    " }));
+  }
+  lines.push("", `Non-official (${report.tools.nonOfficial.length})`);
+  if (!report.tools.nonOfficial.length) lines.push("  (none)");
+  for (const name of report.tools.nonOfficial) {
+    lines.push(...wrapReportText(name, { firstPrefix: "  - ", nextPrefix: "    " }));
+  }
+  if (report.tools.updateable.length) {
+    lines.push("", "Safe updates");
+    for (const name of report.tools.updateable) lines.push(...wrapReportText(name, { firstPrefix: "  - ", nextPrefix: "    " }));
+  }
+  if (report.tools.blocked.length) {
+    lines.push("", "Needs review");
+    for (const item of report.tools.blocked) {
+      lines.push(...wrapReportText(item.name, { firstPrefix: "  - ", nextPrefix: "    " }));
+      lines.push(...wrapReportText(`[${shortToolStatus(item.status)}]`, { firstPrefix: "    ", nextPrefix: "    " }));
+    }
+  }
+  if (report.bootstrapInstalled.length) {
+    lines.push("", "Update support installed");
+    for (const name of report.bootstrapInstalled) lines.push(...wrapReportText(name, { firstPrefix: "  - ", nextPrefix: "    " }));
+  }
+  return renderTextReport(lines);
+}

package/src/transport/telegram/bot.js

@@ -14,17 +14,20 @@ import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "..
 import { formatPortableSessionHistory } from "../../core/agent/agent-manager.js";
 import { ConversationHistoryStore } from "../../core/conversation/conversation-history-store.js";
 import { formatDoctorReport } from "../../runtime/doctor.js";
+import { formatToolUsageReport } from "../../runtime/tool-usage-report.js";
 
 const slowPromptNoticeMs = 300_000;
 
 export const telegramCommands = Object.freeze([
-  { command: "new", description: "Start a new chat context" },
-  { command: "restart", description: "Restart the Arisa service" },
-  { command: "doctor", description: "Check and repair Arisa runtime health" },
-  { command: "model", description: "Choose the model for this chat" },
-  { command: "effort", description: "Choose reasoning effort for this chat" },
-  { command: "speed", description: "Choose model speed for this chat" },
-  { command: "auth", description: "Show authentication status" }
+  { command: "new", description: "New chat context" },
+  { command: "restart", description: "Restart Arisa" },
+  { command: "doctor", description: "Check runtime health" },
+  { command: "update", description: "Check for updates" },
+  { command: "tools", description: "Tool usage counts" },
+  { command: "model", description: "Choose chat model" },
+  { command: "effort", description: "Choose reasoning effort" },
+  { command: "speed", description: "Choose model speed" },
+  { command: "auth", description: "Authentication status" }
 ]);
 
 export function createTelegramRestartHandler({ authorize, requestRestart, logger }) {
@@ -95,6 +98,67 @@ function getIncomingMessageText(message) {
   return message?.text || message?.caption || formatLocationText(message) || "";
 }
 
+function telegramDisplayName(entity = {}) {
+  if (entity.username) return `@${entity.username}`;
+  return [entity.first_name, entity.last_name].filter(Boolean).join(" ") || entity.title || "unknown";
+}
+
+function forwardedMessageSummary(message) {
+  const origin = message?.forward_origin;
+  if (!origin) return [];
+
+  const parts = ["forwarded: true", `forwardedOriginType: ${origin.type}`];
+  if (origin.type === "user") parts.push(`forwardedFrom: ${telegramDisplayName(origin.sender_user)}`);
+  if (origin.type === "hidden_user") parts.push(`forwardedFrom: ${origin.sender_user_name}`);
+  if (origin.type === "chat" || origin.type === "channel") {
+    parts.push(`forwardedFrom: ${telegramDisplayName(origin.chat)}`);
+  }
+  if (origin.type === "channel" && origin.message_id) parts.push(`forwardedMessageId: ${origin.message_id}`);
+  if (origin.author_signature) parts.push(`forwardedAuthorSignature: ${origin.author_signature}`);
+  if (origin.date) parts.push(`forwardedAt: ${new Date(origin.date * 1000).toISOString()}`);
+  return parts;
+}
+
+function reactionLabel(reaction = {}) {
+  if (reaction.type === "emoji") return reaction.emoji || "emoji";
+  if (reaction.type === "custom_emoji") return `custom:${reaction.custom_emoji_id || "unknown"}`;
+  if (reaction.type === "paid") return "paid";
+  return reaction.type || "unknown";
+}
+
+function reactionDifference(left = [], right = []) {
+  const remaining = right.map(reactionLabel);
+  return left.map(reactionLabel).filter((label) => {
+    const index = remaining.indexOf(label);
+    if (index < 0) return true;
+    remaining.splice(index, 1);
+    return false;
+  });
+}
+
+export function buildReactionPrompt({ reaction, reactedMessageText = "" }) {
+  const oldReactions = reaction.old_reaction || [];
+  const newReactions = reaction.new_reaction || [];
+  const added = reactionDifference(newReactions, oldReactions);
+  const removed = reactionDifference(oldReactions, newReactions);
+  const actor = reaction.user || reaction.actor_chat || {};
+  const actorId = reaction.user?.id || reaction.actor_chat?.id || "unknown";
+
+  return [
+    "Incoming Telegram reaction.",
+    `chatId: ${reaction.chat.id}`,
+    `userId: ${actorId}`,
+    `username: ${reaction.user?.username || "(no username)"}`,
+    `reactedMessageId: ${reaction.message_id}`,
+    reactedMessageText ? `reactedMessageText: ${reactedMessageText}` : null,
+    added.length ? `addedReactions: ${added.join(" ")}` : null,
+    removed.length ? `removedReactions: ${removed.join(" ")}` : null,
+    `currentReactions: ${newReactions.map(reactionLabel).join(" ") || "none"}`,
+    `actor: ${telegramDisplayName(actor)}`,
+    "Treat this as lightweight feedback on the referenced message. Respond only if the reaction clearly requests action; otherwise stay silent."
+  ].filter(Boolean).join("\n");
+}
+
 function baseMimeType(mimeType = "") {
   return mimeType.split(";")[0].trim().toLowerCase();
 }
@@ -122,6 +186,7 @@ export function buildPrompt({ ctx, artifact, transcript, toolResult }) {
 
   const messageText = getIncomingMessageText(ctx.message);
   if (messageText) parts.push(`text: ${messageText}`);
+  parts.push(...forwardedMessageSummary(ctx.message));
   parts.push(...quotedMessageSummary(ctx.message?.reply_to_message));
   if (shouldIncludeArtifactReference({ artifact, messageText })) {
     if (artifact?.path) parts.push(`artifactPath: ${artifact.path}`);
@@ -363,7 +428,8 @@ export function createChatStateStore() {
       historyRevision: 0,
       beforeNextPrompt: null,
       activeSession: null,
-      activeSteers: []
+      activeSteers: [],
+      assistantMessages: new Map()
     };
     states.set(String(chatId), state);
     return state;
@@ -477,7 +543,7 @@ export async function closeModelPicker(ctx, { messageText, callbackText }) {
   await ctx.answerCallbackQuery({ text: callbackText });
 }
 
-export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, doctor, requestRestart, logger }) {
+export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, doctor, checkUpdates, requestRestart, logger }) {
   const bot = new Bot(config.telegram.token);
   const perChatState = createChatStateStore();
   const conversationHistory = new ConversationHistoryStore();
@@ -810,7 +876,12 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     }
 
     logger?.log("telegram", `sending text reply for chat ${chatId}`);
-    await sendText(renderTelegramHtml(text), { parse_mode: "HTML" });
+    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 createTelegramSessionBridge(chatId) {
@@ -1152,14 +1223,41 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   bot.command("doctor", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
-    await withTyping(ctx, async () => {
-      try {
-        await ctx.reply(formatDoctorReport(await doctor()));
-      } catch (error) {
-        logger?.error("doctor", `doctor command failed: ${getErrorMessage(error)}`);
-        await ctx.reply(`Arisa Doctor failed: ${getErrorMessage(error)}`);
-      }
-    });
+    const pending = await ctx.reply(renderTelegramHtml("```text\nRunning Arisa Doctor…\n```"), { parse_mode: "HTML" });
+    try {
+      await ctx.api.editMessageText(
+        ctx.chat.id,
+        pending.message_id,
+        renderTelegramHtml(formatDoctorReport(await doctor())),
+        { parse_mode: "HTML" }
+      );
+    } catch (error) {
+      logger?.error("doctor", `doctor command failed: ${getErrorMessage(error)}`);
+      await ctx.api.editMessageText(ctx.chat.id, pending.message_id, `Arisa Doctor failed: ${getErrorMessage(error)}`);
+    }
+  });
+
+  bot.command("update", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    const pending = await ctx.reply(renderTelegramHtml("```text\nChecking Arisa and official tool updates…\n```"), { parse_mode: "HTML" });
+    try {
+      await ctx.api.editMessageText(
+        ctx.chat.id,
+        pending.message_id,
+        renderTelegramHtml(await checkUpdates(ctx.chat.id)),
+        { parse_mode: "HTML" }
+      );
+    } catch (error) {
+      logger?.error("update", `update check failed: ${getErrorMessage(error)}`);
+      await ctx.api.editMessageText(ctx.chat.id, pending.message_id, `Arisa update check failed: ${getErrorMessage(error)}`);
+    }
+  });
+
+  bot.command("tools", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    await ctx.reply(renderTelegramHtml(formatToolUsageReport(await toolRegistry.usage(ctx.chat.id))), { parse_mode: "HTML" });
   });
 
   bot.command("model", async (ctx) => {
@@ -1430,6 +1528,25 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     }
   });
 
+  bot.on("message_reaction", async (ctx) => {
+    const reaction = ctx.messageReaction;
+    const chatId = reaction.chat.id;
+    const auth = await authorizeChat({ config, chatId, saveConfig });
+    if (!auth.ok || piAuthIssue) return;
+
+    const reactedMessageText = getChatState(chatId).assistantMessages.get(reaction.message_id) || "";
+    const prompt = buildReactionPrompt({ reaction, reactedMessageText });
+    enqueuePrompt({
+      chatId,
+      prompt,
+      label: `reaction to message ${reaction.message_id}`,
+      busyMessageMode: "queue"
+    }).catch((error) => {
+      getChatState(chatId).processing = false;
+      logger?.error("telegram", `reaction handling failed for chat ${chatId}: ${getErrorMessage(error)}`);
+    });
+  });
+
   bot.on("message", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -1477,7 +1594,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       await bot.api.deleteWebhook({ drop_pending_updates: true });
       logger?.log("telegram", "bot polling started");
       scheduleStartupMessages({ skipAgentStartupPrompts });
-      await bot.start();
+      await bot.start({ allowed_updates: ["message", "callback_query", "message_reaction"] });
     },
 
     async stop() {

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

@@ -95,7 +95,8 @@ test("chat state uses one queue for numeric and string chat IDs", () => {
     historyRevision: 0,
     beforeNextPrompt: null,
     activeSession: null,
-    activeSteers: []
+    activeSteers: [],
+    assistantMessages: new Map()
   });
 });
 

package/test/doctor.test.js

@@ -28,6 +28,20 @@ function runtime(overrides = {}) {
   };
 }
 
+const system = {
+  platform: "linux x64",
+  cpuCores: 4,
+  loadAverage: [0.25, 0.5, 0.75],
+  memoryTotal: 8 * 1024 ** 3,
+  memoryFree: 3 * 1024 ** 3,
+  memoryUsed: 5 * 1024 ** 3,
+  diskTotal: 100 * 1024 ** 3,
+  diskFree: 40 * 1024 ** 3,
+  diskUsed: 60 * 1024 ** 3,
+  uptimeSeconds: 90061,
+  processRss: 256 * 1024 ** 2
+};
+
 async function run({ diagnostic = runtime(), processes = [], service = { running: false }, repairs = [] } = {}) {
   const stopped = [];
   const report = await runDoctor({
@@ -39,7 +53,8 @@ async function run({ diagnostic = runtime(), processes = [], service = { running
     serviceStatus: async () => service,
     stopProcess: async (pid) => { stopped.push(pid); },
     stopDaemon: async () => {},
-    unregisterDaemon: async () => {}
+    unregisterDaemon: async () => {},
+    inspectResources: async () => system
   });
   return { report, stopped };
 }
@@ -63,7 +78,13 @@ test("reports Pi context size and retained-content inefficiency", async () => {
   assert.equal(report.contexts[0].level, "warning");
   assert.match(report.attention.join("\n"), /80,000\/100,000 tokens/);
   assert.match(report.attention.join("\n"), /tool results occupy 70\.0%/);
-  assert.match(formatDoctorReport(report), /Core: Pi, 1 active session/);
+  const formatted = formatDoctorReport(report);
+  assert.match(formatted, /Core\n  Runtime    Pi/);
+  assert.match(formatted, /CPU        4 cores/);
+  assert.match(formatted, /Load       0\.25 \/ 0\.50 \/ 0\.75/);
+  assert.match(formatted, /Memory     62\.5% \/ 3\.0 GB free/);
+  assert.match(formatted, /Disk       60\.0% \/ 40\.0 GB free/);
+  assert.ok(formatted.split("\n").every((line) => [...line].length <= 35));
 });
 
 test("stops only a registered duplicate Arisa service with verified identity", async () => {

package/test/paths.test.js

@@ -11,6 +11,7 @@ import {
   getChatArtifactsDir,
   getChatConversationHistoryFile,
   getChatToolConfigPath,
+  getChatToolUsageFile,
   getChatToolStateDir,
   getToolStateDir,
   stateDir
@@ -31,6 +32,13 @@ test("keeps portable conversation history scoped below the chat state directory"
   );
 });
 
+test("keeps tool usage scoped below the chat state directory", () => {
+  assert.equal(
+    getChatToolUsageFile("chat-1"),
+    path.join(chatsDir, "chat-1", "state", "tool-usage.json")
+  );
+});
+
 test("keeps chat tool state and config paths scoped below the chat directory for normal names", () => {
   assert.equal(
     getChatToolStateDir("chat-1", "strudel-agent"),

package/test/pi-compaction.test.js

@@ -8,7 +8,7 @@ test("provides Pi compaction defaults through Arisa config", () => {
 
   assert.deepEqual(config.pi.compaction, {
     enabled: true,
-    reserveTokens: 16_384,
+    reserveTokens: 120_000,
     keepRecentTokens: 20_000
   });
   assert.deepEqual(config.pi.compaction, piConfigDefaults.compaction);

package/test/service-manager.test.js

@@ -3,11 +3,14 @@ import test from "node:test";
 import { createTelegramRestartHandler, telegramCommands } from "../src/transport/telegram/bot.js";
 import { handoffServiceRestart, restartService, serviceEntryFile, waitForServiceStop } from "../src/runtime/service-manager.js";
 
-test("registers /restart as a native Telegram command", () => {
+test("registers maintenance as native Telegram commands", () => {
   assert.equal(
     telegramCommands.some((command) => command.command === "restart"),
     true
   );
+  assert.equal(telegramCommands.some((command) => command.command === "update"), true);
+  assert.equal(telegramCommands.some((command) => command.command === "tools"), true);
+  assert.ok(telegramCommands.every((command) => command.description.length <= 24));
   assert.equal(telegramCommands.some((command) => command.command === "harness"), false);
   assert.equal(telegramCommands.some((command) => command.command === "login"), false);
 });

package/test/telegram-text-artifact.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { buildPrompt, shouldIncludeArtifactReference } from "../src/transport/telegram/bot.js";
+import { buildPrompt, buildReactionPrompt, shouldIncludeArtifactReference } from "../src/transport/telegram/bot.js";
 import { captureIncomingArtifact } from "../src/transport/telegram/media.js";
 
 function createTextContext(text = "hello") {
@@ -60,6 +60,41 @@ test("keeps distinct artifacts visible to the prompt", () => {
   );
 });
 
+test("surfaces Telegram forwarding provenance in the prompt", () => {
+  const ctx = createTextContext("forwarded text");
+  ctx.message.forward_origin = {
+    type: "user",
+    sender_user: { id: 999, username: "source_user", first_name: "Source" },
+    date: 1_786_570_000
+  };
+
+  const prompt = buildPrompt({ ctx });
+
+  assert.match(prompt, /forwarded: true/);
+  assert.match(prompt, /forwardedOriginType: user/);
+  assert.match(prompt, /forwardedFrom: @source_user/);
+  assert.match(prompt, /forwardedAt: 2026-/);
+});
+
+test("formats Telegram reaction changes as lightweight feedback", () => {
+  const prompt = buildReactionPrompt({
+    reaction: {
+      chat: { id: 123 },
+      user: { id: 456, username: "martin", first_name: "Martin" },
+      message_id: 321,
+      old_reaction: [{ type: "emoji", emoji: "👍" }],
+      new_reaction: [{ type: "emoji", emoji: "❤️" }]
+    },
+    reactedMessageText: "Updated draft intro"
+  });
+
+  assert.match(prompt, /reactedMessageId: 321/);
+  assert.match(prompt, /reactedMessageText: Updated draft intro/);
+  assert.match(prompt, /addedReactions: ❤️/);
+  assert.match(prompt, /removedReactions: 👍/);
+  assert.match(prompt, /otherwise stay silent/);
+});
+
 test("marks incoming Telegram text artifacts as internal inline messages", async () => {
   const calls = [];
   const artifactStore = {

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

@@ -155,12 +155,33 @@ 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 }]);
 
   const requestFile = result.output.requestFile;
   await assert.rejects(() => access(requestFile), { code: "ENOENT" });
   await assert.rejects(() => access(path.dirname(requestFile)), { code: "ENOENT" });
 });
 
+test("keeps concurrent requests to the same tool isolated", async () => {
+  await resetHome();
+  await createFakeTool("fake-tool");
+
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  const results = await Promise.all(Array.from({ length: 12 }, (_, index) => registry.run({
+    name: "fake-tool",
+    chatId: "chat-1",
+    request: { text: `request-${index}`, args: { index } }
+  })));
+
+  assert.deepEqual(
+    results.map((result) => result.output.request.text).sort(),
+    Array.from({ length: 12 }, (_, index) => `request-${index}`).sort()
+  );
+  assert.equal(new Set(results.map((result) => result.output.requestFile)).size, 12);
+});
+
 test("rejects unknown tools", async () => {
   await resetHome();
   const registry = new ToolRegistry();

package/test/tool-usage.test.js

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { ToolUsageStore } from "../src/core/tools/tool-usage-store.js";
+import { formatToolUsageReport } from "../src/runtime/tool-usage-report.js";
+
+test("counts concurrent tool uses per chat", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "arisa-tool-usage-"));
+  const store = new ToolUsageStore({ resolveFile: (chatId) => path.join(root, String(chatId), "usage.json") });
+  try {
+    await Promise.all([
+      store.record("chat-1", "gmail-workspace"),
+      store.record("chat-1", "gmail-workspace"),
+      store.record("chat-1", "x-reader"),
+      store.record("chat-2", "gmail-workspace")
+    ]);
+    assert.deepEqual(await store.counts("chat-1"), {
+      "gmail-workspace": 2,
+      "x-reader": 1
+    });
+    assert.deepEqual(await store.counts("chat-2"), { "gmail-workspace": 1 });
+  } finally {
+    await rm(root, { recursive: true, force: 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 }
+  ]);
+  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.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));
+});

package/test/update-manager.test.js

@@ -0,0 +1,87 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { compareVersions, formatUpdateReport } from "../src/runtime/update-manager.js";
+
+test("compares semantic versions", () => {
+  assert.equal(compareVersions("5.0.2", "5.0.3"), -1);
+  assert.equal(compareVersions("5.1.0", "5.0.9"), 1);
+  assert.equal(compareVersions("5.0.2", "5.0.2"), 0);
+  assert.equal(compareVersions("invalid", "5.0.2"), null);
+});
+
+test("formats core and official tool update status", () => {
+  assert.equal(formatUpdateReport({
+    core: { currentVersion: "5.0.2", latestVersion: "5.1.0", updateAvailable: true },
+    bootstrapInstalled: ["official-tool-sync"],
+    tools: {
+      installedOfficial: 3,
+      official: [
+        { name: "context-vault", status: "up-to-date" },
+        { name: "customized", status: "diverged" },
+        { name: "gmail-workspace", status: "upstream-update" }
+      ],
+      nonOfficial: ["private-helper"],
+      counts: { "up-to-date": 1, "upstream-update": 1, diverged: 1 },
+      updateable: ["context-vault"],
+      blocked: [{ name: "customized", status: "diverged" }]
+    }
+  }), [
+    "```text",
+    "Arisa update",
+    "============",
+    "Core",
+    "  Current    5.0.2",
+    "  Latest     5.1.0",
+    "  Status     update available",
+    "",
+    "Official tools",
+    "  Installed  3",
+    "  up-to-date           1",
+    "  upstream-update      1",
+    "  diverged             1",
+    "",
+    "Official (3)",
+    "  - context-vault",
+    "  - customized [diverged]",
+    "  - gmail-workspace",
+    "    [upstream-update]",
+    "",
+    "Non-official (1)",
+    "  - private-helper",
+    "",
+    "Safe updates",
+    "  - context-vault",
+    "",
+    "Needs review",
+    "  - customized",
+    "    [diverged]",
+    "",
+    "Update support installed",
+    "  - official-tool-sync",
+    "```"
+  ].join("\n"));
+});
+
+test("shortens long review status labels", () => {
+  const report = formatUpdateReport({
+    core: { currentVersion: "5.0.2", latestVersion: "5.0.2", updateAvailable: false },
+    bootstrapInstalled: [],
+    tools: {
+      installedOfficial: 2,
+      official: [
+        { name: "audio-extractor", status: "locally-modified" },
+        { name: "campaign-draft-runner", status: "untracked-difference" }
+      ],
+      nonOfficial: [],
+      counts: {},
+      updateable: [],
+      blocked: [
+        { name: "audio-extractor", status: "locally-modified" },
+        { name: "campaign-draft-runner", status: "untracked-difference" }
+      ]
+    }
+  });
+  assert.match(report, /audio-extractor\n    \[local\]/);
+  assert.match(report, /campaign-draft-runner\n    \[untracked\]/);
+  assert.ok(report.split("\n").every((line) => [...line].length <= 35));
+});