arisa 4.3.4 → 5.0.2

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

@@ -1,6 +1,10 @@
 import { formatPiModelOption } from "../../core/agent/pi-runtime.js";
 import { buildPagedInlineKeyboard } from "./paged-inline-keyboard.js";
 
+export function reverseModelOrder(models) {
+  return [...models].reverse();
+}
+
 export function parseModelPickerAction(data) {
   if (data === "noop:page") return { type: "noop", value: null };
   const match = /^(model|model-page):(\d+)$/.exec(String(data || ""));
@@ -31,7 +35,13 @@ export function parseEffortPickerAction(data) {
   return null;
 }
 
-export function buildModelPicker({ provider, models, selectedModelId, selectedThinkingLevel, page, pageSize }) {
+export function parseSpeedPickerAction(data) {
+  if (data === "noop:page") return { type: "noop", value: null };
+  const speed = /^speed:(1(?:\.5)?)$/.exec(String(data || ""));
+  return speed ? { type: "speed", speed: Number(speed[1]) } : null;
+}
+
+export function buildModelPicker({ provider, models, selectedModelId, selectedThinkingLevel, selectedSpeed, page, pageSize }) {
   if (!models.length) {
     throw new Error(`No models available for provider ${provider}`);
   }
@@ -39,12 +49,28 @@ export function buildModelPicker({ provider, models, selectedModelId, selectedTh
     text: `${model.id === selectedModelId ? "✓ " : ""}${formatPiModelOption(model)}`
   }));
   const effortLine = selectedThinkingLevel ? `\nEffort: ${selectedThinkingLevel}` : "";
+  const speedLine = selectedSpeed ? `\nSpeed: ${selectedSpeed.toFixed(1)}x` : "";
   return {
-    text: `Current model: ${provider}/${selectedModelId}${effortLine}\nSelect a model for this chat:`,
+    text: `Current model: ${provider}/${selectedModelId}${effortLine}${speedLine}\nSelect a model for this chat:`,
     replyMarkup: buildPagedInlineKeyboard("model", items, { page, pageSize })
   };
 }
 
+export function buildSpeedPicker({ provider, modelId, speeds, selectedSpeed }) {
+  if (!speeds.length) {
+    throw new Error(`No speed levels available for ${provider}/${modelId}`);
+  }
+  return {
+    text: `Current model: ${provider}/${modelId}\nSelect speed for this chat:`,
+    replyMarkup: {
+      inline_keyboard: speeds.map((speed) => ([{
+        text: `${speed === selectedSpeed ? "✓ " : ""}${speed.toFixed(1)}x`,
+        callback_data: `speed:${speed}`
+      }]))
+    }
+  };
+}
+
 export function buildEffortPicker({
   provider,
   modelId,

package/test/agent-tool-policy.test.js

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 import { buildPiToolPolicy } from "../src/core/agent/core-tools.js";
+import { applyConfigDefaults } from "../src/core/config/config-defaults.js";
 import { appendArisaAgentsFile, arisaAgentsFile } from "../src/core/agent/runtime-context.js";
 import { createSystemShellTool } from "../src/core/agent/system-shell-tool.js";
 import { applyRuntimeOverrides } from "../src/runtime/create-app.js";
@@ -60,7 +61,8 @@ test("applies runtime overrides without dropping persisted Pi config", () => {
       workspaceDir: "/tmp/arisa",
       tools: "read,bash",
       excludeTools: "write",
-      shellTimeoutMs: "90000"
+      shellTimeoutMs: "90000",
+      speed: "1.5"
     }
   });
 
@@ -71,6 +73,29 @@ test("applies runtime overrides without dropping persisted Pi config", () => {
   assert.deepEqual(next.pi.tools, ["read", "bash"]);
   assert.deepEqual(next.pi.excludeTools, ["write"]);
   assert.equal(next.pi.shellTimeoutMs, 90000);
+  assert.equal(next.pi.speed, 1.5);
+});
+
+test("rejects attempts to select another harness", () => {
+  const config = {
+    pi: { provider: "openai-codex", model: "current", apiKey: "pi-key" }
+  };
+  assert.throws(
+    () => applyRuntimeOverrides(config, { agent: { runtime: "another" } }),
+    /Unsupported runtime override namespace: agent/
+  );
+});
+
+test("migrates persisted config to Pi-only state", () => {
+  const config = applyConfigDefaults({
+    agent: { runtime: "legacy" },
+    prime: { provider: "legacy-provider", model: "legacy-model" },
+    pi: { provider: "openai-codex", model: "gpt-5.6" }
+  });
+
+  assert.equal(config.pi.model, "gpt-5.6");
+  assert.equal("agent" in config, false);
+  assert.equal("prime" in config, false);
 });
 
 test("system_shell runs commands from the configured workspace", async () => {

package/test/auth-flow.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { getErrorMessage, getPiAuthIssue } from "../src/core/agent/auth-flow.js";
+import { buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue } from "../src/core/agent/auth-flow.js";
 
 test("extracts messages from Error instances and other thrown values", () => {
   assert.equal(getErrorMessage(new Error("boom")), "boom");
@@ -13,7 +13,8 @@ test("classifies invalidated Pi authentication tokens", () => {
     new Error("authentication token has been invalidated"),
     new Error("Token invalidated by provider"),
     new Error("Please try signing in again"),
-    new Error("auth token expired")
+    new Error("auth token expired"),
+    new Error("Provided authentication token is expired.")
   ]) {
     assert.deepEqual(getPiAuthIssue(error), {
       kind: "invalidated-token",
@@ -40,3 +41,28 @@ test("ignores unrelated Pi errors", () => {
   assert.equal(getPiAuthIssue(new Error("model rate limit exceeded")), null);
   assert.equal(getPiAuthIssue(new Error("")), null);
 });
+
+test("reports the active chat model after authentication", () => {
+  const config = {
+    pi: {
+      provider: "openai-codex",
+      model: "gpt-5.5",
+      apiKey: "",
+      chatModels: {
+        "123": {
+          provider: "openai-codex",
+          model: "gpt-5.6",
+          thinkingLevel: "high",
+          speed: 1,
+          sessionRevision: 4
+        }
+      }
+    }
+  };
+
+  const message = buildPiAuthTelegramMessage({ config, chatId: 123, verified: true });
+
+  assert.match(message, /^Pi authentication is working for openai-codex\/gpt-5\.6\./);
+  assert.doesNotMatch(message, /gpt-5\.5/);
+  assert.equal(config.pi.chatModels["123"].sessionRevision, 4);
+});

package/test/capabilities-security.test.js

@@ -120,9 +120,11 @@ test("requires chatId for chat-scoped IPC methods", async () => {
     "artifacts.createText",
     "artifacts.listRecent",
     "artifacts.get",
+    "artifacts.deliver",
     "tasks.add",
     "tasks.list",
     "tasks.cancel",
+    "tasks.cancelAll",
     "agent.enqueueEvent",
     "paths.getChatToolStateDir",
     "paths.getChatToolTmpDir",
@@ -140,6 +142,41 @@ test("requires chatId for chat-scoped IPC methods", async () => {
   }
 });
 
+test("delivers only artifacts resolved from the requesting chat", async () => {
+  const artifact = { id: "artifact-1", chatId: "chat-a", path: "/safe/chat-a/file.txt" };
+  const deliveries = [];
+  const capabilities = createCapabilities({
+    artifactStore: {
+      forChat: (chatId) => ({
+        get: async (artifactId) => String(chatId) === "chat-a" && artifactId === artifact.id ? artifact : null
+      })
+    },
+    agentManager: {
+      deliverArtifact: async (payload) => {
+        deliveries.push(payload);
+        return { ok: true };
+      }
+    }
+  });
+
+  await assert.rejects(() => capabilities.dispatch({
+    method: "artifacts.deliver",
+    toolName: "ipc-tool",
+    chatId: "chat-b",
+    params: { artifactId: "artifact-1", path: artifact.path }
+  }), /Artifact not found/);
+  assert.equal(deliveries.length, 0);
+
+  await capabilities.dispatch({
+    method: "artifacts.deliver",
+    toolName: "ipc-tool",
+    chatId: "chat-a",
+    params: { artifactId: "artifact-1", path: "/attacker/chosen/path" }
+  });
+  assert.equal(deliveries.length, 1);
+  assert.equal(deliveries[0].artifact.path, artifact.path);
+});
+
 test("normalizes tool run args and rejects arrays", async () => {
   const calls = [];
   const capabilities = createCapabilities({

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

@@ -0,0 +1,279 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  collectText,
+  createChatStateStore,
+  drainChatPromptQueue,
+  isSilentReply,
+  queueChatPrompt,
+  resolveTelegramBusyMessageMode,
+  routeBusyPrompt
+} from "../src/transport/telegram/bot.js";
+import { selectScheduledTasks } from "../src/core/agent/agent-manager.js";
+
+function createSession(events) {
+  const listeners = new Set();
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async prompt() {
+      for (const event of events) {
+        for (const listener of listeners) listener(event);
+      }
+    }
+  };
+}
+
+test("collectText ignores a transient error after a successful retry", async () => {
+  const session = createSession([
+    {
+      type: "message_end",
+      message: {
+        role: "assistant",
+        stopReason: "error",
+        errorMessage: "Codex error: Your input exceeds the context window of this model."
+      }
+    },
+    { type: "message_start", message: { role: "assistant" } },
+    {
+      type: "message_update",
+      message: { role: "assistant" },
+      assistantMessageEvent: { type: "text_delta", delta: "Recovered response" }
+    },
+    { type: "message_end", message: { role: "assistant", stopReason: "stop" } }
+  ]);
+
+  assert.equal(await collectText(session, "hello"), "Recovered response");
+});
+
+test("collectText preserves the final assistant error", async () => {
+  const session = createSession([
+    {
+      type: "message_end",
+      message: { role: "assistant", stopReason: "error", errorMessage: "terminal failure" }
+    }
+  ]);
+
+  await assert.rejects(() => collectText(session, "hello"), /terminal failure/);
+});
+
+test("recognizes standalone silent reply markers", () => {
+  assert.equal(isSilentReply("NO_REPLY"), true);
+  assert.equal(isSilentReply("No reply needed."), true);
+  assert.equal(isSilentReply("No action needed."), true);
+  assert.equal(isSilentReply("\nNO_REPLY\n\nNO_REPLY\n"), true);
+  assert.equal(isSilentReply("No reply needed.\n\nNo action needed."), true);
+});
+
+test("does not suppress real text that mentions a silent reply marker", () => {
+  assert.equal(isSilentReply("NO_REPLY means no notification was needed."), false);
+  assert.equal(isSilentReply("NO_REPLY\n\nThere is an important message."), false);
+  assert.equal(isSilentReply("No action needed unless the token expires."), false);
+  assert.equal(isSilentReply("No reply needed"), false);
+  assert.equal(isSilentReply("no_reply"), false);
+  assert.equal(isSilentReply(""), false);
+});
+
+test("chat state uses one queue for numeric and string chat IDs", () => {
+  const states = createChatStateStore();
+  const telegramState = states.get(879964957);
+  telegramState.processing = true;
+  queueChatPrompt(telegramState, "queued prompt");
+
+  assert.strictEqual(states.get("879964957"), telegramState);
+  assert.equal(states.get("879964957").processing, true);
+  assert.deepEqual(states.get("879964957").pendingPrompts, ["queued prompt"]);
+
+  const resetState = states.reset("879964957");
+  assert.strictEqual(states.get(879964957), resetState);
+  assert.deepEqual(resetState, {
+    processing: false,
+    pendingPrompts: [],
+    continueAfterClose: false,
+    historyRevision: 0,
+    beforeNextPrompt: null,
+    activeSession: null,
+    activeSteers: []
+  });
+});
+
+test("queued prompts retain their message boundaries and order", async () => {
+  const chatState = createChatStateStore().get("chat");
+  chatState.processing = true;
+  queueChatPrompt(chatState, "second request");
+  queueChatPrompt(chatState, "third request");
+  const processed = [];
+
+  await drainChatPromptQueue({
+    chatState,
+    initialPrompt: "first request",
+    processPrompt: async ({ prompt }) => processed.push(prompt)
+  });
+
+  assert.deepEqual(processed, ["first request", "second request", "third request"]);
+});
+
+test("a queued /new continues after the active session closes", async () => {
+  const chatState = createChatStateStore().get("chat");
+  chatState.processing = true;
+  const processed = [];
+  const interruption = new Error("active session closed");
+
+  await drainChatPromptQueue({
+    chatState,
+    initialPrompt: "old request",
+    processPrompt: async ({ prompt }) => {
+      processed.push(prompt);
+      if (prompt === "old request") {
+        queueChatPrompt(chatState, "new session confirmation", { replace: true });
+        chatState.continueAfterClose = true;
+        throw interruption;
+      }
+    }
+  });
+
+  assert.deepEqual(processed, ["old request", "new session confirmation"]);
+  assert.equal(chatState.processing, false);
+  assert.deepEqual(chatState.pendingPrompts, []);
+});
+
+test("exclusive pre-prompt work keeps concurrent messages queued", async () => {
+  const chatState = createChatStateStore().get("chat");
+  chatState.processing = true;
+  const processed = [];
+  let releasePreparation;
+  const preparation = new Promise((resolve) => { releasePreparation = resolve; });
+
+  const draining = drainChatPromptQueue({
+    chatState,
+    initialPrompt: "new session confirmation",
+    beforeInitialPrompt: () => preparation,
+    processPrompt: async ({ prompt }) => processed.push(prompt)
+  });
+  await new Promise((resolve) => setImmediate(resolve));
+  queueChatPrompt(chatState, "message received during handoff");
+  releasePreparation();
+  await draining;
+
+  assert.deepEqual(processed, ["new session confirmation", "message received during handoff"]);
+  assert.equal(chatState.processing, false);
+});
+
+test("a queued /new supersedes the initial prompt after exclusive preparation", async () => {
+  const chatState = createChatStateStore().get("chat");
+  chatState.processing = true;
+  const processed = [];
+  let releasePreparation;
+  const preparation = new Promise((resolve) => { releasePreparation = resolve; });
+
+  const draining = drainChatPromptQueue({
+    chatState,
+    initialPrompt: "first new session confirmation",
+    beforeInitialPrompt: () => preparation,
+    processPrompt: async ({ prompt }) => processed.push(prompt)
+  });
+  await new Promise((resolve) => setImmediate(resolve));
+  queueChatPrompt(chatState, "latest new session confirmation", { replace: true });
+  chatState.continueAfterClose = true;
+  releasePreparation();
+  await draining;
+
+  assert.deepEqual(processed, ["latest new session confirmation"]);
+  assert.equal(chatState.processing, false);
+});
+
+test("busy message mode supports global defaults and per-chat overrides", () => {
+  const config = {
+    telegram: {
+      busyMessageMode: "queue",
+      chatMeta: { "879964957": { busyMessageMode: "steer" } }
+    }
+  };
+
+  assert.equal(resolveTelegramBusyMessageMode(config, 879964957), "steer");
+  assert.equal(resolveTelegramBusyMessageMode(config, 123), "queue");
+  assert.equal(resolveTelegramBusyMessageMode({ telegram: { busyMessageMode: "invalid" } }, 123), "queue");
+});
+
+test("steer mode sends text to the active Pi session", async () => {
+  const received = [];
+  const chatState = createChatStateStore().get("chat");
+  chatState.activeSession = {
+    isStreaming: true,
+    async steer(prompt) { received.push(prompt); }
+  };
+
+  const result = await routeBusyPrompt({ chatState, prompt: "change direction", mode: "steer" });
+
+  assert.equal(result.disposition, "steered");
+  assert.deepEqual(received, ["change direction"]);
+  assert.deepEqual(chatState.activeSteers, ["change direction"]);
+  assert.deepEqual(chatState.pendingPrompts, []);
+});
+
+test("failed or unavailable steering falls back to the ordered queue", async () => {
+  const chatState = createChatStateStore().get("chat");
+  chatState.activeSession = {
+    isStreaming: true,
+    async steer() { throw new Error("stream ended"); }
+  };
+
+  const failed = await routeBusyPrompt({ chatState, prompt: "keep this", mode: "steer" });
+  chatState.activeSession = null;
+  const unavailable = await routeBusyPrompt({ chatState, prompt: "and this", mode: "steer" });
+
+  assert.equal(failed.disposition, "queued");
+  assert.match(failed.steerError.message, /stream ended/);
+  assert.equal(unavailable.disposition, "queued");
+  assert.deepEqual(chatState.pendingPrompts, ["keep this", "and this"]);
+});
+
+test("a pending /new forces later text into the replacement queue", async () => {
+  const steered = [];
+  const chatState = createChatStateStore().get("chat");
+  chatState.continueAfterClose = true;
+  chatState.activeSession = {
+    isStreaming: true,
+    async steer(prompt) { steered.push(prompt); }
+  };
+  queueChatPrompt(chatState, "new session confirmation", { replace: true });
+
+  const result = await routeBusyPrompt({ chatState, prompt: "message after new", mode: "steer" });
+
+  assert.equal(result.disposition, "queued");
+  assert.deepEqual(steered, []);
+  assert.deepEqual(chatState.pendingPrompts, ["new session confirmation", "message after new"]);
+});
+
+test("selectScheduledTasks bounds history while keeping active tasks", () => {
+  const tasks = Array.from({ length: 55 }, (_, index) => ({
+    id: `done-${index}`,
+    status: "done"
+  }));
+  tasks[0] = { id: "pending-1", status: "pending" };
+
+  const result = selectScheduledTasks(tasks);
+
+  assert.equal(result.total, 55);
+  assert.equal(result.returned, 50);
+  assert.equal(result.limit, 50);
+  assert.equal(result.truncated, true);
+  assert.equal(result.tasks[0].id, "pending-1");
+});
+
+test("selectScheduledTasks honors an explicit status and limit", () => {
+  const tasks = [
+    { id: "done-1", status: "done" },
+    { id: "done-2", status: "done" }
+  ];
+
+  const result = selectScheduledTasks(tasks, { status: "done", limit: 1 });
+
+  assert.deepEqual(result.tasks.map((task) => task.id), ["done-2"]);
+  assert.equal(result.total, 2);
+  assert.equal(result.returned, 1);
+  assert.equal(result.limit, 1);
+  assert.equal(result.truncated, true);
+});

package/test/daemon-runtime.test.js

@@ -34,14 +34,19 @@ await writeFile(
 const {
   daemonPaths,
   isProcessAlive,
+  readDaemonDiagnostic,
   readJson,
-  stopManagedDaemon
+  stopManagedDaemon,
+  unregisterManagedDaemon,
+  writeDaemonStatus
 } = 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 { createToolProcessSupervisor, formatDaemonOutcome } = await import("../src/runtime/tool-process-supervisor.js");
+const { superviseDaemon } = await import("../src/core/tools/daemon-health.js");
+const { ToolRegistry } = await import("../src/core/tools/tool-registry.js");
 
 const fixtureEntry = fileURLToPath(new URL("../test-fixtures/fake-daemon.js", import.meta.url));
 
@@ -148,6 +153,37 @@ test("supervisor ignores invalid chat directories and recovers valid daemons", a
   }
 });
 
+test("does not restart registrations whose scope no longer matches the tool manifest", async () => {
+  const runtime = runtimeFor({ type: "global" }, { autoStart: true });
+  const registry = new ToolRegistry();
+  registry.tools.set("fake-daemon", {
+    name: "fake-daemon",
+    entry: fixtureEntry,
+    daemon: { scope: "chat", autoStart: false, health: "internal" }
+  });
+
+  await runtime.start();
+  await runtime.stop();
+  await writeDaemonStatus(runtime.paths, {
+    state: "failed",
+    pid: null,
+    restartAttempts: policy.restartLimit + 1,
+    restartRequested: false,
+    message: "Legacy global registration"
+  });
+
+  const supervisor = createToolProcessSupervisor({ policy, toolRegistry: registry });
+  const results = await supervisor.repair();
+  const result = results.find((item) => item.record.toolName === "fake-daemon" && item.record.instanceId === "global");
+
+  assert.equal(result.outcome, "stale-registration");
+  assert.match(result.reason, /global scope does not match manifest chat scope/);
+  assert.equal(isProcessAlive(await runtime.getPid()), false);
+
+  await unregisterManagedDaemon({ toolName: "fake-daemon", scope: { type: "global" } });
+  assert.deepEqual(await readJson(runtime.paths.metaFile, null), null);
+});
+
 test("rejects stale readiness even when the pid is alive", async () => {
   const status = {
     state: "ready",
@@ -170,6 +206,98 @@ test("does not auto-start an intentionally stopped on-demand daemon", async () =
   await supervisor.stop();
 });
 
+test("describes an intentionally stopped on-demand daemon without treating it as a failure", async () => {
+  const runtime = runtimeFor({ type: "global" }, { autoStart: false });
+  await writeDaemonStatus(runtime.paths, {
+    state: "stopped",
+    pid: null,
+    message: "Idle timeout reached",
+    restartAttempts: 0,
+    restartRequested: false
+  });
+
+  const diagnostic = await readDaemonDiagnostic(runtime.registration);
+  assert.equal(diagnostic.state, "stopped");
+  assert.equal(diagnostic.disposition, "leave-stopped");
+  assert.equal(diagnostic.lastError, null);
+});
+
+test("keeps a terminal daemon failure stable until it receives explicit attention", async () => {
+  const runtime = runtimeFor({ type: "global" }, { autoStart: true });
+  await writeDaemonStatus(runtime.paths, {
+    state: "failed",
+    pid: null,
+    message: "Daemon restart limit reached: synthetic crash",
+    restartAttempts: policy.restartLimit + 1,
+    restartRequested: false,
+    lastError: { phase: "restart", message: "synthetic crash token=private-value", code: "SYNTHETIC" }
+  });
+
+  assert.equal(await superviseDaemon(runtime.registration, policy), "failed");
+  assert.equal(await superviseDaemon(runtime.registration, policy), "failed");
+  const status = await readJson(runtime.paths.statusFile, {});
+  assert.equal(status.restartAttempts, policy.restartLimit + 1);
+
+  const diagnostic = await readDaemonDiagnostic(runtime.registration);
+  assert.equal(diagnostic.disposition, "requires-attention");
+  assert.equal(diagnostic.lastError.code, "SYNTHETIC");
+  assert.equal(diagnostic.lastError.message, "synthetic crash token=[redacted]");
+  assert.match(
+    formatDaemonOutcome(runtime.registration, "failed", diagnostic, policy),
+    /failed \| error\[restart\]=synthetic crash token=\[redacted\] \| code=SYNTHETIC \| restarts=3\/2 \| action=requires-attention \| log=/
+  );
+});
+
+test("doctor repair gives a terminal daemon one explicit restart attempt", async () => {
+  const runtime = runtimeFor({ type: "global" }, { autoStart: true });
+  await writeDaemonStatus(runtime.paths, {
+    state: "failed",
+    pid: null,
+    message: "Daemon restart limit reached",
+    restartAttempts: policy.restartLimit + 1,
+    restartRequested: false
+  });
+  const supervisor = createToolProcessSupervisor({ policy });
+
+  try {
+    const results = await supervisor.repair();
+    const result = results.find((item) => item.record.toolName === "fake-daemon" && item.record.instanceId === "global");
+    assert.equal(result.outcome, "started");
+    assert.equal((await readJson(runtime.paths.statusFile, {})).restartAttempts, 0);
+    assert.equal(isProcessAlive(await runtime.getPid()), true);
+  } finally {
+    await runtime.stop().catch(() => {});
+  }
+});
+
+test("includes scoped daemon diagnostics when Arisa lists tools", async () => {
+  const runtime = runtimeFor({ type: "chat", chatId: "101" }, { autoStart: false });
+  await writeDaemonStatus(runtime.paths, {
+    state: "stopped",
+    pid: null,
+    message: "Idle timeout reached",
+    restartAttempts: 0,
+    restartRequested: false
+  });
+  const registry = new ToolRegistry();
+  registry.tools.set("fake-daemon", {
+    name: "fake-daemon",
+    description: "Fake daemon",
+    input: [],
+    output: [],
+    configSchema: {},
+    category: null,
+    keywords: [],
+    skillHints: [],
+    daemon: { scope: "chat", autoStart: false, health: "internal" }
+  });
+
+  const [tool] = await registry.listWithRuntime("101");
+  assert.equal(tool.daemon.scope, "chat");
+  assert.equal(tool.daemon.runtime.state, "stopped");
+  assert.equal(tool.daemon.runtime.disposition, "leave-stopped");
+});
+
 test("external supervisor recovers internally before restarting", async () => {
   const runtime = runtimeFor({ type: "global" }, {
     autoStart: true,

package/test/dependency-warnings.test.js

@@ -0,0 +1,17 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const packageDir = fileURLToPath(new URL("..", import.meta.url));
+
+test("imports grammy without the deprecated built-in punycode module", () => {
+  const result = spawnSync(
+    process.execPath,
+    ["--trace-deprecation", "--input-type=module", "--eval", "await import('grammy')"],
+    { cwd: packageDir, encoding: "utf8" },
+  );
+
+  assert.equal(result.status, 0, result.stderr);
+  assert.doesNotMatch(result.stderr, /DEP0040|punycode.*deprecated/i);
+});