arisa 5.1.68 → 5.2.17

package/test/session-rotation.test.js

@@ -0,0 +1,110 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { applyConfigDefaults } from "../src/core/config/config-defaults.js";
+import { AgentManager } from "../src/core/agent/agent-manager.js";
+import { compactionRotationRequest, normalizeSessionRotationPolicy } from "../src/core/agent/session-rotation.js";
+
+const mebibyte = 1024 * 1024;
+
+function compactionEvent(summary = "checkpoint") {
+  return {
+    type: "compaction_end",
+    aborted: false,
+    errorMessage: "",
+    result: { summary }
+  };
+}
+
+test("normalizes the automatic session rotation policy", () => {
+  assert.deepEqual(normalizeSessionRotationPolicy(), {
+    enabled: true,
+    compactAtPersistedBytes: 24 * mebibyte,
+    maxPersistedBytes: 32 * mebibyte
+  });
+  assert.deepEqual(normalizeSessionRotationPolicy({
+    enabled: false,
+    compactAtPersistedBytes: 8,
+    maxPersistedBytes: 12
+  }), {
+    enabled: false,
+    compactAtPersistedBytes: 8,
+    maxPersistedBytes: 12
+  });
+});
+
+test("requests rotation only after a successful oversized compaction", () => {
+  assert.equal(compactionRotationRequest(compactionEvent(), 24 * mebibyte), null);
+  assert.equal(compactionRotationRequest({ ...compactionEvent(), aborted: true }, 25 * mebibyte), null);
+  assert.equal(compactionRotationRequest(compactionEvent(), 25 * mebibyte, { enabled: false }), null);
+  const request = compactionRotationRequest(compactionEvent("latest summary"), 25 * mebibyte);
+  assert.equal(request.persistedBytes, 25 * mebibyte);
+  assert.match(request.handoff, /latest summary/);
+});
+
+test("compacts at the preventive persisted-size threshold and then rotates", async () => {
+  const config = applyConfigDefaults({ telegram: {}, pi: { provider: "test", model: "test" } });
+  const manager = new AgentManager({
+    config,
+    artifactStore: {},
+    toolRegistry: {},
+    taskStore: {},
+    logger: null
+  });
+  let compactions = 0;
+  const context = {
+    activeUsers: 1,
+    session: {
+      sessionFile: "/sessions/preventive.jsonl",
+      async compact() {
+        compactions += 1;
+        manager.scheduleCompactionRotationCheck("chat", context, compactionEvent("preventive summary"));
+      },
+      async close() {}
+    },
+    rotationCheckPromise: Promise.resolve(),
+    rotationRequest: null
+  };
+  manager.sessions.set("chat", context);
+  manager.estimatePersistedSessionBytes = async () => 25 * mebibyte;
+
+  await manager.releaseSessionContext("chat", context);
+
+  assert.equal(compactions, 1);
+  assert.equal(manager.sessions.has("chat"), false);
+  assert.equal(manager.pendingNewSessions.has("chat"), true);
+});
+
+test("rotates after active work releases and preserves the parent session path", async () => {
+  const config = applyConfigDefaults({ telegram: {}, pi: { provider: "test", model: "test" } });
+  let closes = 0;
+  const manager = new AgentManager({
+    config,
+    artifactStore: {},
+    toolRegistry: {},
+    taskStore: {},
+    logger: null
+  });
+  const context = {
+    activeUsers: 1,
+    session: {
+      sessionFile: "/sessions/oversized.jsonl",
+      async close() { closes += 1; }
+    },
+    rotationCheckPromise: Promise.resolve(),
+    rotationRequest: null
+  };
+  manager.sessions.set("chat", context);
+  manager.estimatePersistedSessionBytes = async () => 65 * mebibyte;
+
+  manager.scheduleCompactionRotationCheck("chat", context, compactionEvent("handoff summary"));
+  await manager.releaseSessionContext("chat", context);
+
+  assert.equal(closes, 1);
+  assert.equal(manager.sessions.has("chat"), false);
+  assert.equal(manager.pendingNewSessions.has("chat"), true);
+  assert.deepEqual(manager.pendingSessionHandoffs.get("chat"), {
+    text: "Automatic session rotation after compaction. Continue from this checkpoint:\n\nhandoff summary",
+    parentSession: "/sessions/oversized.jsonl",
+    source: "compaction-rotation"
+  });
+});

package/test/task-store.test.js

@@ -121,6 +121,38 @@ test("recovers interrupted running tasks for retry after restart", async () => {
   );
 });
 
+test("persists auth blocks, claims only due probes, and clears the block after success", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  await store.add({
+    id: "auth-poll",
+    kind: "poll_tool",
+    runAt: new Date(Date.now() - 1000).toISOString(),
+    payload: { toolName: "checker", args: { action: "poll" } },
+    recurrence: { type: "interval", everySeconds: 60 }
+  });
+
+  await store.claimDue();
+  const blocked = await store.blockAuth("auth-poll", "authentication expired", {
+    retryAfterSeconds: 3600,
+    probeArgs: { action: "auth-status" }
+  });
+  assert.equal(blocked.status, "blocked_auth");
+  assert.equal(blocked.authBlockedNew, true);
+  assert.deepEqual(blocked.authBlock.probeArgs, { action: "auth-status" });
+  assert.deepEqual(await store.claimDue(), []);
+
+  store.tasks.find((task) => task.id === "auth-poll").runAt = new Date(Date.now() - 1000).toISOString();
+  await store.save();
+  const [probe] = await store.claimDue();
+  assert.equal(probe.status, "running");
+  assert.ok(probe.authBlock);
+
+  const completed = await store.complete("auth-poll");
+  assert.equal(completed.status, "pending");
+  assert.equal(completed.authBlock, undefined);
+});
+
 test("completes one-off tasks and re-schedules recurring interval tasks", async () => {
   await resetHome();
   const store = new TaskStore();

package/test/telegram-prompt-controller.test.js

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createChatStateStore } from "../src/transport/telegram/chat-queue.js";
+import { createTelegramPromptController } from "../src/transport/telegram/telegram-prompt-controller.js";
+
+function createController(overrides = {}) {
+  const stateStore = createChatStateStore();
+  const calls = { cleared: [], reset: [], steered: [] };
+  const controller = createTelegramPromptController({
+    config: { pi: { chatModels: {} }, telegram: {} },
+    api: {},
+    artifactStore: {},
+    toolRegistry: {},
+    agentManager: {
+      resetSession: (...args) => calls.reset.push(args),
+      runTurn: async (_options, work) => work()
+    },
+    sessionSeeds: {
+      clear: async (chatId) => calls.cleared.push(chatId)
+    },
+    workspaceTopics: {},
+    contextRoute: (ctx) => ctx.route,
+    getChatState: (chatId) => stateStore.get(chatId),
+    createTelegramSessionBridge: () => ({}),
+    createWorkspaceAccessGuard: () => async () => {},
+    sendTextReply: async () => {},
+    authController: { notifyIssueIfNeeded: async () => false },
+    ensureWorkspaceTopicModelSelection: async () => {},
+    ensureQueuedTyping: async () => {},
+    withTyping: async (_ctx, work) => work(),
+    resolveBusyMessageMode: () => "steer",
+    ...overrides
+  });
+  return { controller, stateStore, calls };
+}
+
+test("busy /new resets only the active session and replaces its queued prompt", async () => {
+  const { controller, stateStore, calls } = createController();
+  const route = {
+    workspace: true,
+    sessionId: "topic-87",
+    scopeChatId: "owner",
+    transportChatId: "group",
+    threadId: 87
+  };
+  const state = stateStore.get(route.sessionId);
+  state.processing = true;
+  state.pendingPrompts.push("stale prompt");
+
+  await controller.handleNewCommand({ route, from: { language_code: "es" } });
+
+  assert.deepEqual(calls.cleared, [route.sessionId]);
+  assert.deepEqual(calls.reset, [[route.sessionId]]);
+  assert.equal(state.pendingPrompts.length, 1);
+  assert.match(state.pendingPrompts[0], /System event: \/new requested/);
+  assert.equal(state.continueAfterClose, true);
+});
+
+test("a busy prompt for another topic queues instead of steering the active session", async () => {
+  const { controller, stateStore, calls } = createController();
+  const state = stateStore.get("topic-session");
+  state.processing = true;
+  state.activeRoute = { transportChatId: "group", threadId: 87 };
+  state.activeSession = {
+    isStreaming: true,
+    steer: async (prompt) => calls.steered.push(prompt)
+  };
+  const ctx = {
+    route: { transportChatId: "group", threadId: 114 }
+  };
+
+  await controller.enqueuePrompt({
+    chatId: "topic-session",
+    prompt: "different destination",
+    label: "cross-topic prompt",
+    ctx,
+    busyMessageMode: "steer"
+  });
+
+  assert.deepEqual(calls.steered, []);
+  assert.deepEqual(state.pendingPrompts, ["different destination"]);
+});

package/test/telegram-task-dispatcher.test.js

@@ -7,6 +7,10 @@ function createHarness(overrides = {}) {
   const taskStore = {
     async fail(...args) { calls.push(["fail", ...args]); return { status: "failed" }; },
     async complete(...args) { calls.push(["complete", ...args]); return { status: "done" }; },
+    async blockAuth(taskId, error, resolution) {
+      calls.push(["blockAuth", taskId, error.message, resolution]);
+      return { status: "blocked_auth", authBlockedNew: true, runAt: "2026-09-02T05:00:00.000Z" };
+    },
     async retryOrFail(taskId, error, options) {
       calls.push(["retryOrFail", taskId, error.message, options]);
       return { status: options.retryable ? "pending" : "failed" };
@@ -21,7 +25,10 @@ function createHarness(overrides = {}) {
     artifactStore: { forChat() { throw new Error("unexpected artifact access"); } },
     toolRegistry: {},
     resourceNotes: { async get() { return ""; } },
-    agentManager: { async runTool(input) { calls.push(["runTool", input]); return { ok: true }; } },
+    agentManager: {
+      async runTurn(options, work) { calls.push(["runTurn", options]); return work(); },
+      async runTool(input) { calls.push(["runTool", input]); return { ok: true }; }
+    },
     logger: null,
     ...overrides.dependencies
   });
@@ -74,7 +81,9 @@ test("passes bounded execution deadlines to scheduled prompts", async () => {
 
   const enqueues = calls.filter(([name]) => name === "enqueue");
   assert.equal(enqueues[0][1].timeoutMs, 900);
+  assert.equal(enqueues[0][1].priority, "background");
   assert.equal(enqueues[1][1].timeoutMs, 300);
+  assert.equal(enqueues[1][1].priority, "interactive");
 });
 
 test("acknowledges an agent event before executing it", async () => {
@@ -101,15 +110,66 @@ test("runs poll tools headlessly and confirms their result", async () => {
   });
 
   assert.deepEqual(calls, [
+    ["runTurn", { priority: "background", label: "poll tool checker" }],
     ["runTool", { name: "checker", request: { args: { cursor: "4" } }, chatId: 123 }],
     ["complete", "poll-1"]
   ]);
 });
 
+test("pauses a poll once when its tool reports terminal authentication failure", async () => {
+  const resolution = {
+    type: "reauthentication_required",
+    retryAfterSeconds: 3600,
+    probeArgs: { action: "auth-status" }
+  };
+  const { calls, dispatcher } = createHarness({
+    dependencies: {
+      agentManager: {
+        async runTurn(options, work) { calls.push(["runTurn", options]); return work(); },
+        async runTool(input) {
+          calls.push(["runTool", input]);
+          return { ok: false, status: "blocked_auth", error: "authentication expired", resolution };
+        }
+      }
+    }
+  });
+
+  await dispatcher.runClaimedTask({
+    id: "poll-auth",
+    kind: "poll_tool",
+    payload: { chatId: 123, toolName: "checker", args: { action: "poll" } }
+  });
+
+  assert.deepEqual(calls.at(-2), ["blockAuth", "poll-auth", "authentication expired", resolution]);
+  assert.deepEqual(calls.at(-1), [
+    "send",
+    123,
+    "⚠️ Arisa automation paused for authentication\nTool: checker\nReason: authentication expired\nNext authentication check: 2026-09-02T05:00:00.000Z",
+    undefined
+  ]);
+});
+
+test("uses a lightweight auth probe before resuming blocked poll work", async () => {
+  const { calls, dispatcher } = createHarness();
+  await dispatcher.runClaimedTask({
+    id: "poll-resume",
+    kind: "poll_tool",
+    authBlock: { probeArgs: { action: "auth-status" }, retryAfterSeconds: 3600 },
+    payload: { chatId: 123, toolName: "checker", args: { action: "poll" } }
+  });
+
+  assert.deepEqual(calls.filter(([name]) => name === "runTool").map((call) => call[1].request.args), [
+    { action: "auth-status" },
+    { action: "poll" }
+  ]);
+  assert.deepEqual(calls.at(-1), ["complete", "poll-resume"]);
+});
+
 test("retries a known poll failure with backoff", async () => {
   const { calls, dispatcher } = createHarness({
     dependencies: {
       agentManager: {
+        async runTurn(options, work) { calls.push(["runTurn", options]); return work(); },
         async runTool(input) {
           calls.push(["runTool", input]);
           return { ok: false, status: "failed", error: "temporary checker failure" };
@@ -220,10 +280,11 @@ test("due-task dispatch retries one failure without blocking another task", asyn
 
   await dispatcher.dispatchDueTasks();
 
-  assert.deepEqual(calls, [
+  assert.deepEqual(calls.slice(0, 3), [
     ["claimDue", 10],
-    ["runTool", { name: "checker", request: { args: {} }, chatId: 123 }],
-    ["complete", "good"],
-    ["retryOrFail", "bad", "queue unavailable", { retryable: true }]
+    ["runTurn", { priority: "background", label: "poll tool checker" }],
+    ["runTool", { name: "checker", request: { args: {} }, chatId: 123 }]
   ]);
+  assert.ok(calls.some((call) => JSON.stringify(call) === JSON.stringify(["complete", "good"])));
+  assert.ok(calls.some((call) => JSON.stringify(call) === JSON.stringify(["retryOrFail", "bad", "queue unavailable", { retryable: true }])));
 });

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

@@ -110,6 +110,36 @@ test("surfaces Telegram forwarding provenance in the prompt", () => {
   assert.match(prompt, /forwardedAt: 2026-/);
 });
 
+test("surfaces Telegram selected quote text when the replied message has no body", () => {
+  const ctx = createTextContext("update that too");
+  ctx.message.reply_to_message = {
+    message_id: 824,
+    from: { username: "ArisaWaybot" }
+  };
+  ctx.message.quote = { text: "master-slave 0.1.9" };
+
+  const prompt = buildPrompt({ ctx });
+
+  assert.match(prompt, /quotedMessageId: 824/);
+  assert.match(prompt, /quotedSelection: master-slave 0\.1\.9/);
+  assert.doesNotMatch(prompt, /no textual body available/);
+});
+
+test("surfaces quoted Telegram forum topic metadata", () => {
+  const ctx = createTextContext("continue here");
+  ctx.message.reply_to_message = {
+    message_id: 824,
+    from: { username: "ArisaWaybot" },
+    forum_topic_created: { name: "storybot" }
+  };
+
+  const prompt = buildPrompt({ ctx });
+
+  assert.match(prompt, /quotedKind: forum_topic_created/);
+  assert.match(prompt, /quotedTopicName: storybot/);
+  assert.doesNotMatch(prompt, /no textual body available/);
+});
+
 test("formats Telegram reaction changes as lightweight feedback", () => {
   const prompt = buildReactionPrompt({
     reaction: {

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

@@ -8,7 +8,9 @@ const homeDir = await mkdtemp(path.join(os.tmpdir(), "arisa-tool-registry-home-"
 process.env.HOME = homeDir;
 process.env.USERPROFILE = homeDir;
 
-const { ToolRegistry, createToolOutputParser } = await import("../src/core/tools/tool-registry.js");
+const { ToolRegistry, createToolOutputParser, isolatedToolProcessInvocation, readyDaemonAdmission } = await import("../src/core/tools/tool-registry.js");
+const { createToolOutputParser: directToolOutputParser } = await import("../src/core/tools/tool-process-output.js");
+const { isolatedToolProcessInvocation: directToolProcessInvocation } = await import("../src/core/tools/tool-process-runner.js");
 const {
   arisaHomeDir,
   arisaPackageDir,
@@ -98,6 +100,33 @@ setInterval(() => {}, 1_000);
   return dir;
 }
 
+test("preserves process helpers through the ToolRegistry compatibility facade", () => {
+  assert.equal(createToolOutputParser, directToolOutputParser);
+  assert.equal(isolatedToolProcessInvocation, directToolProcessInvocation);
+});
+
+test("wraps declared Linux tool processes in a memory-limited cgroup", () => {
+  assert.deepEqual(isolatedToolProcessInvocation(
+    ["--max-old-space-size=192", "/tool/index.js", "run"],
+    { maxMemoryMb: 384 },
+    { platform: "linux", systemdAvailable: true, oomAdjustAvailable: true }
+  ), {
+    command: "systemd-run",
+    args: [
+      "--scope", "--quiet", "--collect", "--slice=arisa-tools.slice",
+      "-p", "MemoryHigh=326M",
+      "-p", "MemoryMax=384M",
+      "-p", "MemorySwapMax=128M",
+      "--", "choom", "-n", "500", "--", "node", "--max-old-space-size=192", "/tool/index.js", "run"
+    ],
+    isolated: true
+  });
+  assert.equal(isolatedToolProcessInvocation(["tool.js"], { maxMemoryMb: 384 }, {
+    platform: "darwin",
+    systemdAvailable: false
+  }).isolated, false);
+});
+
 test("loads and lists installed tools from the user tools directory", async () => {
   await resetHome();
   await createFakeTool("fake-tool", {
@@ -172,7 +201,10 @@ test("loads weighted execution metadata from the tool manifest", async () => {
   assert.deepEqual(registry.get("heavy-tool").execution, {
     resourceClass: "browser",
     weight: 2,
-    deduplicateConcurrent: false
+    deduplicateConcurrent: false,
+    maxHeapMb: 4096,
+    maxMemoryMb: 16_384,
+    maxOutputBytes: 1_048_576
   });
 });
 
@@ -210,6 +242,15 @@ test("reports dependency status in help and blocks a tool with a missing depende
   );
 });
 
+test("only a live ready declared daemon bypasses worker RSS spawn admission", () => {
+  const tool = { daemon: { scope: "chat", health: "internal" } };
+  assert.deepEqual(readyDaemonAdmission(tool, { alive: true, state: "ready", restart: { requested: false } }), { ignoreWorkerRss: true });
+  assert.deepEqual(readyDaemonAdmission(tool, { alive: false, state: "ready", restart: { requested: false } }), {});
+  assert.deepEqual(readyDaemonAdmission(tool, { alive: true, state: "degraded", restart: { requested: false } }), {});
+  assert.deepEqual(readyDaemonAdmission(tool, { alive: true, state: "ready", restart: { requested: true } }), {});
+  assert.deepEqual(readyDaemonAdmission({}, { alive: true, state: "ready" }), {});
+});
+
 test("wraps declared tool runs in the shared execution governor", async () => {
   await resetHome();
   await createFakeTool("heavy-tool", {
@@ -232,7 +273,14 @@ test("wraps declared tool runs in the shared execution governor", async () => {
   assert.deepEqual(calls, [
     {
       type: "acquire",
-      execution: { resourceClass: "browser", weight: 1, deduplicateConcurrent: false },
+      execution: {
+        resourceClass: "browser",
+        weight: 1,
+        deduplicateConcurrent: false,
+        maxHeapMb: 4096,
+        maxMemoryMb: 16_384,
+        maxOutputBytes: 1_048_576
+      },
       label: "heavy-tool"
     },
     { type: "release", label: "heavy-tool" }
@@ -252,7 +300,13 @@ await new Promise((resolve) => setTimeout(resolve, 100));
 process.stdout.write(JSON.stringify({ ok: true, output: { text: request.args.value } }));
 `, "utf8");
   const counterFile = path.join(homeDir, "single-flight-count.txt");
-  const registry = new ToolRegistry({ executionPolicy: { capacities: { orchestrator: 1 } } });
+  const registry = new ToolRegistry({
+    executionPolicy: {
+      capacities: { orchestrator: 1 },
+      maxWorkerRssMb: 4096,
+      maxSwapUsedPercent: 100
+    }
+  });
   await registry.load();
   const invocation = {
     name: "single-flight-tool",
@@ -398,6 +452,57 @@ test("parses fragmented NDJSON incrementally and keeps stderr diagnostic-only",
   assert.doesNotMatch(JSON.stringify(events), /stream diagnostic/);
 });
 
+test("contains an isolated tool heap failure and keeps the registry alive", async () => {
+  await resetHome();
+  const dir = await createFakeTool("heap-bomb-tool", {
+    execution: {
+      resourceClass: "browser",
+      weight: 1,
+      maxHeapMb: 64,
+      maxMemoryMb: 128,
+      maxOutputBytes: 65_536
+    }
+  });
+  await writeFile(path.join(dir, "index.js"), `
+const retained = [];
+while (true) retained.push(new Array(1_000_000).fill("heap-pressure"));
+`, "utf8");
+  await createFakeTool("healthy-after-oom");
+  const registry = new ToolRegistry({
+    runTimeoutMs: 30_000,
+    executionPolicy: { maxWorkerRssMb: 4096, maxSwapUsedPercent: 100 }
+  });
+  await registry.load();
+
+  const failed = await registry.run({ name: "heap-bomb-tool", chatId: "chat-1", request: { args: {} } });
+  assert.equal(failed.ok, false);
+  assert.equal(failed.status, "outcome_uncertain");
+
+  const healthy = await registry.run({ name: "healthy-after-oom", chatId: "chat-1", request: { args: {} } });
+  assert.equal(healthy.ok, true);
+});
+
+test("terminates oversized isolated tool output without taking down the registry", async () => {
+  await resetHome();
+  const dir = await createFakeTool("oversized-tool", {
+    execution: { resourceClass: "browser", weight: 1, maxOutputBytes: 65_536 }
+  });
+  await writeFile(path.join(dir, "index.js"), `process.stdout.write("x".repeat(70_000));`, "utf8");
+  await createFakeTool("healthy-tool");
+  const registry = new ToolRegistry({
+    executionPolicy: { maxWorkerRssMb: 4096, maxSwapUsedPercent: 100 }
+  });
+  await registry.load();
+
+  const oversized = await registry.run({ name: "oversized-tool", chatId: "chat-1", request: { args: {} } });
+  assert.equal(oversized.ok, false);
+  assert.equal(oversized.status, "outcome_uncertain");
+  assert.match(oversized.error, /exceeds 65536 bytes/);
+
+  const healthy = await registry.run({ name: "healthy-tool", chatId: "chat-1", request: { args: {} } });
+  assert.equal(healthy.ok, true);
+});
+
 test("rejects invalid NDJSON sequences and a second terminal event", async () => {
   const invalidSequence = createToolOutputParser("sequence-tool");
   await invalidSequence.push(`${JSON.stringify({ version: 1, jobId: "job", type: "accepted", sequence: 1, payload: {} })}\n`);
@@ -414,6 +519,14 @@ test("rejects invalid NDJSON sequences and a second terminal event", async () =>
   );
 });
 
+test("bounds accumulated legacy output before parsing", async () => {
+  const parser = createToolOutputParser("legacy-tool", { maxOutputBytes: 10 });
+  await assert.rejects(
+    () => parser.push("12345678901"),
+    (error) => error.code === "TOOL_OUTPUT_LIMIT"
+  );
+});
+
 test("preserves pretty-printed single JSON tool responses", async () => {
   const parser = createToolOutputParser("legacy-tool");
   const output = JSON.stringify({ ok: true, output: { text: "legacy" } }, null, 2);

package/test/tui.test.js

@@ -0,0 +1,41 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createTuiCapabilityTools, resolveTuiChatId } from "../src/runtime/tui.js";
+
+test("uses the first authorized owner scope for TUI capabilities", () => {
+  assert.equal(resolveTuiChatId({ telegram: { authorizedChatIds: [879964957, 2] } }), 879964957);
+  assert.throws(() => resolveTuiChatId({ telegram: { authorizedChatIds: [] } }), /authorized chat/);
+});
+
+test("adapts Pi TUI tools to the running Arisa IPC service", async () => {
+  const calls = [];
+  const client = {
+    tools: {
+      list: async (params) => { calls.push(["list", params]); return { tools: [] }; },
+      help: async () => "help",
+      skills: async () => [],
+      setConfig: async () => ({ ok: true }),
+      run: async () => ({ ok: true })
+    },
+    tasks: {
+      list: async () => [],
+      cancel: async () => ({ ok: true }),
+      cancelAll: async () => ({ ok: true })
+    }
+  };
+  const tools = createTuiCapabilityTools(client);
+  assert.deepEqual(tools.map((tool) => tool.name), [
+    "list_tools",
+    "tool_help",
+    "tool_skills",
+    "set_tool_config",
+    "run_tool",
+    "list_scheduled_tasks",
+    "cancel_scheduled_task",
+    "cancel_all_scheduled_tasks"
+  ]);
+
+  const result = await tools[0].execute("call", { query: "email" });
+  assert.deepEqual(calls, [["list", { query: "email" }]]);
+  assert.match(result.content[0].text, /"tools"/);
+});