arisa 5.1.49 → 5.1.60

package/test/task-store.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -9,7 +9,7 @@ process.env.HOME = homeDir;
 process.env.USERPROFILE = homeDir;
 
 const { TaskStore } = await import("../src/core/tasks/task-store.js");
-const { arisaHomeDir } = await import("../src/runtime/paths.js");
+const { arisaHomeDir, tasksFile } = await import("../src/runtime/paths.js");
 
 async function resetHome() {
   await rm(arisaHomeDir, { recursive: true, force: true });
@@ -78,15 +78,17 @@ test("recovers interrupted running tasks for retry after restart", async () => {
   const recovered = await store.recoverInterrupted();
 
   assert.deepEqual(recovered.map((task) => task.id), ["interrupted-once", "interrupted-recurring"]);
-  assert.ok(recovered.every((task) => task.status === "pending"));
-  assert.ok(recovered.every((task) => task.runAt === runAt));
+  assert.equal(recovered[0].status, "outcome_uncertain");
+  assert.equal(recovered[1].status, "pending");
+  assert.ok(Date.parse(recovered[1].runAt) > Date.now());
+  assert.ok(recovered.every((task) => task.lastError === "execution interrupted before confirmation"));
   assert.equal((await store.get("still-pending")).status, "pending");
   assert.equal((await store.get("already-done")).status, "done");
 
   const restartedStore = new TaskStore();
   assert.deepEqual(
     (await restartedStore.claimDue()).map((task) => task.id),
-    ["interrupted-once", "interrupted-recurring", "still-pending"]
+    ["still-pending"]
   );
 });
 
@@ -114,6 +116,175 @@ test("completes one-off tasks and re-schedules recurring interval tasks", async
   assert.ok(repeat.lastRunAt);
 });
 
+test("compacts terminal payloads while preserving routing and audit identifiers", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  const route = { transport: "telegram", destination: { chatId: -1001, threadId: 87 } };
+  const payload = {
+    chatId: "chat-1",
+    prompt: "private operational prompt ".repeat(200),
+    args: { cursor: "large private state".repeat(100) },
+    acknowledgement: "received",
+    toolName: "checker",
+    resourceId: "inbox:primary",
+    artifactId: "artifact-1"
+  };
+  await store.add({ id: "compact-done", kind: "agent_task", payload, route });
+  await store.add({ id: "compact-failed", kind: "agent_task", payload });
+  await store.add({ id: "compact-uncertain", kind: "agent_task", payload });
+
+  const done = await store.complete("compact-done");
+  const failed = await store.fail("compact-failed", "permanent failure");
+  const uncertain = await store.retryOrFail("compact-uncertain", "unknown outcome", {
+    retryable: false,
+    outcomeUncertain: true
+  });
+  const expectedPayload = {
+    chatId: "chat-1",
+    toolName: "checker",
+    resourceId: "inbox:primary",
+    artifactId: "artifact-1"
+  };
+
+  for (const task of [done, failed, uncertain]) {
+    assert.deepEqual(task.payload, expectedPayload);
+    assert.equal(task.payloadCompacted, true);
+    assert.equal(task.retry, undefined);
+    assert.equal(task.recurrence, undefined);
+  }
+  assert.deepEqual(done.route, route);
+  assert.ok(done.completedAt);
+  assert.equal(failed.error, "permanent failure");
+  assert.ok(uncertain.uncertainAt);
+  assert.deepEqual(
+    (await store.list({ chatId: "chat-1" })).map((task) => task.id),
+    ["compact-done", "compact-failed", "compact-uncertain"]
+  );
+});
+
+test("startup recovery compacts historical terminal tasks without changing active payloads", async () => {
+  await resetHome();
+  await mkdir(path.dirname(tasksFile), { recursive: true });
+  await writeFile(tasksFile, `${JSON.stringify([
+    {
+      id: "historical-done",
+      kind: "agent_task",
+      status: "done",
+      payload: { chatId: "chat-1", prompt: "obsolete prompt", args: { large: "value" } },
+      retry: { maxAttempts: 3 },
+      recurrence: null
+    },
+    {
+      id: "active-pending",
+      kind: "agent_task",
+      status: "pending",
+      runAt: new Date(Date.now() + 60_000).toISOString(),
+      payload: { chatId: "chat-1", prompt: "still required" }
+    }
+  ], null, 2)}\n`, "utf8");
+
+  const store = new TaskStore();
+  assert.deepEqual(await store.recoverInterrupted(), []);
+  const persisted = JSON.parse(await readFile(tasksFile, "utf8"));
+  const historical = persisted.find((task) => task.id === "historical-done");
+  const active = persisted.find((task) => task.id === "active-pending");
+
+  assert.deepEqual(historical.payload, { chatId: "chat-1" });
+  assert.equal(historical.payloadCompacted, true);
+  assert.equal(historical.retry, undefined);
+  assert.equal(historical.recurrence, undefined);
+  assert.equal(active.payload.prompt, "still required");
+  assert.ok(active.retry);
+});
+
+test("backs off known failures and fails after the attempt limit", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  const runAt = new Date(Date.now() - 1000).toISOString();
+  await store.add({
+    id: "retrying",
+    kind: "agent_task",
+    runAt,
+    retry: { maxAttempts: 2, baseDelaySeconds: 1, maxDelaySeconds: 10, multiplier: 2 }
+  });
+
+  await store.claimDue();
+  const retrying = await store.retryOrFail("retrying", "temporary");
+  assert.equal(retrying.status, "pending");
+  assert.equal(retrying.attempts, 1);
+  assert.ok(Date.parse(retrying.runAt) > Date.now());
+
+  retrying.runAt = runAt;
+  store.tasks.find((task) => task.id === "retrying").runAt = runAt;
+  await store.save();
+  await store.claimDue();
+  const failed = await store.retryOrFail("retrying", "still broken");
+  assert.equal(failed.status, "failed");
+  assert.equal(failed.attempts, 2);
+});
+
+test("keeps recurring tasks scheduled after a run exhausts its retries", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  const past = new Date(Date.now() - 1000).toISOString();
+  await store.add({
+    id: "recurring-failure",
+    kind: "agent_task",
+    runAt: past,
+    recurrence: { type: "interval", everySeconds: 60 },
+    retry: { maxAttempts: 1 }
+  });
+
+  await store.claimDue();
+  const result = await store.retryOrFail("recurring-failure", "temporary outage");
+
+  assert.equal(result.status, "pending");
+  assert.equal(result.terminalFailure, true);
+  assert.equal(result.lastOutcome, "failed");
+  assert.equal(result.lastError, "temporary outage");
+  assert.equal(result.attempts, 0);
+  assert.equal(result.consecutiveFailures, 1);
+  assert.ok(Date.parse(result.runAt) > Date.now());
+
+  const persisted = await store.get("recurring-failure");
+  assert.equal(persisted.terminalFailure, undefined);
+  assert.equal(persisted.status, "pending");
+});
+
+test("moves legacy Telegram routing out of task payloads", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  const task = await store.add({
+    id: "routed",
+    kind: "agent_task",
+    payload: {
+      chatId: "owner",
+      telegramContext: { transportChatId: -1001, messageThreadId: 87 }
+    }
+  });
+
+  assert.deepEqual(task.route, {
+    transport: "telegram",
+    destination: { chatId: -1001, threadId: 87 }
+  });
+  assert.equal(task.payload.telegramContext, undefined);
+});
+
+test("records uncertain outcomes without retrying", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  await store.add({ id: "uncertain", kind: "agent_task", status: "running", attempts: 1 });
+
+  const task = await store.retryOrFail("uncertain", "turn interrupted", {
+    retryable: false,
+    outcomeUncertain: true
+  });
+
+  assert.equal(task.status, "outcome_uncertain");
+  assert.equal(task.error, "turn interrupted");
+  assert.ok(task.uncertainAt);
+});
+
 test("fails and cancels tasks by id", async () => {
   await resetHome();
   const store = new TaskStore();
@@ -138,6 +309,7 @@ test("cancelAll preserves done and failed tasks and respects chat filters", asyn
   await store.add({ id: "chat-2-pending", kind: "agent_task" }, { payload: { chatId: "chat-2" } });
   await store.add({ id: "chat-1-done", kind: "agent_task", status: "done" }, { payload: { chatId: "chat-1" } });
   await store.add({ id: "chat-1-failed", kind: "agent_task", status: "failed" }, { payload: { chatId: "chat-1" } });
+  await store.add({ id: "chat-1-uncertain", kind: "agent_task", status: "outcome_uncertain" }, { payload: { chatId: "chat-1" } });
 
   const removed = await store.cancelAll({ chatId: "chat-1" });
   const remaining = await store.list();
@@ -145,6 +317,6 @@ test("cancelAll preserves done and failed tasks and respects chat filters", asyn
   assert.deepEqual(removed.map((task) => task.id), ["chat-1-pending"]);
   assert.deepEqual(
     remaining.map((task) => task.id),
-    ["chat-2-pending", "chat-1-done", "chat-1-failed"]
+    ["chat-2-pending", "chat-1-done", "chat-1-failed", "chat-1-uncertain"]
   );
 });

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

@@ -5,8 +5,12 @@ import { createTelegramTaskDispatcher } from "../src/transport/telegram/task-dis
 function createHarness(overrides = {}) {
   const calls = [];
   const taskStore = {
-    async fail(...args) { calls.push(["fail", ...args]); },
-    async complete(...args) { calls.push(["complete", ...args]); },
+    async fail(...args) { calls.push(["fail", ...args]); return { status: "failed" }; },
+    async complete(...args) { calls.push(["complete", ...args]); return { status: "done" }; },
+    async retryOrFail(taskId, error, options) {
+      calls.push(["retryOrFail", taskId, error.message, options]);
+      return { status: options.retryable ? "pending" : "failed" };
+    },
     async claimDue() { return []; },
     ...overrides.taskStore
   };
@@ -17,31 +21,44 @@ function createHarness(overrides = {}) {
     artifactStore: { forChat() { throw new Error("unexpected artifact access"); } },
     toolRegistry: {},
     resourceNotes: { async get() { return ""; } },
-    agentManager: { async runTool(input) { calls.push(["runTool", input]); } },
+    agentManager: { async runTool(input) { calls.push(["runTool", input]); return { ok: true }; } },
     logger: null,
     ...overrides.dependencies
   });
   return { calls, taskStore, dispatcher };
 }
 
-test("dispatches an agent task into the Telegram prompt queue", async () => {
-  const { calls, dispatcher } = createHarness();
-  await dispatcher.dispatchTask({
+test("confirms an agent task only after prompt execution resolves", async () => {
+  let confirmExecution;
+  const execution = new Promise((resolve) => { confirmExecution = resolve; });
+  const { calls, dispatcher } = createHarness({
+    dependencies: {
+      enqueueAsyncPrompt: async (input) => {
+        calls.push(["enqueue", input]);
+        await execution;
+      }
+    }
+  });
+  const running = dispatcher.runClaimedTask({
     id: "task-1",
     kind: "agent_task",
-    payload: { chatId: 123, prompt: "do the thing", telegramContext: { messageThreadId: 9 } }
+    status: "running",
+    payload: { chatId: 123, prompt: "do the thing" },
+    route: { transport: "telegram", destination: { chatId: -1001, threadId: 9 } }
   });
 
+  await new Promise((resolve) => setImmediate(resolve));
   assert.equal(calls[0][0], "enqueue");
-  assert.equal(calls[0][1].chatId, 123);
-  assert.match(calls[0][1].prompt, /taskId: task-1/);
-  assert.match(calls[0][1].prompt, /text: do the thing/);
-  assert.deepEqual(calls[1], ["complete", "task-1"]);
+  assert.deepEqual(calls[0][1].route, { transport: "telegram", destination: { chatId: -1001, threadId: 9 } });
+  assert.equal(calls.some(([name]) => name === "complete"), false);
+  confirmExecution();
+  await running;
+  assert.deepEqual(calls.at(-1), ["complete", "task-1"]);
 });
 
-test("acknowledges an agent event before queueing it", async () => {
+test("acknowledges an agent event before executing it", async () => {
   const { calls, dispatcher } = createHarness();
-  await dispatcher.dispatchTask({
+  await dispatcher.runClaimedTask({
     id: "event-1",
     kind: "agent_event",
     payload: { chatId: 123, prompt: "something happened", acknowledgement: "received" }
@@ -54,9 +71,9 @@ test("acknowledges an agent event before queueing it", async () => {
   assert.deepEqual(calls[2], ["complete", "event-1"]);
 });
 
-test("runs poll tools headlessly and completes the checker task", async () => {
+test("runs poll tools headlessly and confirms their result", async () => {
   const { calls, dispatcher } = createHarness();
-  await dispatcher.dispatchTask({
+  await dispatcher.runClaimedTask({
     id: "poll-1",
     kind: "poll_tool",
     payload: { chatId: 123, toolName: "checker", args: { cursor: "4" } }
@@ -68,18 +85,77 @@ test("runs poll tools headlessly and completes the checker task", async () => {
   ]);
 });
 
-test("fails malformed and unsupported tasks without enqueueing them", async () => {
+test("retries a known poll failure with backoff", async () => {
+  const { calls, dispatcher } = createHarness({
+    dependencies: {
+      agentManager: {
+        async runTool(input) {
+          calls.push(["runTool", input]);
+          return { ok: false, status: "failed", error: "temporary checker failure" };
+        }
+      }
+    }
+  });
+  await dispatcher.runClaimedTask({
+    id: "poll-failed",
+    kind: "poll_tool",
+    payload: { chatId: 123, toolName: "checker" }
+  });
+
+  assert.deepEqual(calls.at(-1), [
+    "retryOrFail",
+    "poll-failed",
+    "temporary checker failure",
+    { retryable: true }
+  ]);
+});
+
+test("fails malformed tasks without retrying", async () => {
   const { calls, dispatcher } = createHarness();
-  await dispatcher.dispatchTask({ id: "bad-1", kind: "agent_task", payload: {} });
-  await dispatcher.dispatchTask({ id: "bad-2", kind: "other", payload: { chatId: 123 } });
+  await dispatcher.runClaimedTask({ id: "bad-1", kind: "agent_task", payload: {} });
+  await dispatcher.runClaimedTask({ id: "bad-2", kind: "other", payload: { chatId: 123 } });
 
   assert.deepEqual(calls, [
-    ["fail", "bad-1", "Task missing chatId: agent_task"],
-    ["fail", "bad-2", "Unsupported task: other"]
+    ["retryOrFail", "bad-1", "Task missing chatId: agent_task", { retryable: false }],
+    ["retryOrFail", "bad-2", "Unsupported task: other", { retryable: false }],
+    ["send", 123, "⚠️ Arisa task failed\nTask: other (bad-2)\nError: Unsupported task: other\nNo further retries are scheduled.", undefined]
+  ]);
+});
+
+test("notifies the routed Telegram topic once retries are exhausted", async () => {
+  const { calls, dispatcher } = createHarness({
+    taskStore: {
+      async retryOrFail(taskId, error, options) {
+        calls.push(["retryOrFail", taskId, error.message, options]);
+        return {
+          status: "pending",
+          terminalFailure: true,
+          runAt: "2026-08-21T00:00:00.000Z"
+        };
+      }
+    },
+    dependencies: {
+      enqueueAsyncPrompt: async () => { throw new Error("token=very-secret-value queue unavailable"); }
+    }
+  });
+
+  await dispatcher.runClaimedTask({
+    id: "recurring-bad",
+    kind: "agent_task",
+    payload: { chatId: 123, prompt: "private payload must not appear" },
+    route: { transport: "telegram", destination: { chatId: -1001, threadId: 87 } }
+  });
+
+  assert.deepEqual(calls.at(-1), [
+    "send",
+    -1001,
+    "⚠️ Arisa task failed\nTask: agent_task (recurring-bad)\nError: token=[redacted] queue unavailable\nNext run: 2026-08-21T00:00:00.000Z",
+    { message_thread_id: 87 }
   ]);
+  assert.equal(calls.at(-1)[2].includes("private payload"), false);
 });
 
-test("due-task dispatch isolates failures between claimed tasks", async () => {
+test("due-task dispatch retries one failure without blocking another task", async () => {
   const tasks = [
     { id: "bad", kind: "agent_task", payload: { chatId: 123, prompt: "fail" } },
     { id: "good", kind: "poll_tool", payload: { chatId: 123, toolName: "checker" } }
@@ -95,8 +171,8 @@ test("due-task dispatch isolates failures between claimed tasks", async () => {
 
   assert.deepEqual(calls, [
     ["claimDue", 10],
-    ["fail", "bad", "queue unavailable"],
     ["runTool", { name: "checker", request: { args: {} }, chatId: 123 }],
-    ["complete", "good"]
+    ["complete", "good"],
+    ["retryOrFail", "bad", "queue unavailable", { retryable: true }]
   ]);
 });

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

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { buildPrompt, buildReactionPrompt, isScheduledTaskPrompt, shouldIncludeArtifactReference, withPromptSpeed } from "../src/transport/telegram/bot.js";
+import { buildPrompt, buildReactionPrompt, isScheduledTaskPrompt, scheduledPromptSpeedOptions, shouldIncludeArtifactReference, withPromptSpeed } from "../src/transport/telegram/bot.js";
 import { captureIncomingArtifact } from "../src/transport/telegram/media.js";
 
 test("scheduled agent prompts use normal speed for one turn and restore chat speed", async () => {
@@ -11,7 +11,18 @@ test("scheduled agent prompts use normal speed for one turn and restore chat spe
   assert.equal(isScheduledTaskPrompt("Scheduled task fired.\ntaskId: one"), true);
   assert.equal(isScheduledTaskPrompt("Incoming Telegram message."), false);
 
-  await withPromptSpeed({ speedController, speed: 1, restoreSpeed: () => 1.5 }, async () => {
+  const speedOptions = scheduledPromptSpeedOptions({
+    prompt: "Scheduled task fired.\ntaskId: one",
+    session: {
+      model: { provider: "openai-codex", api: "openai-codex-responses", id: "gpt-5.5" }
+    },
+    speedController,
+    configuredSpeed: 1.5
+  });
+  assert.equal(speedOptions.speed, 1);
+  assert.equal(speedOptions.restoreSpeed(), 1.5);
+
+  await withPromptSpeed(speedOptions, async () => {
     assert.equal(speed, 1);
   });
   assert.equal(speed, 1.5);

package/test/telegram-tools-command.test.js

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createTelegramToolsCommandHandler } from "../src/transport/telegram/telegram-tools-command.js";
+
+test("/tools shows typing and sends the scoped usage report", async () => {
+  const events = [];
+  const handler = createTelegramToolsCommandHandler({
+    authorize: async () => ({ ok: true }),
+    contextRoute: () => ({ scopeChatId: 879964957 }),
+    toolRegistry: {
+      usage: async (chatId) => {
+        assert.equal(chatId, 879964957);
+        return [{ name: "example", count: 2, official: true }];
+      }
+    },
+    withTyping: async (_ctx, work) => {
+      events.push("typing");
+      return work();
+    },
+    logger: null
+  });
+  const ctx = {
+    chat: { id: 879964957 },
+    reply: async (text, options) => events.push({ text, options })
+  };
+
+  await handler(ctx);
+
+  assert.equal(events[0], "typing");
+  assert.match(events[1].text, /example/);
+  assert.deepEqual(events[1].options, { parse_mode: "HTML" });
+});
+
+test("/tools reports failures instead of disappearing", async () => {
+  const replies = [];
+  const handler = createTelegramToolsCommandHandler({
+    authorize: async () => ({ ok: true }),
+    contextRoute: () => ({ scopeChatId: 1 }),
+    toolRegistry: { usage: async () => { throw new Error("store unavailable"); } },
+    withTyping: async (_ctx, work) => work(),
+    logger: null
+  });
+
+  await handler({ chat: { id: 1 }, reply: async (text) => replies.push(text) });
+
+  assert.deepEqual(replies, ["Tool usage report failed: store unavailable"]);
+});