arisa 5.1.60 → 5.1.64

package/src/transport/telegram/reply-topic-routing.js

@@ -0,0 +1,111 @@
+const replyTopicMarkerPattern = /\s*\[\[ARISA_REPLY_TOPIC:(\d+)\]\]\s*$/u;
+const proposalMarkerPattern = /\s*\[\[ARISA_PROPOSE_TOPIC:([^\]\r\n]{1,80})\]\]\s*$/u;
+const anyRoutingMarkerPattern = /\s*\[\[ARISA_(?:REPLY_TOPIC|PROPOSE_TOPIC):[^\]]*\]\]\s*$/u;
+
+function singleLine(value, maxLength) {
+  return String(value || "").replace(/\s+/g, " ").trim().slice(0, maxLength);
+}
+
+export function isGeneralWorkspaceRoute(route) {
+  return Boolean(route?.workspace
+    && route.threadId == null
+    && route.topicThreadId === route.generalTopicId);
+}
+
+function activeTopics(topics = []) {
+  return topics
+    .map((topic) => ({
+      threadId: Number(topic?.threadId),
+      name: singleLine(topic?.name, 80),
+      description: singleLine(topic?.description, 240)
+    }))
+    .filter((topic) => Number.isSafeInteger(topic.threadId) && topic.threadId > 0 && topic.name)
+    .sort((left, right) => left.threadId - right.threadId)
+    .slice(0, 32);
+}
+
+export function buildGeneralReplyRoutingInstruction(topics = [], recentProposals = []) {
+  const available = activeTopics(topics);
+  const options = available.length
+    ? available.map((topic) => [
+      `- ${topic.threadId}: ${topic.name}`,
+      topic.description ? ` — ${topic.description}` : ""
+    ].join(""))
+    : ["- No named topics are registered yet."];
+  const proposals = recentProposals
+    .map((proposal) => singleLine(proposal?.name, 80))
+    .filter(Boolean)
+    .slice(0, 12);
+  return [
+    "Telegram General-topic management instruction:",
+    "This applies only because the incoming message was written in General inside an owner workspace supergroup. It never applies to a private chat with the bot.",
+    "The original message must stay in General and the conversation remains in the General session.",
+    "If, and only if, your final response clearly belongs to exactly one registered topic below, append [[ARISA_REPLY_TOPIC:<id>]] as the final line. Do not mention this routing marker.",
+    "If the relationship is weak, ambiguous, or no topic fits, do not append a reply marker and the response will remain in General.",
+    "You may occasionally propose a new topic only when the General conversation shows a substantial theme recurring across multiple turns and no registered topic fits. Ask for explicit confirmation in the visible response and append [[ARISA_PROPOSE_TOPIC:<short name>]] as the final line. Never create a topic without explicit confirmation.",
+    proposals.length ? `Do not repeat these recent topic proposals: ${proposals.join(", ")}.` : null,
+    "Registered reply topics:",
+    ...options
+  ].filter(Boolean).join("\n");
+}
+
+export function appendGeneralReplyRoutingInstruction(prompt, topics = [], recentProposals = []) {
+  return `${String(prompt || "")}\n\n${buildGeneralReplyRoutingInstruction(topics, recentProposals)}`;
+}
+
+export function extractReplyTopicMetadata(text, topics = []) {
+  let cleanedText = String(text || "");
+  let requestedThreadId = null;
+  let proposal = "";
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const replyMatch = cleanedText.match(replyTopicMarkerPattern);
+    if (replyMatch) {
+      requestedThreadId ??= Number(replyMatch[1]);
+      cleanedText = cleanedText.replace(replyTopicMarkerPattern, "");
+      changed = true;
+      continue;
+    }
+    const proposalMatch = cleanedText.match(proposalMarkerPattern);
+    if (proposalMatch) {
+      proposal ||= singleLine(proposalMatch[1], 80);
+      cleanedText = cleanedText.replace(proposalMarkerPattern, "");
+      changed = true;
+      continue;
+    }
+    if (anyRoutingMarkerPattern.test(cleanedText)) {
+      cleanedText = cleanedText.replace(anyRoutingMarkerPattern, "");
+      changed = true;
+    }
+  }
+
+  const available = activeTopics(topics);
+  const allowed = available.some((topic) => topic.threadId === requestedThreadId);
+  return {
+    text: cleanedText.trimEnd(),
+    threadId: allowed ? requestedThreadId : null,
+    proposal
+  };
+}
+
+export function routeGeneralWorkspaceReply({ route, text, topics = [] }) {
+  const generalWorkspaceRoute = isGeneralWorkspaceRoute(route);
+  const extracted = extractReplyTopicMetadata(text, generalWorkspaceRoute ? topics : []);
+  if (!generalWorkspaceRoute) {
+    return { text: extracted.text, route, topic: null, proposal: "" };
+  }
+
+  const topic = activeTopics(topics).find((item) => item.threadId === extracted.threadId) || null;
+  if (!topic) return { text: extracted.text, route, topic: null, proposal: extracted.proposal };
+  return {
+    text: extracted.text,
+    route: {
+      ...route,
+      threadId: topic.threadId,
+      topicThreadId: topic.threadId
+    },
+    topic,
+    proposal: ""
+  };
+}

package/src/transport/telegram/task-dispatcher.js

@@ -5,6 +5,13 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+function boundedTimeout(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0
+    ? Math.min(Math.round(parsed), 60 * 60_000)
+    : fallback;
+}
+
 function requireChatId(task) {
   const chatId = task.payload?.chatId;
   if (chatId == null || chatId === "") {
@@ -31,7 +38,7 @@ function failureDestination(task) {
 }
 
 function buildFailureNotice({ task, result, error }) {
-  const uncertain = result?.status === "outcome_uncertain";
+  const uncertain = result?.status === "outcome_uncertain" || result?.lastOutcome === "outcome_uncertain";
   const recurring = result?.terminalFailure === true && result?.status === "pending";
   const lines = [
     uncertain ? "⚠️ Arisa task outcome is uncertain" : "⚠️ Arisa task failed",
@@ -51,8 +58,12 @@ export function createTelegramTaskDispatcher({
   toolRegistry,
   resourceNotes,
   agentManager,
+  taskTimeouts = {},
   logger
 }) {
+  const agentTimeoutMs = boundedTimeout(taskTimeouts.agentTimeoutMs, 15 * 60_000);
+  const eventTimeoutMs = boundedTimeout(taskTimeouts.eventTimeoutMs, 5 * 60_000);
+
   async function dispatchAgentTask(task, chatId) {
     if (!task.payload.prompt) throw new NonRetryableTaskError("agent_task missing prompt");
     logger?.log("tasks", `running task ${task.id} for chat ${chatId}`);
@@ -60,7 +71,8 @@ export function createTelegramTaskDispatcher({
       chatId,
       prompt: await buildAsyncTaskPrompt({ task, artifactStore, toolRegistry, resourceNotes, logger }),
       label: `scheduled task ${task.id}`,
-      route: task.route
+      route: task.route,
+      timeoutMs: agentTimeoutMs
     });
   }
 
@@ -79,7 +91,8 @@ export function createTelegramTaskDispatcher({
       chatId,
       prompt: await buildAsyncEventPrompt(task, resourceNotes),
       label: `agent event ${task.id}`,
-      route: task.route
+      route: task.route,
+      timeoutMs: eventTimeoutMs
     });
   }
 
@@ -124,6 +137,16 @@ export function createTelegramTaskDispatcher({
   const runner = createTaskRunner({
     taskStore,
     dispatch: dispatchTask,
+    laneKey(task) {
+      if (task.kind === "poll_tool") {
+        return `poll:${task.payload?.chatId}:${task.payload?.toolName || task.id}`;
+      }
+      const destination = task.route?.transport === "telegram" ? task.route.destination : null;
+      if (!destination?.chatId || Number(destination.threadId) === 1) {
+        return `agent:${task.payload?.chatId}`;
+      }
+      return `agent:${destination.chatId}:${destination.threadId || 0}`;
+    },
     onTerminalFailure: notifyTerminalFailure,
     logger
   });

package/src/transport/telegram/telegram-session-bridge.js

@@ -24,6 +24,7 @@ export function createTelegramSessionBridgeController({
   agentManager,
   artifactStore,
   sessionSeeds,
+  workspaceTopics,
   getChatState,
   buildTopicInitializationHandoff,
   logger
@@ -61,6 +62,12 @@ export function createTelegramSessionBridgeController({
         throw new Error("The General topic already uses the owner's private session and cannot be reinitialized here.");
       }
       const handoff = buildTopicInitializationHandoff({ name, context });
+      await workspaceTopics.upsertTopic(route.ownerChatId, route.transportChatId, {
+        threadId: messageThreadId,
+        name,
+        description: context,
+        source: "arisa-initialized"
+      });
       await sessionSeeds.set(initializedSessionId, handoff);
       agentManager.resetSession(initializedSessionId, { handoff });
       await agentManager.waitForSessionClose(initializedSessionId);

package/src/transport/telegram/workspace-topic-store.js

@@ -0,0 +1,228 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getChatTelegramWorkspacesFile } from "../../runtime/paths.js";
+
+const recentProposalWindowMs = 30 * 24 * 60 * 60 * 1000;
+
+function emptyState() {
+  return { version: 1, groups: {} };
+}
+
+function integer(value, label) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) throw new Error(`${label} must be an integer`);
+  return parsed;
+}
+
+function oneLine(value, maxLength) {
+  return String(value || "").replace(/\s+/g, " ").trim().slice(0, maxLength);
+}
+
+function normalizeState(parsed) {
+  if (!parsed || parsed.version !== 1 || !parsed.groups || typeof parsed.groups !== "object") {
+    throw new Error("Unsupported Telegram workspace topic state");
+  }
+  return parsed;
+}
+
+async function readState(file) {
+  try {
+    return normalizeState(JSON.parse(await readFile(file, "utf8")));
+  } catch (error) {
+    if (error?.code === "ENOENT") return emptyState();
+    throw error;
+  }
+}
+
+async function writeState(file, state) {
+  await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  await rename(temporary, file);
+}
+
+function workspace(state, groupChatId) {
+  const groupKey = String(groupChatId);
+  state.groups[groupKey] ||= { topics: {}, proposals: {} };
+  state.groups[groupKey].topics ||= {};
+  state.groups[groupKey].proposals ||= {};
+  return state.groups[groupKey];
+}
+
+function normalizeTopic(threadId, topic) {
+  return {
+    threadId: Number(threadId),
+    name: oneLine(topic?.name, 80),
+    description: oneLine(topic?.description, 240),
+    status: topic?.status === "closed" ? "closed" : "open",
+    source: oneLine(topic?.source, 40),
+    createdAt: oneLine(topic?.createdAt, 40),
+    updatedAt: oneLine(topic?.updatedAt, 40)
+  };
+}
+
+export async function migrateLegacyReplyTopics(config, store) {
+  let migratedGroups = 0;
+  for (const [groupChatId, workspaceConfig] of Object.entries(config.telegram?.ownerWorkspaceGroups || {})) {
+    const configured = workspaceConfig?.replyTopics;
+    if (!configured || typeof configured !== "object" || Array.isArray(configured)) continue;
+    const generalTopicId = Number(workspaceConfig.generalTopicId) || 1;
+    for (const [threadId, topic] of Object.entries(configured)) {
+      const numericThreadId = Number(threadId);
+      const name = oneLine(topic?.name, 80);
+      if (!Number.isSafeInteger(numericThreadId) || numericThreadId <= 0 || numericThreadId === generalTopicId || !name) continue;
+      await store.upsertTopic(workspaceConfig.ownerChatId, Number(groupChatId), {
+        threadId: numericThreadId,
+        name,
+        description: topic?.description,
+        source: "legacy-config-migration"
+      });
+    }
+    delete workspaceConfig.replyTopics;
+    migratedGroups += 1;
+  }
+  return migratedGroups;
+}
+
+export class WorkspaceTopicStore {
+  constructor({ resolveFile = getChatTelegramWorkspacesFile, now = () => Date.now() } = {}) {
+    this.resolveFile = resolveFile;
+    this.now = now;
+    this.queues = new Map();
+  }
+
+  async withOwnerLock(ownerChatId, work) {
+    const key = String(ownerChatId);
+    const previous = this.queues.get(key) || Promise.resolve();
+    const current = previous.catch(() => {}).then(work);
+    this.queues.set(key, current);
+    try {
+      return await current;
+    } finally {
+      if (this.queues.get(key) === current) this.queues.delete(key);
+    }
+  }
+
+  async read(ownerChatId) {
+    await (this.queues.get(String(ownerChatId)) || Promise.resolve()).catch(() => {});
+    return readState(this.resolveFile(ownerChatId));
+  }
+
+  async listTopics(ownerChatId, groupChatId, { includeClosed = false } = {}) {
+    const state = await this.read(ownerChatId);
+    const group = state.groups[String(groupChatId)];
+    if (!group?.topics) return [];
+    return Object.entries(group.topics)
+      .map(([threadId, topic]) => normalizeTopic(threadId, topic))
+      .filter((topic) => Number.isSafeInteger(topic.threadId)
+        && topic.threadId > 0
+        && topic.name
+        && (includeClosed || topic.status === "open"))
+      .sort((left, right) => left.threadId - right.threadId);
+  }
+
+  async upsertTopic(ownerChatId, groupChatId, { threadId, name, description, status = "open", source = "observed" }) {
+    const scopedOwner = integer(ownerChatId, "ownerChatId");
+    const scopedGroup = integer(groupChatId, "groupChatId");
+    const scopedThread = integer(threadId, "threadId");
+    const scopedName = oneLine(name, 80);
+    if (scopedThread <= 0) throw new Error("threadId must be positive");
+    if (!scopedName) throw new Error("topic name is required");
+
+    return this.withOwnerLock(scopedOwner, async () => {
+      const file = this.resolveFile(scopedOwner);
+      const state = await readState(file);
+      const group = workspace(state, scopedGroup);
+      const key = String(scopedThread);
+      const existing = group.topics[key] || {};
+      const timestamp = new Date(this.now()).toISOString();
+      group.topics[key] = {
+        ...existing,
+        name: scopedName,
+        description: description === undefined ? oneLine(existing.description, 240) : oneLine(description, 240),
+        status: status === "closed" ? "closed" : "open",
+        source: oneLine(source, 40) || oneLine(existing.source, 40) || "observed",
+        createdAt: existing.createdAt || timestamp,
+        updatedAt: timestamp
+      };
+      await writeState(file, state);
+      return normalizeTopic(key, group.topics[key]);
+    });
+  }
+
+  async setTopicStatus(ownerChatId, groupChatId, threadId, status) {
+    const scopedOwner = integer(ownerChatId, "ownerChatId");
+    const scopedGroup = integer(groupChatId, "groupChatId");
+    const scopedThread = integer(threadId, "threadId");
+    return this.withOwnerLock(scopedOwner, async () => {
+      const file = this.resolveFile(scopedOwner);
+      const state = await readState(file);
+      const topic = state.groups[String(scopedGroup)]?.topics?.[String(scopedThread)];
+      if (!topic) return null;
+      topic.status = status === "closed" ? "closed" : "open";
+      topic.updatedAt = new Date(this.now()).toISOString();
+      await writeState(file, state);
+      return normalizeTopic(scopedThread, topic);
+    });
+  }
+
+  async observeMessage(route, message = {}) {
+    if (!route?.workspace || !route.ownerChatId || !route.transportChatId) return null;
+    const threadId = route.topicThreadId;
+    if (!Number.isSafeInteger(threadId) || threadId === route.generalTopicId) return null;
+    if (message.forum_topic_created?.name) {
+      return this.upsertTopic(route.ownerChatId, route.transportChatId, {
+        threadId,
+        name: message.forum_topic_created.name,
+        source: "telegram-created"
+      });
+    }
+    if (message.forum_topic_edited?.name) {
+      return this.upsertTopic(route.ownerChatId, route.transportChatId, {
+        threadId,
+        name: message.forum_topic_edited.name,
+        source: "telegram-edited"
+      });
+    }
+    if (message.forum_topic_closed) {
+      return this.setTopicStatus(route.ownerChatId, route.transportChatId, threadId, "closed");
+    }
+    if (message.forum_topic_reopened) {
+      return this.setTopicStatus(route.ownerChatId, route.transportChatId, threadId, "open");
+    }
+    return null;
+  }
+
+  async recordProposal(ownerChatId, groupChatId, name) {
+    const scopedOwner = integer(ownerChatId, "ownerChatId");
+    const scopedGroup = integer(groupChatId, "groupChatId");
+    const scopedName = oneLine(name, 80);
+    if (!scopedName) return null;
+    return this.withOwnerLock(scopedOwner, async () => {
+      const file = this.resolveFile(scopedOwner);
+      const state = await readState(file);
+      const group = workspace(state, scopedGroup);
+      const key = scopedName.toLocaleLowerCase("en-US");
+      group.proposals[key] = {
+        name: scopedName,
+        proposedAt: new Date(this.now()).toISOString()
+      };
+      const ordered = Object.entries(group.proposals)
+        .sort((left, right) => String(right[1]?.proposedAt || "").localeCompare(String(left[1]?.proposedAt || "")))
+        .slice(0, 50);
+      group.proposals = Object.fromEntries(ordered);
+      await writeState(file, state);
+      return group.proposals[key];
+    });
+  }
+
+  async listRecentProposals(ownerChatId, groupChatId) {
+    const state = await this.read(ownerChatId);
+    const proposals = state.groups[String(groupChatId)]?.proposals || {};
+    const cutoff = this.now() - recentProposalWindowMs;
+    return Object.values(proposals)
+      .filter((proposal) => Date.parse(proposal?.proposedAt || "") >= cutoff)
+      .sort((left, right) => String(right.proposedAt).localeCompare(String(left.proposedAt)))
+      .slice(0, 12);
+  }
+}

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/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/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/task-store.test.js

@@ -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,18 +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.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.ok(Date.parse(recovered[1].runAt) > Date.now());
-  assert.ok(recovered.every((task) => task.lastError === "execution interrupted before confirmation"));
+  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),
-    ["still-pending"]
+    ["claimed-not-started", "still-pending"]
   );
 });
 
@@ -270,6 +299,29 @@ test("moves legacy Telegram routing out of task payloads", async () => {
   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();