arisa 5.1.11 → 5.1.13

package/ARISA-MASTER-SLAVE-SPEC.md

@@ -76,7 +76,9 @@ el protocolo, la CLI y la documentación.
 - Linux con systemd es la primera plataforma operativa soportada. Master y Slave
   pueden coexistir en un host mediante homes, sockets, PID y logs separados.
 - El usuario dedicado es la opción recomendada. El usuario actual está
-  permitido y root requiere siempre una elección y confirmación explícitas.
+  permitido y root requiere una elección explícita durante la instalación.
+  Una Slave elegida como root queda por defecto en modo host completo con todas
+  las capacidades v1; una política guardada posteriormente reemplaza ese default.
 - Los jobs dirigidos a Slaves offline se rechazan en v1.
 - La instalación remota acepta sólo tools del catálogo verificado y requiere
   confirmación. Nunca se instala código silenciosamente como root.
@@ -565,9 +567,10 @@ Ejecutar Arisa Slave como:
 ```
 
 Se admite elegir `root`. El perfil resultante y todos los informes de Master
-deben mostrar que Slave tiene autoridad root. El modo root restringido puede
-seguir aplicando las raíces y operaciones configuradas en la capa de aplicación.
-El modo root con host completo requiere otra confirmación explícita.
+deben mostrar que Slave tiene autoridad root. Elegir root instala por defecto un
+perfil de host completo con raíz `/` y todas las capacidades v1, incluida
+`process.exec`. Una política persistida después puede volver a restringir las
+raíces y operaciones en la capa de aplicación.
 
 Las restricciones de aplicación reducen el uso accidental, pero dejan de ser
 una frontera de seguridad si el propio proceso de Slave resulta comprometido:

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "arisa",
-  "version": "5.1.11",
+  "version": "5.1.13",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",
   "bin": {
     "arisa": "bin/arisa.js"
   },
+  "scripts": {
+    "start": "node src/index.js",
+    "bootstrap": "node src/index.js --bootstrap",
+    "test": "node --test"
+  },
   "keywords": [
     "telegram",
     "pi-agent",
@@ -39,15 +44,11 @@
     "url": "https://github.com/clasen/Arisa/issues"
   },
   "homepage": "https://arisa.sh",
+  "packageManager": "pnpm@11.3.0+sha512.2c403d6594527287672b1f7056343a1f7c3634036a67ffabfcc2b3d7595d843768f8787148d1b57cf7956c90606bbd192857c363af19e96d2d0ec9ec5741d215",
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.80.6",
     "@sinclair/typebox": "^0.34.41",
     "grammy": "^1.42.0",
     "typebox": "1.1.38"
-  },
-  "scripts": {
-    "start": "node src/index.js",
-    "bootstrap": "node src/index.js --bootstrap",
-    "test": "node --test"
   }
-}
+}

package/src/official-tools.lock.json

@@ -1,15 +1,15 @@
 {
   "version": 1,
   "repository": "https://github.com/clasen/Arisa.git",
-  "commit": "5959b7378c94b4d9c4864eba9e1ef9aa564f104a",
+  "commit": "8438bffbc656de7f85e9a98fe7d8804b3c0224ea",
   "tools": {
     "master-slave": {
       "files": {
-        "README.md": "39a546ca6046e622f92eff2d46f2c441beef43f150758799c68328bffd54efce",
+        "README.md": "8533804fda909c2f7bb0d05d40e2d6be9ef9126215bde70cd0ac4dda4afe9c55",
         "batch-runner.js": "be3939efe9c5800d3078c15a094f53db1094ef6e809d7826db7c47e3bec0c31b",
         "chat-state-store.js": "50de39aa33432733bb688eb01968e314a32b169324a66d0f0089b2a19ed9c880",
         "config.js": "ff1c1cb6701ae1da7a6eb1519ba96a416e48daa73c2155a6f93cf5d64f65cef8",
-        "index.js": "39dc9bf44f94864bc4fd09ce695cc2e084e59eea48d09764f0fb6f998faf9dd3",
+        "index.js": "8586303b3d1bf937932159adbe9b69c1031e6a393300e7d3aca93910ddfab082",
         "lib/bootstrap-url.js": "f05925cc0f0dff0882f94f9908c6f2c80aa8632cd51f63389381dcbb0f73afb3",
         "lib/encrypted-frames.js": "47e1b11fafdbbcdfd86a0993a47a774e4f37d6386edeaf8ec1c8511b109728cf",
         "lib/handshake-crypto.js": "9728b117aad7de53f5f0e255c0fd865ee1a19633368730a7634334d374094578",
@@ -20,7 +20,7 @@
         "master-domain.js": "10b7dfb43eb9939eb5baec54f742076cc73a2add6589a0ff57c51bc79c236faf",
         "network-session.js": "db2d81a7ef47af29236d963b98e21414a11fef68e8b20895126eaad3f696ba3d",
         "package.json": "8e9177238ba878dd4b51e32e0ed58a39c5789186c22b19ad7a43ab6caf9dc469",
-        "remote-runtime.js": "92c86adf575f2734c6f2f0d9004018f2019a8ac10288a1810425ce9fe0ffa129",
+        "remote-runtime.js": "55dd7e577a822be17c2f337798a2d7f44ad0c5b6d68c46490e058282135c4658",
         "slave-operations.js": "fec2e8addfff98f080284f24f722c1516124e5f6d12d8c03bb3c9cc0c475d1d6",
         "state-store.js": "c56849a3f1b9c990128276e17963034a7836abacedc44f2e500d5732ebf9e451",
         "test/batch-runner.test.js": "f14c6fddff5d6240008eef388df6a153e82490e534d06419d7bb267e4f4693a7",
@@ -31,7 +31,7 @@
         "test/network-session.test.js": "2e459346cc9364be705bc5f54691245044588b2cd03ae77e2e870dee6dfbcca6",
         "test/pairing-secret-store.test.js": "c51257365fd0b641c24768d710cdff2d1c5f8816bf90f66c2c01a226904cb43f",
         "test/profile-catalog.test.js": "d8e297bee413d53ec13f2e1779c13f2e019cb8304976d567eab0e9f1ca36637c",
-        "test/remote-runtime.test.js": "a842c9934a3bf2e37c0a807ad2bc78f2f0d5adb38336c53369ddd92132bfb2b6",
+        "test/remote-runtime.test.js": "1161bd653dc47b9b8219bf848d0d395ce390f2bb7b58ea41e3e4270b1d504798",
         "test/slave-operations.test.js": "a84526ad7554c7d03192a68655b4637bec18750559a5c3436f7471e912ca74cc",
         "tool.manifest.json": "abf24c67b1d9ef0331ded59e04dcc092772419e74691c0d753ab51b40286d6f6"
       }

package/src/runtime/create-app.js

@@ -11,7 +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";
+import { checkForUpdates, installCoreUpdate, updateOfficialTools } from "./update-manager.js";
 
 function normalizeString(value) {
   const text = String(value ?? "").trim();
@@ -146,7 +146,9 @@ export async function createApp({ logger, runtimeOverrides, requestRestart } = {
       },
       logger
     }),
-    checkUpdates: async (chatId) => formatUpdateReport(await checkForUpdates({ chatId, toolRegistry })),
+    checkUpdates: async (chatId) => checkForUpdates({ chatId, toolRegistry }),
+    updateCore: async (targetVersion) => installCoreUpdate({ targetVersion }),
+    updateTools: async (chatId) => updateOfficialTools({ chatId, toolRegistry }),
     requestRestart,
     logger
   });

package/src/runtime/update-manager.js

@@ -58,6 +58,32 @@ async function fetchLatestVersion() {
   return version;
 }
 
+export async function installCoreUpdate({ targetVersion }, {
+  readVersion = readCurrentVersion,
+  fetchVersion = fetchLatestVersion,
+  execute = runCommand
+} = {}) {
+  if (!parseSemver(targetVersion)) throw new Error("Invalid Arisa update version");
+  const [currentVersion, latestVersion] = await Promise.all([readVersion(), fetchVersion()]);
+  if (targetVersion !== latestVersion) {
+    throw new Error(`Arisa ${latestVersion} is now the latest version. Run /update again.`);
+  }
+  if (compareVersions(currentVersion, latestVersion) !== -1) {
+    return { updated: false, currentVersion, latestVersion };
+  }
+
+  await execute("npm", ["install", "--global", `arisa@${latestVersion}`]);
+  const installedVersion = await readVersion();
+  if (installedVersion !== latestVersion) {
+    throw new Error(`npm completed, but Arisa is still ${installedVersion} instead of ${latestVersion}`);
+  }
+  return {
+    updated: true,
+    previousVersion: currentVersion,
+    currentVersion: installedVersion
+  };
+}
+
 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 });
@@ -156,6 +182,23 @@ export async function checkForUpdates({ chatId, toolRegistry }) {
   };
 }
 
+export async function updateOfficialTools({ chatId, toolRegistry }) {
+  try {
+    const result = await toolRegistry.run({
+      name: "official-tool-sync",
+      chatId,
+      request: { args: { action: "update-safe" } }
+    });
+    const sync = parseToolSyncOutput(result);
+    return {
+      updated: (sync.updates || []).filter((item) => item.action === "updated").map((item) => item.name),
+      skipped: (sync.skipped || []).map(({ name, status }) => ({ name, status }))
+    };
+  } finally {
+    await toolRegistry.load();
+  }
+}
+
 function shortToolStatus(status) {
   return ({
     "locally-modified": "local",

package/src/transport/telegram/bot.js

@@ -16,6 +16,8 @@ import { ConversationHistoryStore } from "../../core/conversation/conversation-h
 import { formatDoctorReport } from "../../runtime/doctor.js";
 import { formatToolUsageReport } from "../../runtime/tool-usage-report.js";
 import { ToolResourceNoteStore } from "../../core/tools/tool-resource-note-store.js";
+import { formatUpdateReport } from "../../runtime/update-manager.js";
+import { buildUpdatePicker, createTelegramUpdateCallbackHandler } from "./update-command.js";
 
 const slowPromptNoticeMs = 300_000;
 
@@ -23,7 +25,7 @@ export const telegramCommands = Object.freeze([
   { command: "new", description: "New chat context" },
   { command: "restart", description: "Restart Arisa" },
   { command: "doctor", description: "Check runtime health" },
-  { command: "update", description: "Check for updates" },
+  { command: "update", description: "Check and apply updates" },
   { command: "tools", description: "Tool usage counts" },
   { command: "model", description: "Choose chat model" },
   { command: "effort", description: "Choose reasoning effort" },
@@ -352,21 +354,23 @@ function buildStartupMessage(chatMeta = {}) {
 }
 
 export async function collectText(session, prompt, { logger, chatId, onSlowPrompt } = {}) {
-  let text = "";
+  const assistantMessages = [];
+  let assistantMessage = "";
   let assistantErrorMessage = "";
-  let shouldSeparateAssistantMessage = false;
   let slowPromptTimer = null;
+  const finishAssistantMessage = () => {
+    if (assistantMessage && !isSilentReply(assistantMessage)) {
+      assistantMessages.push(assistantMessage);
+    }
+    assistantMessage = "";
+  };
   const unsubscribe = session.subscribe((event) => {
     if (event.arisaPromptScoped === false) return;
     if (event.type === "message_start" && event.message.role === "assistant") {
-      shouldSeparateAssistantMessage = text.trim().length > 0;
+      finishAssistantMessage();
     }
     if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
-      if (shouldSeparateAssistantMessage && event.assistantMessageEvent.delta) {
-        text += "\n\n";
-        shouldSeparateAssistantMessage = false;
-      }
-      text += event.assistantMessageEvent.delta;
+      assistantMessage += event.assistantMessageEvent.delta;
     }
     if (event.type === "message_end" && event.message?.role === "assistant") {
       if (event.message.stopReason === "error") {
@@ -375,6 +379,7 @@ export async function collectText(session, prompt, { logger, chatId, onSlowPromp
         // Auto-compaction and retry can emit a transient error before a successful continuation.
         assistantErrorMessage = "";
       }
+      finishAssistantMessage();
     }
     const logMessage = sessionEventLogMessage(event);
     if (logMessage) logger?.log("agent", `chat ${chatId} ${logMessage}`);
@@ -400,7 +405,8 @@ export async function collectText(session, prompt, { logger, chatId, onSlowPromp
     throw new Error(assistantErrorMessage);
   }
 
-  return text.trim();
+  finishAssistantMessage();
+  return assistantMessages.join("\n\n").trim();
 }
 
 export function isSilentReply(text) {
@@ -568,7 +574,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, checkUpdates, requestRestart, logger }) {
+export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, doctor, checkUpdates, updateCore, updateTools, requestRestart, logger }) {
   const resourceNotes = new ToolResourceNoteStore();
   const bot = new Bot(config.telegram.token);
   const perChatState = createChatStateStore();
@@ -588,6 +594,18 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     requestRestart,
     logger
   });
+  const handleUpdateCallback = createTelegramUpdateCallbackHandler({
+    authorize: (ctx) => authorizeChat({
+      config,
+      chatId: ctx.chat.id,
+      saveConfig,
+      chatMeta: getIncomingChatMeta(ctx)
+    }),
+    updateCore,
+    updateTools,
+    requestRestart,
+    logger
+  });
 
   function chatKey(chatId) {
     return String(chatId);
@@ -1272,11 +1290,13 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     if (!auth.ok) return;
     const pending = await ctx.reply(renderTelegramHtml("```text\nChecking Arisa and official tool updates…\n```"), { parse_mode: "HTML" });
     try {
+      const report = await checkUpdates(ctx.chat.id);
+      const picker = buildUpdatePicker(report);
       await ctx.api.editMessageText(
         ctx.chat.id,
         pending.message_id,
-        renderTelegramHtml(await checkUpdates(ctx.chat.id)),
-        { parse_mode: "HTML" }
+        renderTelegramHtml(formatUpdateReport(report)),
+        { parse_mode: "HTML", reply_markup: picker.replyMarkup }
       );
     } catch (error) {
       logger?.error("update", `update check failed: ${getErrorMessage(error)}`);
@@ -1342,6 +1362,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   });
 
   bot.on("callback_query:data", async (ctx, next) => {
+    if (await handleUpdateCallback(ctx)) return;
     const modelAction = parseModelPickerAction(ctx.callbackQuery.data);
     const effortAction = modelAction ? null : parseEffortPickerAction(ctx.callbackQuery.data);
     const speedAction = modelAction || effortAction ? null : parseSpeedPickerAction(ctx.callbackQuery.data);

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

@@ -0,0 +1,122 @@
+const callbackPrefix = "arisa-update:";
+
+function callbackMessage(ctx) {
+  return {
+    chatId: ctx.chat.id,
+    messageId: ctx.callbackQuery.message.message_id
+  };
+}
+
+async function editCallbackMessage(ctx, text, extra) {
+  const { chatId, messageId } = callbackMessage(ctx);
+  return extra
+    ? ctx.api.editMessageText(chatId, messageId, text, extra)
+    : ctx.api.editMessageText(chatId, messageId, text);
+}
+
+export function buildUpdatePicker(report) {
+  const rows = [];
+  if (report.core.updateAvailable) {
+    rows.push([{
+      text: `Update Arisa → ${report.core.latestVersion}`,
+      callback_data: `${callbackPrefix}core:${report.core.latestVersion}`
+    }]);
+  }
+  if (report.tools.updateable.length) {
+    rows.push([{
+      text: `Update safe tools (${report.tools.updateable.length})`,
+      callback_data: `${callbackPrefix}tools`
+    }]);
+  }
+  rows.push(rows.length
+    ? [{ text: "Not now", callback_data: `${callbackPrefix}close` }]
+    : [{ text: "Up to date", callback_data: `${callbackPrefix}noop` }]);
+  return { replyMarkup: { inline_keyboard: rows } };
+}
+
+export function parseUpdateAction(data) {
+  if (data === `${callbackPrefix}tools`) return { type: "tools" };
+  if (data === `${callbackPrefix}close`) return { type: "close" };
+  if (data === `${callbackPrefix}noop`) return { type: "noop" };
+  const core = String(data || "").match(/^arisa-update:core:(\d+\.\d+\.\d+)$/);
+  return core ? { type: "core", targetVersion: core[1] } : null;
+}
+
+export function formatOfficialToolUpdateResult(result) {
+  const lines = result.updated.length
+    ? ["Updated official tools:", ...result.updated.map((name) => `- ${name}`)]
+    : ["Official tools were already up to date."];
+  if (result.skipped.length) {
+    lines.push("", "Not changed (needs review):");
+    for (const item of result.skipped) lines.push(`- ${item.name} [${item.status}]`);
+  }
+  return lines.join("\n");
+}
+
+export function createTelegramUpdateCallbackHandler({ authorize, updateCore, updateTools, requestRestart, logger }) {
+  let updateInProgress = false;
+
+  return async function handleTelegramUpdateCallback(ctx) {
+    const action = parseUpdateAction(ctx.callbackQuery.data);
+    if (!action) return false;
+
+    const auth = await authorize(ctx);
+    if (!auth.ok) {
+      await ctx.answerCallbackQuery({ text: "This chat is not authorized.", show_alert: true });
+      return true;
+    }
+    if (action.type === "noop") {
+      await ctx.answerCallbackQuery({ text: "Arisa and official tools are up to date." });
+      return true;
+    }
+    if (action.type === "close") {
+      await ctx.answerCallbackQuery();
+      await editCallbackMessage(ctx, "Update cancelled.");
+      return true;
+    }
+    if (updateInProgress) {
+      await ctx.answerCallbackQuery({ text: "An update is already in progress.", show_alert: true });
+      return true;
+    }
+
+    updateInProgress = true;
+    const coreUpdate = action.type === "core";
+    try {
+      await ctx.answerCallbackQuery({ text: coreUpdate ? "Updating Arisa…" : "Updating safe tools…" });
+      if (coreUpdate) {
+        await editCallbackMessage(ctx, `Updating Arisa to ${action.targetVersion}…`);
+        const result = await updateCore(action.targetVersion);
+        if (!result.updated) {
+          await editCallbackMessage(ctx, `Arisa ${result.currentVersion} is already up to date.`);
+          return true;
+        }
+        await editCallbackMessage(
+          ctx,
+          `Arisa updated from ${result.previousVersion} to ${result.currentVersion}. Restarting…`
+        );
+        try {
+          await requestRestart();
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          logger?.error("update", `restart after update failed: ${message}`);
+          await editCallbackMessage(
+            ctx,
+            `Arisa updated to ${result.currentVersion}, but restart failed: ${message}\nRun /restart to activate it.`
+          );
+        }
+        return true;
+      }
+
+      await editCallbackMessage(ctx, "Updating safe official tools…");
+      await editCallbackMessage(ctx, formatOfficialToolUpdateResult(await updateTools(ctx.chat.id)));
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger?.error("update", `update action failed: ${message}`);
+      await editCallbackMessage(ctx, `Arisa update failed: ${message}`).catch(() => {});
+      return true;
+    } finally {
+      updateInProgress = false;
+    }
+  };
+}

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

@@ -59,6 +59,44 @@ test("collectText preserves the final assistant error", async () => {
   await assert.rejects(() => collectText(session, "hello"), /terminal failure/);
 });
 
+test("collectText drops a standalone silent event reply before a steered response", async () => {
+  const session = createSession([
+    { type: "message_start", message: { role: "assistant" } },
+    {
+      type: "message_update",
+      message: { role: "assistant" },
+      assistantMessageEvent: { type: "text_delta", delta: "NO_REPLY" }
+    },
+    { type: "message_end", message: { role: "assistant", stopReason: "stop" } },
+    { type: "message_start", message: { role: "assistant" } },
+    {
+      type: "message_update",
+      message: { role: "assistant" },
+      assistantMessageEvent: { type: "text_delta", delta: "The useful Telegram response." }
+    },
+    { type: "message_end", message: { role: "assistant", stopReason: "stop" } }
+  ]);
+
+  assert.equal(await collectText(session, "event followed by a Telegram steer"), "The useful Telegram response.");
+});
+
+test("collectText preserves useful text in the same message as a silent marker", async () => {
+  const session = createSession([
+    { type: "message_start", message: { role: "assistant" } },
+    {
+      type: "message_update",
+      message: { role: "assistant" },
+      assistantMessageEvent: { type: "text_delta", delta: "NO_REPLY\n\nThis text belongs to the same response." }
+    },
+    { type: "message_end", message: { role: "assistant", stopReason: "stop" } }
+  ]);
+
+  assert.equal(
+    await collectText(session, "one response that mentions the marker"),
+    "NO_REPLY\n\nThis text belongs to the same response."
+  );
+});
+
 test("recognizes standalone silent reply markers", () => {
   assert.equal(isSilentReply("NO_REPLY"), true);
   assert.equal(isSilentReply("No reply needed."), true);

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

@@ -3,6 +3,7 @@ import crypto from "node:crypto";
 import { cp, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import test from "node:test";
 import {
   installBundledOfficialTool,
@@ -59,6 +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 () => {
+  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 }
+  );
+});
+
 test("rejects symbolic links before deployment", async (t) => {
   const { source, files } = await fixture(t);
   await symlink(path.join(source, "index.js"), path.join(source, "link.js"));

package/test/update-command.test.js

@@ -0,0 +1,139 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  buildUpdatePicker,
+  createTelegramUpdateCallbackHandler,
+  parseUpdateAction
+} from "../src/transport/telegram/update-command.js";
+
+function report(overrides = {}) {
+  return {
+    core: { currentVersion: "5.0.2", latestVersion: "5.1.0", updateAvailable: true },
+    bootstrapInstalled: [],
+    tools: {
+      installedOfficial: 2,
+      official: [],
+      nonOfficial: [],
+      counts: {},
+      updateable: ["context-vault", "gmail-workspace"],
+      blocked: []
+    },
+    ...overrides
+  };
+}
+
+test("offers only available update actions", () => {
+  assert.deepEqual(buildUpdatePicker(report()).replyMarkup.inline_keyboard, [
+    [{ text: "Update Arisa → 5.1.0", callback_data: "arisa-update:core:5.1.0" }],
+    [{ text: "Update safe tools (2)", callback_data: "arisa-update:tools" }],
+    [{ text: "Not now", callback_data: "arisa-update:close" }]
+  ]);
+
+  assert.deepEqual(buildUpdatePicker(report({
+    core: { currentVersion: "5.1.0", latestVersion: "5.1.0", updateAvailable: false },
+    tools: { ...report().tools, updateable: [] }
+  })).replyMarkup.inline_keyboard, [
+    [{ text: "Up to date", callback_data: "arisa-update:noop" }]
+  ]);
+});
+
+test("parses only valid update callback data", () => {
+  assert.deepEqual(parseUpdateAction("arisa-update:core:5.1.0"), { type: "core", targetVersion: "5.1.0" });
+  assert.deepEqual(parseUpdateAction("arisa-update:tools"), { type: "tools" });
+  assert.deepEqual(parseUpdateAction("arisa-update:close"), { type: "close" });
+  assert.deepEqual(parseUpdateAction("arisa-update:noop"), { type: "noop" });
+  assert.equal(parseUpdateAction("arisa-update:core:latest"), null);
+  assert.equal(parseUpdateAction("model:1"), null);
+});
+
+test("applies a confirmed core update and then requests restart", async () => {
+  const calls = [];
+  const handler = createTelegramUpdateCallbackHandler({
+    authorize: async () => ({ ok: true }),
+    updateCore: async (targetVersion) => {
+      calls.push(["updateCore", targetVersion]);
+      return { updated: true, previousVersion: "5.0.2", currentVersion: targetVersion };
+    },
+    updateTools: async () => assert.fail("must not update tools"),
+    requestRestart: async () => { calls.push("restart"); }
+  });
+  const ctx = {
+    chat: { id: 42 },
+    callbackQuery: { data: "arisa-update:core:5.1.0", message: { message_id: 7 } },
+    answerCallbackQuery: async (payload) => { calls.push(["answer", payload]); },
+    api: {
+      editMessageText: async (...args) => { calls.push(["edit", ...args]); }
+    }
+  };
+
+  assert.equal(await handler(ctx), true);
+  assert.deepEqual(calls, [
+    ["answer", { text: "Updating Arisa…" }],
+    ["edit", 42, 7, "Updating Arisa to 5.1.0…"],
+    ["updateCore", "5.1.0"],
+    ["edit", 42, 7, "Arisa updated from 5.0.2 to 5.1.0. Restarting…"],
+    "restart"
+  ]);
+});
+
+test("uses official-tool-sync for the confirmed safe tool action", async () => {
+  const calls = [];
+  const handler = createTelegramUpdateCallbackHandler({
+    authorize: async () => ({ ok: true }),
+    updateCore: async () => assert.fail("must not update core"),
+    updateTools: async (chatId) => {
+      calls.push(["updateTools", chatId]);
+      return {
+        updated: ["context-vault"],
+        skipped: [{ name: "customized", status: "locally-modified" }]
+      };
+    },
+    requestRestart: async () => assert.fail("tool updates do not restart Arisa")
+  });
+  const ctx = {
+    chat: { id: 42 },
+    callbackQuery: { data: "arisa-update:tools", message: { message_id: 7 } },
+    answerCallbackQuery: async (payload) => { calls.push(["answer", payload]); },
+    api: {
+      editMessageText: async (...args) => { calls.push(["edit", ...args]); }
+    }
+  };
+
+  assert.equal(await handler(ctx), true);
+  assert.deepEqual(calls, [
+    ["answer", { text: "Updating safe tools…" }],
+    ["edit", 42, 7, "Updating safe official tools…"],
+    ["updateTools", 42],
+    ["edit", 42, 7, [
+      "Updated official tools:",
+      "- context-vault",
+      "",
+      "Not changed (needs review):",
+      "- customized [locally-modified]"
+    ].join("\n")]
+  ]);
+});
+
+test("reports restart failure separately after a successful core update", async () => {
+  const edits = [];
+  const handler = createTelegramUpdateCallbackHandler({
+    authorize: async () => ({ ok: true }),
+    updateCore: async () => ({ updated: true, previousVersion: "5.0.2", currentVersion: "5.1.0" }),
+    updateTools: async () => assert.fail("must not update tools"),
+    requestRestart: async () => { throw new Error("not running as a service"); }
+  });
+  const ctx = {
+    chat: { id: 42 },
+    callbackQuery: { data: "arisa-update:core:5.1.0", message: { message_id: 7 } },
+    answerCallbackQuery: async () => {},
+    api: {
+      editMessageText: async (_chatId, _messageId, text) => { edits.push(text); }
+    }
+  };
+
+  assert.equal(await handler(ctx), true);
+  assert.equal(edits.at(-1), [
+    "Arisa updated to 5.1.0, but restart failed: not running as a service",
+    "Run /restart to activate it."
+  ].join("\n"));
+});

package/test/update-manager.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { compareVersions, formatUpdateReport } from "../src/runtime/update-manager.js";
+import { compareVersions, formatUpdateReport, installCoreUpdate, updateOfficialTools } from "../src/runtime/update-manager.js";
 
 test("compares semantic versions", () => {
   assert.equal(compareVersions("5.0.2", "5.0.3"), -1);
@@ -85,3 +85,59 @@ test("shortens long review status labels", () => {
   assert.match(report, /campaign-draft-runner\n    \[untracked\]/);
   assert.ok(report.split("\n").every((line) => [...line].length <= 35));
 });
+
+test("installs only the currently published core update and verifies it", async () => {
+  const calls = [];
+  const versions = ["5.0.2", "5.1.0"];
+  const result = await installCoreUpdate({ targetVersion: "5.1.0" }, {
+    readVersion: async () => versions.shift(),
+    fetchVersion: async () => "5.1.0",
+    execute: async (...args) => { calls.push(args); }
+  });
+
+  assert.deepEqual(calls, [["npm", ["install", "--global", "arisa@5.1.0"]]]);
+  assert.deepEqual(result, {
+    updated: true,
+    previousVersion: "5.0.2",
+    currentVersion: "5.1.0"
+  });
+});
+
+test("refuses a stale core update button", async () => {
+  await assert.rejects(
+    installCoreUpdate({ targetVersion: "5.1.0" }, {
+      readVersion: async () => "5.0.2",
+      fetchVersion: async () => "5.1.1",
+      execute: async () => assert.fail("must not install a stale target")
+    }),
+    /Run \/update again/
+  );
+});
+
+test("updates only safe official tools and reloads the registry", async () => {
+  const calls = [];
+  const toolRegistry = {
+    async run(request) {
+      calls.push(request);
+      return {
+        ok: true,
+        output: {
+          json: {
+            updates: [{ name: "context-vault", action: "updated" }],
+            skipped: [{ name: "customized", status: "locally-modified" }]
+          }
+        }
+      };
+    },
+    async load() { calls.push("load"); }
+  };
+
+  assert.deepEqual(await updateOfficialTools({ chatId: 42, toolRegistry }), {
+    updated: ["context-vault"],
+    skipped: [{ name: "customized", status: "locally-modified" }]
+  });
+  assert.deepEqual(calls, [
+    { name: "official-tool-sync", chatId: 42, request: { args: { action: "update-safe" } } },
+    "load"
+  ]);
+});