arisa 5.1.49 → 5.1.64

package/test/chat-queue.test.js

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  createChatStateStore,
+  createPromptExecutionReceipt,
+  drainChatPromptQueue,
+  queueChatPrompt
+} from "../src/transport/telegram/chat-queue.js";
+
+test("execution receipts start only when their queued prompt begins", async () => {
+  const state = createChatStateStore().get("chat-1");
+  const starts = [];
+  const receipt = createPromptExecutionReceipt(() => starts.push("second"));
+  queueChatPrompt(state, "second", { receipt });
+  let releaseFirst;
+  const first = new Promise((resolve) => { releaseFirst = resolve; });
+
+  const draining = drainChatPromptQueue({
+    chatState: state,
+    initialPrompt: "first",
+    processPrompt: async ({ prompt }) => {
+      if (prompt === "first") await first;
+    }
+  });
+
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.deepEqual(starts, []);
+  releaseFirst();
+  await draining;
+  assert.deepEqual(starts, ["second"]);
+  await receipt.promise;
+});

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

@@ -4,6 +4,7 @@ import {
   collectText,
   ensureQueuedTelegramTyping,
   isSilentReply,
+  resolveIncomingBusyMessageMode,
   stopQueuedTelegramTyping
 } from "../src/transport/telegram/bot.js";
 import {
@@ -13,7 +14,7 @@ import {
   resolveTelegramBusyMessageMode,
   routeBusyPrompt
 } from "../src/transport/telegram/chat-queue.js";
-import { selectScheduledTasks } from "../src/core/agent/agent-manager.js";
+import { selectScheduledTasks } from "../src/core/capabilities/capability-service.js";
 
 test("queued Telegram prompts start typing immediately and share one indicator", async () => {
   let actions = 0;
@@ -158,6 +159,8 @@ test("chat state uses one queue for numeric and string chat IDs", () => {
     processing: false,
     pendingPrompts: [],
     pendingPromptContexts: [],
+    pendingPromptReceipts: [],
+    pendingPromptCoalescible: [],
     continueAfterClose: false,
     historyRevision: 0,
     beforeNextPrompt: null,
@@ -183,6 +186,32 @@ test("queued prompts retain their message boundaries and order", async () => {
   assert.deepEqual(processed, ["first request", "second request", "third request"]);
 });
 
+test("queued execution receipts resolve only after their prompt runs", async () => {
+  const chatState = createChatStateStore().get("chat");
+  chatState.processing = true;
+  let releaseFirst;
+  const firstGate = new Promise((resolve) => { releaseFirst = resolve; });
+  const { createPromptExecutionReceipt } = await import("../src/transport/telegram/chat-queue.js");
+  const receipt = createPromptExecutionReceipt();
+  queueChatPrompt(chatState, "scheduled request", { receipt });
+  let confirmed = false;
+  receipt.promise.then(() => { confirmed = true; });
+
+  const draining = drainChatPromptQueue({
+    chatState,
+    initialPrompt: "active request",
+    processPrompt: async ({ prompt }) => {
+      if (prompt === "active request") await firstGate;
+    }
+  });
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(confirmed, false);
+  releaseFirst();
+  await receipt.promise;
+  assert.equal(confirmed, true);
+  await draining;
+});
+
 test("a queued /new continues after the active session closes", async () => {
   const chatState = createChatStateStore().get("chat");
   chatState.processing = true;
@@ -265,6 +294,20 @@ test("busy message mode supports global defaults and per-chat overrides", () =>
   assert.equal(resolveTelegramBusyMessageMode({ telegram: { busyMessageMode: "invalid" } }, 123), "queue");
 });
 
+test("forum topics queue while direct Arisa messages retain steer mode", () => {
+  const config = { telegram: { busyMessageMode: "steer", chatMeta: {} } };
+  assert.equal(resolveIncomingBusyMessageMode({
+    config,
+    route: { workspace: true, sessionId: "owner--topic-87" },
+    message: { text: "topic follow-up" }
+  }), "queue");
+  assert.equal(resolveIncomingBusyMessageMode({
+    config,
+    route: { workspace: false, sessionId: "879964957" },
+    message: { text: "direct follow-up" }
+  }), "steer");
+});
+
 test("steer mode sends text to the active Pi session", async () => {
   const received = [];
   const chatState = createChatStateStore().get("chat");
@@ -297,6 +340,38 @@ test("failed or unavailable steering falls back to the ordered queue", async ()
   assert.deepEqual(chatState.pendingPrompts, ["keep this", "and this"]);
 });
 
+test("direct steer fallback coalesces consecutive text without reordering it", async () => {
+  const steered = [];
+  const chatState = createChatStateStore().get("chat");
+
+  const unavailable = await routeBusyPrompt({
+    chatState,
+    prompt: "first direct message",
+    mode: "steer",
+    coalesceQueued: true,
+    ctx: { message: { message_id: 1 } }
+  });
+  chatState.activeSession = {
+    isStreaming: true,
+    async steer(prompt) { steered.push(prompt); }
+  };
+  const next = await routeBusyPrompt({
+    chatState,
+    prompt: "second direct message",
+    mode: "steer",
+    coalesceQueued: true,
+    ctx: { message: { message_id: 2 } }
+  });
+
+  assert.equal(unavailable.disposition, "queued");
+  assert.equal(next.disposition, "coalesced");
+  assert.deepEqual(steered, []);
+  assert.deepEqual(chatState.pendingPrompts, [
+    "first direct message\n\n--- next direct message ---\n\nsecond direct message"
+  ]);
+  assert.equal(chatState.pendingPromptContexts[0].message.message_id, 2);
+});
+
 test("a pending /new forces later text into the replacement queue", async () => {
   const steered = [];
   const chatState = createChatStateStore().get("chat");

package/test/device-code-message.test.js

@@ -1,6 +1,15 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { buildDeviceCodeTelegramMessage } from "../src/transport/telegram/device-code-message.js";
+import { selectTelegramLoginOption } from "../src/transport/telegram/telegram-auth-controller.js";
+
+test("Telegram auth prefers device login and falls back deterministically", () => {
+  const browser = { id: "oauth", label: "Browser login" };
+  const device = { id: "device-code", label: "Device code" };
+  assert.strictEqual(selectTelegramLoginOption([browser, device]), device);
+  assert.strictEqual(selectTelegramLoginOption([browser]), browser);
+  assert.equal(selectTelegramLoginOption([]), null);
+});
 
 test("builds a copyable device-code Telegram message with HTML and inline buttons", () => {
   const payload = buildDeviceCodeTelegramMessage({

package/test/media-caption.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { resolveMediaCaption } from "../src/core/agent/agent-manager.js";
+import { resolveMediaCaption } from "../src/core/capabilities/capability-service.js";
 
 test("does not turn a domain-like filename into a caption", () => {
   assert.equal(resolveMediaCaption(undefined), undefined);

package/test/model-selection.test.js

@@ -10,7 +10,12 @@ import {
   selectChatSpeed,
   selectChatThinkingLevel
 } from "../src/core/agent/model-selection.js";
-import { applyConfigDefaults, piConfigDefaults, telegramConfigDefaults } from "../src/core/config/config-defaults.js";
+import {
+  applyConfigDefaults,
+  piConfigDefaults,
+  telegramConfigDefaults,
+  toolExecutionConfigDefaults
+} from "../src/core/config/config-defaults.js";
 import {
   clampModelThinkingLevel,
   listModelThinkingLevels,
@@ -295,6 +300,9 @@ test("centralizes Telegram and Pi defaults in config", () => {
 
   assert.equal(config.telegram.modelPickerPageSize, telegramConfigDefaults.modelPickerPageSize);
   assert.equal(config.telegram.busyMessageMode, "steer");
+  assert.equal(config.toolExecution.defaultCapacity, toolExecutionConfigDefaults.defaultCapacity);
+  assert.equal(config.toolExecution.maxQueuedPerClass, 100);
+  assert.deepEqual(config.toolExecution.capacities, {});
   assert.equal(config.pi.thinkingLevel, piConfigDefaults.thinkingLevel);
   assert.equal(config.pi.speed, piConfigDefaults.speed);
 });

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

@@ -7,7 +7,7 @@ async function manifest(name) {
 }
 
 test("official orchestrators declare their hard tool dependencies", async () => {
-  assert.deepEqual((await manifest("magnific-mcp")).toolDependencies, { "mcp-client": "^0.1.0" });
+  assert.deepEqual((await manifest("magnific-mcp")).toolDependencies, { "mcp-client": "^0.2.0" });
   assert.deepEqual((await manifest("campaign-draft-runner")).toolDependencies, {
     "pr-campaign": "^0.1.0",
     "gmail-workspace": "^0.1.0"

package/test/paths.test.js

@@ -10,6 +10,7 @@ import {
   createIpcSocketPath,
   getChatArtifactsDir,
   getChatSessionSeedFile,
+  getChatTelegramWorkspacesFile,
   getChatToolConfigPath,
   getChatToolUsageFile,
   getChatToolStateDir,
@@ -39,6 +40,13 @@ test("keeps tool usage scoped below the chat state directory", () => {
   );
 });
 
+test("keeps Telegram workspace topics scoped below the owner chat state directory", () => {
+  assert.equal(
+    getChatTelegramWorkspacesFile("chat-1"),
+    path.join(chatsDir, "chat-1", "state", "telegram-workspaces.json")
+  );
+});
+
 test("keeps chat tool state and config paths scoped below the chat directory for normal names", () => {
   assert.equal(
     getChatToolStateDir("chat-1", "strudel-agent"),

package/test/pi-capability-tools.test.js

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createPiCapabilityTools } from "../src/core/agent/pi-capability-tools.js";
+
+function createHarness() {
+  const calls = [];
+  let taskContext = { transportChatId: "chat-1", messageThreadId: 10 };
+  const capabilityService = {
+    async execute(request) {
+      calls.push(request);
+      if (request.method === "tools.list") return { tools: [] };
+      if (request.method === "tools.run") return { ok: true, output: {} };
+      return { ok: true };
+    }
+  };
+  const telegram = {
+    getTaskContext: () => taskContext,
+    sendMedia: async () => {}
+  };
+  const tools = createPiCapabilityTools({
+    capabilityService,
+    telegram,
+    chatId: "session-1",
+    policy: {
+      workspaceDir: "/workspace",
+      tools: ["read"],
+      excludeTools: [],
+      shell: {}
+    }
+  });
+  return {
+    calls,
+    tools,
+    setTaskContext(value) {
+      taskContext = value;
+    }
+  };
+}
+
+test("Pi tools delegate capability policy to CapabilityService", async () => {
+  const harness = createHarness();
+  const listTools = harness.tools.find((tool) => tool.name === "list_tools");
+
+  await listTools.execute("call-1", { query: "audio" });
+
+  assert.equal(harness.calls.length, 1);
+  assert.equal(harness.calls[0].method, "tools.list");
+  assert.equal(harness.calls[0].actorToolName, "list_tools");
+  assert.equal(harness.calls[0].chatId, "session-1");
+  assert.equal(harness.calls[0].context.workspaceDir, "/workspace");
+  assert.equal(harness.calls[0].context.coreTools[0].name, "read");
+  assert.equal(harness.calls[0].context.nativeTools[0].name, "system_shell");
+});
+
+test("Pi tool execution resolves the current Telegram task context per call", async () => {
+  const harness = createHarness();
+  const runTool = harness.tools.find((tool) => tool.name === "run_tool");
+
+  await runTool.execute("call-1", { name: "worker", args: {} });
+  harness.setTaskContext({ transportChatId: "chat-1", messageThreadId: 20 });
+  await runTool.execute("call-2", { name: "worker", args: {} });
+
+  assert.equal(harness.calls[0].context.taskContext.messageThreadId, 10);
+  assert.equal(harness.calls[1].context.taskContext.messageThreadId, 20);
+});

package/test/service-manager.test.js

@@ -1,7 +1,9 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { EventEmitter } from "node:events";
 import { createTelegramRestartHandler, telegramCommands } from "../src/transport/telegram/bot.js";
 import { handoffServiceRestart, restartService, serviceEntryFile, waitForServiceStop } from "../src/runtime/service-manager.js";
+import { createServiceSupervisor } from "../src/runtime/service-supervisor.js";
 
 test("registers maintenance as native Telegram commands", () => {
   assert.equal(
@@ -225,6 +227,52 @@ test("restart does not start a second service when shutdown times out", async ()
   assert.equal(started, false);
 });
 
+test("accepts restart handoff from a worker owned by the active supervisor", async () => {
+  let spawned = false;
+  await handoffServiceRestart({}, {
+    ensureHome: async () => {},
+    getStatus: async () => ({ running: true, pid: 77 }),
+    openLog: async () => ({ fd: 17, close: async () => {} }),
+    spawnProcess: () => ({ pid: 84, unref() { spawned = true; } }),
+    environment: { ARISA_SUPERVISOR_PID: "77" },
+    currentPid: 41
+  });
+  assert.equal(spawned, true);
+});
+
+test("supervisor restarts an unexpectedly exited worker and forwards shutdown", async () => {
+  const children = [];
+  const delays = [];
+  const spawnProcess = () => {
+    const child = new EventEmitter();
+    child.pid = 100 + children.length;
+    child.kill = (signal) => {
+      child.killedWith = signal;
+      queueMicrotask(() => child.emit("exit", 0, signal));
+    };
+    children.push(child);
+    return child;
+  };
+  const supervisor = createServiceSupervisor({
+    command: "node",
+    args: ["worker.js"],
+    restartLimit: 2,
+    restartBackoffMs: 5,
+    restartBackoffMaxMs: 20,
+    stableRuntimeMs: 60_000,
+    spawnProcess,
+    wait: async (ms) => { delays.push(ms); }
+  });
+  const running = supervisor.start();
+  children[0].emit("exit", 1, null);
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(children.length, 2);
+  assert.deepEqual(delays, [5]);
+  await supervisor.stop();
+  await running;
+  assert.equal(children[1].killedWith, "SIGTERM");
+});
+
 test("requires explicit positive shutdown timing policy", async () => {
   await assert.rejects(
     waitForServiceStop({ timeoutMs: 0, pollIntervalMs: 1 }),

package/test/session-start-operational-notes.test.js

@@ -16,7 +16,7 @@ async function loadNotesWithHome(homeDir, notesPayload) {
   );
 
   const script = `
-const mod = await import(${JSON.stringify(new URL("../src/core/agent/agent-manager.js", import.meta.url).href)});
+const mod = await import(${JSON.stringify(new URL("../src/core/agent/agent-session-lifecycle.js", import.meta.url).href)});
 process.stdout.write(JSON.stringify(mod.loadSessionStartOperationalNotes()));
 `;
   const { stdout } = await execFileAsync(process.execPath, ["--input-type=module", "--eval", script], {

package/test/task-idempotency.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+const homeDir = await mkdtemp(path.join(os.tmpdir(), "arisa-task-idempotency-home-"));
+process.env.HOME = homeDir;
+process.env.USERPROFILE = homeDir;
+
+const { TaskStore } = await import("../src/core/tasks/task-store.js");
+const { createTaskRunner } = await import("../src/core/tasks/task-runner.js");
+const { arisaHomeDir } = await import("../src/runtime/paths.js");
+
+test("two concurrent dispatchers execute one task id exactly once", async () => {
+  await rm(arisaHomeDir, { recursive: true, force: true });
+  const seedStore = new TaskStore();
+  await seedStore.add({
+    id: "single-execution",
+    kind: "agent_task",
+    runAt: new Date(Date.now() - 1_000).toISOString()
+  });
+
+  const executions = [];
+  const dispatch = async (task) => {
+    executions.push(task.id);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  };
+  const first = createTaskRunner({ taskStore: new TaskStore(), dispatch });
+  const second = createTaskRunner({ taskStore: new TaskStore(), dispatch });
+
+  const results = (await Promise.all([
+    first.dispatchDueTasks(),
+    second.dispatchDueTasks()
+  ])).flat();
+
+  assert.deepEqual(executions, ["single-execution"]);
+  assert.deepEqual(results, [{ taskId: "single-execution", status: "completed" }]);
+  assert.equal((await new TaskStore().get("single-execution")).status, "done");
+});

package/test/task-routing.test.js

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { taskWithoutCallerRouting } from "../src/core/tasks/task-routing.js";
+import { materializeToolOutput } from "../src/core/tools/tool-output-materializer.js";
+
+test("external tasks cannot override owner scope or transport routing", () => {
+  assert.deepEqual(taskWithoutCallerRouting({
+    kind: "agent_task",
+    route: { transport: "telegram", destination: { chatId: -999, threadId: 1 } },
+    payload: {
+      chatId: "other-owner",
+      telegramContext: { transportChatId: -999, messageThreadId: 1 },
+      prompt: "safe"
+    }
+  }), {
+    kind: "agent_task",
+    payload: { prompt: "safe" }
+  });
+});
+
+test("tool output materialization stores routing outside task payloads", async () => {
+  let capturedTasks;
+  let capturedDefaults;
+  const taskStore = {
+    async addMany(tasks, defaults) {
+      capturedTasks = tasks;
+      capturedDefaults = defaults;
+      return tasks;
+    }
+  };
+  const artifactStore = {
+    forChat() {
+      return {
+        async createText() { throw new Error("unexpected text artifact"); },
+        async createFromFile() { throw new Error("unexpected file artifact"); }
+      };
+    }
+  };
+  const route = { transport: "telegram", destination: { chatId: -1001, threadId: 87 } };
+
+  await materializeToolOutput({
+    result: {
+      asyncTask: {
+        kind: "agent_task",
+        route: { transport: "telegram", destination: { chatId: -999, threadId: 1 } },
+        payload: { chatId: "other", prompt: "run" }
+      }
+    },
+    name: "scheduler",
+    chatId: "owner",
+    artifactStore,
+    taskStore,
+    taskContext: route
+  });
+
+  assert.deepEqual(capturedTasks, [{ kind: "agent_task", payload: { prompt: "run" } }]);
+  assert.deepEqual(capturedDefaults, {
+    payload: { chatId: "owner" },
+    route,
+    source: { type: "tool", toolName: "scheduler", chatId: "owner" }
+  });
+});