arisa 4.2.8 → 4.3.2

package/src/transport/telegram/bot.js

@@ -3,9 +3,12 @@ import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact, formatLocationText } from "./media.js";
 import { buildDeviceCodeTelegramMessage } from "./device-code-message.js";
+import { buildModelPicker, parseModelPickerAction } from "./model-picker.js";
 import { renderTelegramHtml } from "./text-format.js";
 import { buildPiAuthRecoveryBlockedMessage, buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue, getPiAuthStatus } from "../../core/agent/auth-flow.js";
 import { createPiOAuthLogin } from "../../core/agent/pi-auth-login.js";
+import { resolveChatModel, selectChatModel } from "../../core/agent/model-selection.js";
+import { createPiRuntime, listProviderModels } from "../../core/agent/pi-runtime.js";
 import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
 
 const slowPromptNoticeMs = 300_000;
@@ -410,6 +413,49 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     return perChatState.get(chatId);
   }
 
+  function getProviderModels() {
+    const runtime = createPiRuntime({
+      provider: config.pi.provider,
+      apiKey: config.pi.apiKey
+    });
+    return listProviderModels(config.pi.provider, runtime);
+  }
+
+  async function showModelPicker(ctx, page = 0) {
+    const picker = buildModelPicker({
+      provider: config.pi.provider,
+      models: getProviderModels(),
+      selectedModelId: resolveChatModel(config, ctx.chat.id),
+      page,
+      pageSize: config.telegram.modelPickerPageSize
+    });
+    const extra = { reply_markup: picker.replyMarkup };
+    const messageId = ctx.callbackQuery?.message?.message_id;
+    if (messageId) {
+      return ctx.api.editMessageText(ctx.chat.id, messageId, picker.text, extra);
+    }
+    return ctx.reply(picker.text, extra);
+  }
+
+  async function persistChatModel(chatId, model) {
+    const key = chatKey(chatId);
+    const hadSelections = Boolean(config.pi.chatModels);
+    const previousSelection = config.pi.chatModels?.[key];
+    selectChatModel(config, chatId, model);
+    try {
+      await saveConfig(config);
+    } catch (error) {
+      if (previousSelection) {
+        config.pi.chatModels[key] = previousSelection;
+      } else {
+        delete config.pi.chatModels[key];
+        if (!hadSelections) delete config.pi.chatModels;
+      }
+      throw error;
+    }
+    agentManager.resetSession(chatId);
+  }
+
   async function buildIncomingPrompt(ctx) {
     const chatId = ctx.chat.id;
     logger?.log("telegram", `message ${ctx.msg.message_id} in chat ${chatId}`);
@@ -684,6 +730,12 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     await handleNewCommand(ctx);
   });
 
+  bot.command("model", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    await showModelPicker(ctx);
+  });
+
   bot.command("auth", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -717,6 +769,67 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     }
   });
 
+  bot.on("callback_query:data", async (ctx, next) => {
+    const action = parseModelPickerAction(ctx.callbackQuery.data);
+    if (!action) return next();
+    if (action.type === "noop") {
+      await ctx.answerCallbackQuery();
+      return;
+    }
+
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig });
+    if (!auth.ok) {
+      await ctx.answerCallbackQuery({ text: "This chat is not authorized.", show_alert: true });
+      return;
+    }
+
+    try {
+      if (action.type === "page") {
+        await showModelPicker(ctx, action.value);
+        await ctx.answerCallbackQuery();
+        return;
+      }
+
+      if (getChatState(ctx.chat.id).processing) {
+        await ctx.answerCallbackQuery({
+          text: "Wait for the current response before changing models.",
+          show_alert: true
+        });
+        return;
+      }
+
+      const models = getProviderModels();
+      const model = models[action.value];
+      if (!model) {
+        await ctx.answerCallbackQuery({
+          text: "This model list is no longer current. Run /model again.",
+          show_alert: true
+        });
+        return;
+      }
+
+      const currentModelId = resolveChatModel(config, ctx.chat.id);
+      if (model.id === currentModelId) {
+        await ctx.answerCallbackQuery({ text: `Already using ${model.id}.` });
+        return;
+      }
+
+      await persistChatModel(ctx.chat.id, model);
+      await ctx.api.editMessageText(
+        ctx.chat.id,
+        ctx.callbackQuery.message.message_id,
+        `Model changed to ${model.provider}/${model.id}.\nA new chat context will start with your next message.`
+      );
+      await ctx.answerCallbackQuery({ text: `Using ${model.id}.` });
+    } catch (error) {
+      logger?.error("telegram", `model selection failed for chat ${ctx.chat.id}: ${getErrorMessage(error)}`);
+      await ctx.answerCallbackQuery({
+        text: "Could not change the model.",
+        show_alert: true
+      }).catch(() => {});
+    }
+  });
+
   bot.on("message", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -753,6 +866,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       config.telegram.chatMeta ||= {};
       await bot.api.setMyCommands([
         { command: "new", description: "Start a new chat context" },
+        { command: "model", description: "Choose the model for this chat" },
         { command: "auth", description: "Show Pi authentication status" }
       ]);
       if (!taskTimer) {

package/src/transport/telegram/model-picker.js

@@ -0,0 +1,25 @@
+import { formatPiModelOption } from "../../core/agent/pi-runtime.js";
+import { buildPagedInlineKeyboard } from "./paged-inline-keyboard.js";
+
+export function parseModelPickerAction(data) {
+  if (data === "noop:page") return { type: "noop", value: null };
+  const match = /^(model|model-page):(\d+)$/.exec(String(data || ""));
+  if (!match) return null;
+  return {
+    type: match[1] === "model" ? "select" : "page",
+    value: Number(match[2])
+  };
+}
+
+export function buildModelPicker({ provider, models, selectedModelId, page, pageSize }) {
+  if (!models.length) {
+    throw new Error(`No models available for provider ${provider}`);
+  }
+  const items = models.map((model) => ({
+    text: `${model.id === selectedModelId ? "✓ " : ""}${formatPiModelOption(model)}`
+  }));
+  return {
+    text: `Current model: ${provider}/${selectedModelId}\nSelect a model for this chat:`,
+    replyMarkup: buildPagedInlineKeyboard("model", items, { page, pageSize })
+  };
+}

package/src/transport/telegram/paged-inline-keyboard.js

@@ -0,0 +1,30 @@
+function requirePositiveInteger(value, name) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+}
+
+export function buildPagedInlineKeyboard(action, items, { page = 0, pageSize }) {
+  requirePositiveInteger(pageSize, "pageSize");
+  const pageCount = Math.max(1, Math.ceil(items.length / pageSize));
+  const currentPage = Math.max(0, Math.min(pageCount - 1, page));
+  const startIndex = currentPage * pageSize;
+  const rows = items.slice(startIndex, startIndex + pageSize).map((item, index) => ([{
+    text: item.text,
+    callback_data: `${action}:${startIndex + index}`
+  }]));
+
+  if (pageCount > 1) {
+    const navigation = [];
+    if (currentPage > 0) {
+      navigation.push({ text: "Previous", callback_data: `${action}-page:${currentPage - 1}` });
+    }
+    navigation.push({ text: `${currentPage + 1}/${pageCount}`, callback_data: "noop:page" });
+    if (currentPage < pageCount - 1) {
+      navigation.push({ text: "Next", callback_data: `${action}-page:${currentPage + 1}` });
+    }
+    rows.push(navigation);
+  }
+
+  return { inline_keyboard: rows };
+}

package/test/artifact-store.test.js

@@ -78,12 +78,12 @@ test("creates generated file artifacts", async () => {
     source: { type: "assistant" }
   });
 
-  assert.equal(await readFile(artifact.path, "utf8"), "# Hello\n");
+  assert.equal(await readFile(artifact.path, "utf8"), "\ufeff# Hello\n");
   assert.equal(artifact.kind, "document");
   assert.equal(artifact.mimeType, "text/markdown");
 });
 
-test("writes generated text file artifacts as UTF-8", async () => {
+test("writes generated text file artifacts as BOM UTF-8", async () => {
   await resetHome();
   const content = "# Español\nÑandú\n";
   const artifact = await new ArtifactStore().forChat("chat-1").createGeneratedFile({
@@ -94,6 +94,43 @@ test("writes generated text file artifacts as UTF-8", async () => {
     source: { type: "assistant" }
   });
 
+  assert.deepEqual(await readFile(artifact.path), Buffer.from(`\ufeff${content}`, "utf8"));
+});
+
+test("normalizes copied generated text files to BOM UTF-8", async () => {
+  await resetHome();
+  const originalDir = await mkdtemp(path.join(os.tmpdir(), "arisa-source-file-"));
+  const originalPath = path.join(originalDir, "report.json");
+  const content = "{\"message\":\"Español\"}\n";
+  await writeFile(originalPath, content, "utf8");
+
+  const artifact = await new ArtifactStore().forChat("chat-1").createFromFile({
+    originalPath,
+    fileName: "report.json",
+    kind: "document",
+    mimeType: "application/json",
+    source: { type: "tool", toolName: "reporter" }
+  });
+
+  assert.deepEqual(await readFile(artifact.path), Buffer.from(`\ufeff${content}`, "utf8"));
+  assert.equal(await readFile(originalPath, "utf8"), content);
+});
+
+test("does not duplicate an existing UTF-8 BOM", async () => {
+  await resetHome();
+  const originalDir = await mkdtemp(path.join(os.tmpdir(), "arisa-source-file-"));
+  const originalPath = path.join(originalDir, "report.txt");
+  const content = "\ufeffAlready marked\n";
+  await writeFile(originalPath, content, "utf8");
+
+  const artifact = await new ArtifactStore().forChat("chat-1").createFromFile({
+    originalPath,
+    fileName: "report.txt",
+    kind: "document",
+    mimeType: "text/plain",
+    source: { type: "tool", toolName: "reporter" }
+  });
+
   assert.deepEqual(await readFile(artifact.path), Buffer.from(content, "utf8"));
 });
 

package/test/daemon-catalog-conformance.test.js

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const expected = {
+  "whispermix-transcribe": { scope: "global", autoStart: false },
+  "whatsapp-web": { scope: "chat", autoStart: false },
+  "roster-sites": { scope: "global", autoStart: true },
+  "turn-server": { scope: "global", autoStart: true },
+  "signaling-server": { scope: "global", autoStart: true }
+};
+
+for (const [toolName, daemon] of Object.entries(expected)) {
+  test(`${toolName} declares the managed daemon contract`, async () => {
+    const toolDir = path.join(repositoryRoot, "tools", toolName);
+    const manifest = JSON.parse(await readFile(path.join(toolDir, "tool.manifest.json"), "utf8"));
+    const source = await readFile(path.join(toolDir, manifest.entry), "utf8");
+
+    assert.equal(manifest.daemon.scope, daemon.scope);
+    assert.equal(manifest.daemon.autoStart, daemon.autoStart);
+    assert.equal(manifest.daemon.health, "internal");
+    assert.match(source, /createDaemonRuntime/);
+    assert.match(source, /healthCheck/);
+  });
+}

package/test/daemon-runtime.test.js

@@ -0,0 +1,220 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const homeDir = await mkdtemp(path.join(os.tmpdir(), "arisa-daemon-test-"));
+process.env.ARISA_HOME = homeDir;
+
+const policy = {
+  supervisorIntervalMs: 20,
+  heartbeatIntervalMs: 20,
+  heartbeatStaleMs: 150,
+  healthIntervalMs: 100,
+  healthTimeoutMs: 1_000,
+  healthRetryLimit: 1,
+  healthRetryBackoffMs: 10,
+  restartLimit: 2,
+  restartBackoffMs: 20,
+  restartBackoffMaxMs: 40,
+  startupTimeoutMs: 2_000,
+  stopTimeoutMs: 300,
+  queuePollIntervalMs: 10
+};
+
+await mkdir(path.join(homeDir, "state"), { recursive: true });
+await writeFile(
+  path.join(homeDir, "state", "config.json"),
+  `${JSON.stringify({ daemons: policy }, null, 2)}\n`,
+  "utf8"
+);
+
+const {
+  daemonPaths,
+  isProcessAlive,
+  readJson,
+  stopManagedDaemon
+} = await import("../src/core/tools/daemon-processes.js");
+const {
+  createDaemonRuntime,
+  isDaemonReady
+} = await import("../src/core/tools/daemon-runtime.js");
+const { createToolProcessSupervisor } = await import("../src/runtime/tool-process-supervisor.js");
+
+const fixtureEntry = fileURLToPath(new URL("../test-fixtures/fake-daemon.js", import.meta.url));
+
+function runtimeFor(scope, options = {}) {
+  return createDaemonRuntime({
+    toolName: "fake-daemon",
+    entryPath: fixtureEntry,
+    scope,
+    startupContext: options.startupContext || { health: "ok" },
+    autoStart: options.autoStart ?? false
+  });
+}
+
+async function waitFor(check, timeoutMs = 3_000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const result = await check();
+    if (result) return result;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  throw new Error(`Condition was not met after ${timeoutMs}ms`);
+}
+
+test.after(async () => {
+  for (const scope of [{ type: "global" }, { type: "chat", chatId: "101" }, { type: "chat", chatId: "202" }]) {
+    await stopManagedDaemon({ toolName: "fake-daemon", scope }).catch(() => {});
+  }
+  await rm(homeDir, { recursive: true, force: true });
+});
+
+test("runs health through the queue before accepting jobs", async () => {
+  const runtime = runtimeFor({ type: "global" });
+  const output = await runtime.submit({ value: "hello" }, { timeoutMs: 1_000 });
+  assert.deepEqual(output, { echo: "hello" });
+
+  const status = await readJson(runtime.paths.statusFile, {});
+  const pid = await runtime.getPid();
+  assert.equal(status.state, "ready");
+  assert.ok(status.heartbeatAt);
+  assert.ok(status.lastHealthSuccessAt);
+  assert.ok(status.lastSuccessfulJobAt);
+  assert.equal(isDaemonReady(status, pid, policy), true);
+
+  await assert.rejects(
+    () => runtime.submit({ action: "fail" }, { timeoutMs: 1_000 }),
+    /synthetic job failure/
+  );
+  const failedStatus = await readJson(runtime.paths.statusFile, {});
+  assert.equal(failedStatus.lastSuccessfulJobAt, status.lastSuccessfulJobAt);
+  assert.equal(failedStatus.lastError.phase, "job");
+
+  await runtime.stop();
+});
+
+test("isolates daemon process files and context by chat scope", async () => {
+  const first = runtimeFor({ type: "chat", chatId: "101" });
+  const second = runtimeFor({ type: "chat", chatId: "202" });
+  await first.submit({ value: "first" }, { timeoutMs: 2_000 });
+  await second.submit({ value: "second" }, { timeoutMs: 2_000 });
+
+  const firstPid = await first.getPid();
+  const secondPid = await second.getPid();
+  assert.notEqual(firstPid, secondPid);
+  assert.notEqual(first.paths.root, second.paths.root);
+
+  const firstMeta = JSON.parse(await readFile(first.paths.metaFile, "utf8"));
+  const secondMeta = JSON.parse(await readFile(second.paths.metaFile, "utf8"));
+  assert.deepEqual(firstMeta.scope, { type: "chat", chatId: "101" });
+  assert.deepEqual(secondMeta.scope, { type: "chat", chatId: "202" });
+  assert.deepEqual(firstMeta.startupContext, { health: "ok" });
+
+  await Promise.all([first.stop(), second.stop()]);
+});
+
+test("supervisor ignores invalid chat directories and recovers valid daemons", async () => {
+  const invalidChatDir = path.join(homeDir, "chats", "24137857-c513-4f53-b39d-1b28f51ebbb6");
+  await mkdir(path.join(invalidChatDir, "state", "tools", "orphaned-tool"), { recursive: true });
+
+  const runtime = runtimeFor({ type: "chat", chatId: "202" }, {
+    autoStart: true,
+    startupContext: { health: "ok" }
+  });
+  let supervisor;
+
+  try {
+    await runtime.submit({ value: "before" }, { timeoutMs: 1_000 });
+    const oldPid = await runtime.getPid();
+    process.kill(oldPid, "SIGKILL");
+    await waitFor(() => !isProcessAlive(oldPid));
+
+    supervisor = createToolProcessSupervisor({ policy });
+    await supervisor.start();
+
+    const newPid = await waitFor(async () => {
+      const pid = await runtime.getPid();
+      const status = await readJson(runtime.paths.statusFile, {});
+      return pid && pid !== oldPid && status.state === "ready" ? pid : null;
+    });
+    assert.notEqual(newPid, oldPid);
+  } finally {
+    await supervisor?.stop();
+    await runtime.stop().catch(() => {});
+    await rm(invalidChatDir, { recursive: true, force: true });
+  }
+});
+
+test("rejects stale readiness even when the pid is alive", async () => {
+  const status = {
+    state: "ready",
+    heartbeatAt: new Date(Date.now() - policy.heartbeatStaleMs - 1).toISOString(),
+    lastHealthSuccessAt: new Date().toISOString()
+  };
+  assert.equal(isDaemonReady(status, process.pid, policy), false);
+});
+
+test("does not auto-start an intentionally stopped on-demand daemon", async () => {
+  const runtime = runtimeFor({ type: "global" }, { autoStart: false });
+  await runtime.submit({ value: "once" }, { timeoutMs: 2_000 });
+  await runtime.stop();
+
+  const supervisor = createToolProcessSupervisor({ policy });
+  await supervisor.start();
+  await new Promise((resolve) => setTimeout(resolve, policy.supervisorIntervalMs * 3));
+  assert.equal(isProcessAlive(await runtime.getPid()), false);
+  assert.equal((await readJson(runtime.paths.statusFile, {})).state, "stopped");
+  await supervisor.stop();
+});
+
+test("external supervisor recovers internally before restarting", async () => {
+  const runtime = runtimeFor({ type: "global" }, {
+    autoStart: true,
+    startupContext: { health: "fail", recover: true }
+  });
+  await runtime.start();
+  const supervisor = createToolProcessSupervisor({ policy });
+  await supervisor.start();
+
+  const status = await waitFor(async () => {
+    const current = await readJson(runtime.paths.statusFile, {});
+    return current.state === "ready" ? current : null;
+  });
+  assert.equal(status.state, "ready");
+  assert.deepEqual(
+    JSON.parse(await readFile(path.join(runtime.paths.root, "recovered.json"), "utf8")),
+    { recovered: true }
+  );
+
+  await supervisor.stop();
+  await runtime.stop();
+});
+
+test("external supervisor recreates a dead process with the same context", async () => {
+  const scope = { type: "chat", chatId: "101" };
+  const runtime = runtimeFor(scope, {
+    autoStart: true,
+    startupContext: { health: "ok", marker: "preserved" }
+  });
+  await runtime.submit({ value: "before" }, { timeoutMs: 1_000 });
+  const oldPid = await runtime.getPid();
+  process.kill(oldPid, "SIGKILL");
+  await waitFor(() => !isProcessAlive(oldPid));
+
+  const supervisor = createToolProcessSupervisor({ policy });
+  await supervisor.start();
+  const newPid = await waitFor(async () => {
+    const pid = (await readJson(daemonPaths({ toolName: "fake-daemon", scope }).pidFile, {})).pid;
+    const status = await readJson(runtime.paths.statusFile, {});
+    return pid && pid !== oldPid && status.state === "ready" ? pid : null;
+  });
+  assert.notEqual(newPid, oldPid);
+  const meta = await readJson(runtime.paths.metaFile, {});
+  assert.deepEqual(meta.startupContext, { health: "ok", marker: "preserved" });
+
+  await supervisor.stop();
+  await runtime.stop();
+});

package/test/model-selection.test.js

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import { resolveChatModel, selectChatModel } from "../src/core/agent/model-selection.js";
+import { applyConfigDefaults, telegramConfigDefaults } from "../src/core/config/config-defaults.js";
+import { getChatPiSessionsDir } from "../src/runtime/paths.js";
+import { buildModelPicker, parseModelPickerAction } from "../src/transport/telegram/model-picker.js";
+
+function createConfig() {
+  return {
+    telegram: {},
+    pi: {
+      provider: "openai-codex",
+      model: "gpt-default"
+    }
+  };
+}
+
+test("resolves the default model until a chat selects one", () => {
+  const config = createConfig();
+
+  assert.equal(resolveChatModel(config, 123), "gpt-default");
+
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-selected" });
+
+  assert.equal(resolveChatModel(config, 123), "gpt-selected");
+  assert.equal(resolveChatModel(config, 456), "gpt-default");
+  assert.deepEqual(config.pi.chatModels["123"], {
+    provider: "openai-codex",
+    model: "gpt-selected",
+    sessionRevision: 1
+  });
+});
+
+test("starts a distinct persisted Pi session revision on every model change", () => {
+  const config = createConfig();
+
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-a" });
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-b" });
+
+  assert.equal(config.pi.chatModels["123"].sessionRevision, 2);
+  assert.equal(
+    getChatPiSessionsDir(123, config.pi.chatModels["123"].sessionRevision),
+    path.join(getChatPiSessionsDir(123), "2")
+  );
+});
+
+test("ignores a chat selection from a different active provider", () => {
+  const config = createConfig();
+  config.pi.chatModels = {
+    123: { provider: "anthropic", model: "claude-selected" }
+  };
+
+  assert.equal(resolveChatModel(config, 123), "gpt-default");
+});
+
+test("rejects selecting a model outside the active provider", () => {
+  const config = createConfig();
+
+  assert.throws(
+    () => selectChatModel(config, 123, { provider: "anthropic", id: "claude-selected" }),
+    /active provider is openai-codex/
+  );
+});
+
+test("builds a paged model picker and marks the current model", () => {
+  const models = [
+    { provider: "openai-codex", id: "gpt-a", reasoning: false, input: ["text"] },
+    { provider: "openai-codex", id: "gpt-b", reasoning: true, input: ["text", "image"] },
+    { provider: "openai-codex", id: "gpt-c", reasoning: false, input: ["text"] }
+  ];
+
+  const picker = buildModelPicker({
+    provider: "openai-codex",
+    models,
+    selectedModelId: "gpt-b",
+    page: 0,
+    pageSize: 2
+  });
+
+  assert.match(picker.text, /openai-codex\/gpt-b/);
+  assert.equal(picker.replyMarkup.inline_keyboard[0][0].callback_data, "model:0");
+  assert.match(picker.replyMarkup.inline_keyboard[1][0].text, /^✓ gpt-b \[reasoning, image\]$/);
+  assert.equal(picker.replyMarkup.inline_keyboard[2][1].callback_data, "model-page:1");
+});
+
+test("parses only model picker callback data", () => {
+  assert.deepEqual(parseModelPickerAction("model:12"), { type: "select", value: 12 });
+  assert.deepEqual(parseModelPickerAction("model-page:2"), { type: "page", value: 2 });
+  assert.deepEqual(parseModelPickerAction("noop:page"), { type: "noop", value: null });
+  assert.equal(parseModelPickerAction("provider:1"), null);
+  assert.equal(parseModelPickerAction("model:-1"), null);
+});
+
+test("centralizes the model picker page size in Telegram config defaults", () => {
+  const config = applyConfigDefaults(createConfig());
+
+  assert.equal(config.telegram.modelPickerPageSize, telegramConfigDefaults.modelPickerPageSize);
+});

package/test-fixtures/fake-daemon.js

@@ -0,0 +1,47 @@
+import { fileURLToPath } from "node:url";
+import {
+  readDaemonLaunchContext,
+  writeJson
+} from "../src/core/tools/daemon-processes.js";
+import { createDaemonRuntime } from "../src/core/tools/daemon-runtime.js";
+
+const toolName = "fake-daemon";
+const entryPath = fileURLToPath(import.meta.url);
+const launch = await readDaemonLaunchContext({ expectedToolName: toolName });
+const runtime = createDaemonRuntime({
+  toolName,
+  entryPath,
+  scope: launch.scope,
+  startupContext: launch.startupContext,
+  autoStart: launch.autoStart
+});
+
+async function healthCheck() {
+  if (launch.startupContext.health === "fail") {
+    throw new Error("synthetic health failure");
+  }
+  if (launch.startupContext.health === "hang") {
+    await new Promise(() => {});
+  }
+  return { message: "synthetic health passed" };
+}
+
+async function recover() {
+  if (!launch.startupContext.recover) return false;
+  await writeJson(`${runtime.paths.root}/recovered.json`, { recovered: true });
+  launch.startupContext.health = "ok";
+  return true;
+}
+
+if (process.argv[2] !== "daemon") {
+  throw new Error("fake daemon only supports the daemon command");
+}
+
+await runtime.workLoop({
+  healthCheck,
+  recover,
+  processJob: async (payload) => {
+    if (payload.action === "fail") throw new Error("synthetic job failure");
+    return { echo: payload.value ?? null };
+  }
+});