arisa 5.1.49 → 5.1.64

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 });
@@ -59,12 +59,37 @@ test("claims only due pending tasks and marks them running", async () => {
   assert.equal((await store.get("done")).status, "done");
 });
 
+test("claims overdue tasks chronologically and records actual execution start", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  const older = new Date(Date.now() - 2_000).toISOString();
+  const newer = new Date(Date.now() - 1_000).toISOString();
+  await store.add({ id: "newer", kind: "agent_task", runAt: newer });
+  await store.add({ id: "older", kind: "agent_task", runAt: older });
+
+  const claimed = await store.claimDue(2);
+  assert.deepEqual(claimed.map((task) => task.id), ["older", "newer"]);
+  assert.ok(claimed.every((task) => task.claimedAt));
+  assert.equal(claimed[0].executionStartedAt, undefined);
+
+  const started = await store.markExecutionStarted("older");
+  assert.ok(started.executionStartedAt);
+});
+
 test("recovers interrupted running tasks for retry after restart", async () => {
   await resetHome();
   const store = new TaskStore();
   const runAt = new Date(Date.now() - 1000).toISOString();
 
   await store.add({ id: "interrupted-once", kind: "agent_task", runAt, status: "running" });
+  await store.add({
+    id: "claimed-not-started",
+    kind: "agent_task",
+    runAt,
+    status: "running",
+    attempts: 1,
+    claimedAt: new Date().toISOString()
+  });
   await store.add({
     id: "interrupted-recurring",
     kind: "poll_tool",
@@ -77,16 +102,22 @@ 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.deepEqual(recovered.map((task) => task.id), ["interrupted-once", "claimed-not-started", "interrupted-recurring"]);
+  assert.equal(recovered[0].status, "outcome_uncertain");
+  assert.equal(recovered[1].status, "pending");
+  assert.equal(recovered[1].attempts, 0);
+  assert.equal(recovered[1].lastError, "execution interrupted before start");
+  assert.equal(recovered[2].status, "pending");
+  assert.ok(Date.parse(recovered[2].runAt) > Date.now());
+  assert.equal(recovered[0].lastError, "execution interrupted before confirmation");
+  assert.equal(recovered[2].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"]
+    ["claimed-not-started", "still-pending"]
   );
 });
 
@@ -114,6 +145,198 @@ 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("keeps recurring tasks scheduled after an uncertain outcome without replaying the occurrence", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  await store.add({
+    id: "recurring-uncertain",
+    kind: "agent_task",
+    status: "running",
+    attempts: 1,
+    recurrence: { type: "interval", everySeconds: 60 }
+  });
+
+  const task = await store.retryOrFail("recurring-uncertain", "deadline exceeded", {
+    retryable: false,
+    outcomeUncertain: true
+  });
+
+  assert.equal(task.status, "pending");
+  assert.equal(task.lastOutcome, "outcome_uncertain");
+  assert.equal(task.attempts, 0);
+  assert.equal(task.terminalFailure, true);
+  assert.ok(Date.parse(task.runAt) > Date.now());
+});
+
+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 +361,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 +369,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-reply-topic-routing.test.js

@@ -0,0 +1,94 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  appendGeneralReplyRoutingInstruction,
+  extractReplyTopicMetadata,
+  isGeneralWorkspaceRoute,
+  routeGeneralWorkspaceReply
+} from "../src/transport/telegram/reply-topic-routing.js";
+
+const topics = [
+  { threadId: 23, name: "Stories", description: "Published stories and editorial work" },
+  { threadId: 87, name: "CBPR", description: "Castle Bravo press campaign" },
+  { threadId: 114, name: "CORE", description: "Arisa core engineering" }
+];
+
+const generalRoute = {
+  workspace: true,
+  ownerChatId: 42,
+  sessionId: "42",
+  scopeChatId: 42,
+  transportChatId: -100123,
+  threadId: null,
+  topicThreadId: 1,
+  generalTopicId: 1
+};
+
+test("General prompts describe conservative dynamic reply routing", () => {
+  const prompt = appendGeneralReplyRoutingInstruction("Incoming Telegram message.", topics, [
+    { name: "Infrastructure", proposedAt: "2026-08-24T00:00:00.000Z" }
+  ]);
+  assert.match(prompt, /only because the incoming message was written in General/);
+  assert.match(prompt, /never applies to a private chat/);
+  assert.match(prompt, /original message must stay in General/);
+  assert.match(prompt, /23: Stories/);
+  assert.match(prompt, /87: CBPR/);
+  assert.match(prompt, /114: CORE/);
+  assert.match(prompt, /Do not repeat these recent topic proposals: Infrastructure/);
+  assert.match(prompt, /Never create a topic without explicit confirmation/);
+});
+
+test("an allowed trailing marker is stripped and selects its topic", () => {
+  assert.deepEqual(extractReplyTopicMetadata("Implemented.\n[[ARISA_REPLY_TOPIC:114]]", topics), {
+    text: "Implemented.",
+    threadId: 114,
+    proposal: ""
+  });
+});
+
+test("invalid markers are stripped without rerouting", () => {
+  assert.deepEqual(extractReplyTopicMetadata("Keep this here.\n[[ARISA_REPLY_TOPIC:999]]", topics), {
+    text: "Keep this here.",
+    threadId: null,
+    proposal: ""
+  });
+});
+
+test("topic proposals are stripped and returned as transport metadata", () => {
+  assert.deepEqual(extractReplyTopicMetadata("Should we create it?\n[[ARISA_PROPOSE_TOPIC:Research Lab]]", topics), {
+    text: "Should we create it?",
+    threadId: null,
+    proposal: "Research Lab"
+  });
+});
+
+test("only replies originating in a supergroup General topic can change destination", () => {
+  assert.equal(isGeneralWorkspaceRoute(generalRoute), true);
+  const routed = routeGeneralWorkspaceReply({
+    route: generalRoute,
+    topics,
+    text: "Core update.\n[[ARISA_REPLY_TOPIC:114]]"
+  });
+  assert.equal(routed.text, "Core update.");
+  assert.equal(routed.route.sessionId, "42");
+  assert.equal(routed.route.threadId, 114);
+  assert.equal(routed.topic.name, "CORE");
+
+  const privateRoute = {
+    workspace: false,
+    sessionId: "42",
+    scopeChatId: 42,
+    transportChatId: 42,
+    threadId: null
+  };
+  assert.equal(isGeneralWorkspaceRoute(privateRoute), false);
+  const privateReply = routeGeneralWorkspaceReply({
+    route: privateRoute,
+    topics,
+    text: "Private response.\n[[ARISA_REPLY_TOPIC:114]]"
+  });
+  assert.equal(privateReply.route, privateRoute);
+  assert.equal(privateReply.topic, null);
+  assert.equal(privateReply.proposal, "");
+  assert.equal(privateReply.text, "Private response.");
+});

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,65 @@ 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[0][1].timeoutMs, 15 * 60_000);
+  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("passes bounded execution deadlines to scheduled prompts", async () => {
+  const { calls, dispatcher } = createHarness({
+    dependencies: { taskTimeouts: { agentTimeoutMs: 900, eventTimeoutMs: 300 } }
+  });
+  await dispatcher.runClaimedTask({
+    id: "deadline-task",
+    kind: "agent_task",
+    payload: { chatId: 123, prompt: "work" }
+  });
+  await dispatcher.runClaimedTask({
+    id: "deadline-event",
+    kind: "agent_event",
+    payload: { chatId: 123, prompt: "event" }
+  });
+
+  const enqueues = calls.filter(([name]) => name === "enqueue");
+  assert.equal(enqueues[0][1].timeoutMs, 900);
+  assert.equal(enqueues[1][1].timeoutMs, 300);
+});
+
+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 +92,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 +106,107 @@ 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("serializes tasks within one destination while independent destinations continue", async () => {
+  const tasks = [
+    { id: "first", kind: "agent_task", payload: { chatId: 123, prompt: "first" }, route: { transport: "telegram", destination: { chatId: -1001, threadId: 87 } } },
+    { id: "second", kind: "agent_task", payload: { chatId: 123, prompt: "second" }, route: { transport: "telegram", destination: { chatId: -1001, threadId: 87 } } },
+    { id: "other", kind: "agent_task", payload: { chatId: 123, prompt: "other" }, route: { transport: "telegram", destination: { chatId: -1001, threadId: 23 } } }
+  ];
+  let releaseFirst;
+  const firstExecution = new Promise((resolve) => { releaseFirst = resolve; });
+  const { calls, dispatcher } = createHarness({
+    taskStore: { async claimDue() { return tasks; } },
+    dependencies: {
+      enqueueAsyncPrompt: async (input) => {
+        calls.push(["enqueue", input.label]);
+        if (input.label.includes("first")) await firstExecution;
+      }
+    }
+  });
+
+  const dispatching = dispatcher.dispatchDueTasks();
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.ok(calls.some((call) => call[0] === "enqueue" && call[1].includes("first")));
+  assert.ok(calls.some((call) => call[0] === "enqueue" && call[1].includes("other")));
+  assert.equal(calls.some((call) => call[0] === "enqueue" && call[1].includes("second")), false);
+
+  releaseFirst();
+  await dispatching;
+  const enqueueOrder = calls.filter((call) => call[0] === "enqueue").map((call) => call[1]);
+  assert.ok(enqueueOrder.indexOf("scheduled task first") < enqueueOrder.indexOf("scheduled task second"));
 });
 
-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 +222,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);