arisa 5.1.68 → 5.2.17

package/src/transport/telegram/telegram-prompt-controller.js

@@ -0,0 +1,359 @@
+import { getErrorMessage } from "../../core/agent/auth-flow.js";
+import { resolveChatSpeed } from "../../core/agent/model-selection.js";
+import { captureIncomingArtifact } from "./media.js";
+import {
+  appendGeneralReplyRoutingInstruction,
+  isGeneralWorkspaceRoute,
+  routeGeneralWorkspaceReply
+} from "./reply-topic-routing.js";
+import {
+  buildNewSessionPrompt,
+  buildPrompt,
+  buildSessionHandoffPrompt,
+  collectText,
+  normalizeIncomingArtifact,
+  sanitizeSessionHandoff,
+  scheduledPromptSpeedOptions,
+  withPromptSpeed
+} from "./prompt-builders.js";
+import {
+  createPromptExecutionReceipt,
+  drainChatPromptQueue,
+  queueChatPrompt,
+  routeBusyPrompt
+} from "./chat-queue.js";
+
+function directChatRoute(chatId) {
+  return {
+    workspace: false,
+    sessionId: String(chatId),
+    scopeChatId: chatId,
+    transportChatId: chatId,
+    threadId: null
+  };
+}
+
+export function createTelegramPromptController({
+  config,
+  api,
+  artifactStore,
+  toolRegistry,
+  agentManager,
+  sessionSeeds,
+  workspaceTopics,
+  logger,
+  contextRoute,
+  getChatState,
+  createTelegramSessionBridge,
+  createWorkspaceAccessGuard,
+  sendTextReply,
+  authController,
+  ensureWorkspaceTopicModelSelection,
+  ensureQueuedTyping,
+  withTyping,
+  resolveBusyMessageMode
+}) {
+  async function buildIncomingPrompt(ctx, route = contextRoute(ctx)) {
+    logger?.log("telegram", `message ${ctx.msg.message_id} in chat ${route.transportChatId} session ${route.sessionId}`);
+    const chatArtifactStore = artifactStore.forChat(route.scopeChatId);
+    const artifact = await captureIncomingArtifact(ctx, artifactStore, { storageChatId: route.scopeChatId });
+    if (artifact) logger?.log("telegram", `captured artifact ${artifact.kind}${artifact.id ? ` ${artifact.id}` : ""}`);
+    const { transcript, toolResult, normalizationRequired } = await normalizeIncomingArtifact({
+      artifact,
+      toolRegistry,
+      chatArtifactStore,
+      chatId: route.scopeChatId
+    });
+    if (transcript) logger?.log("telegram", `media transcribed to artifact ${transcript.id}`);
+    if (normalizationRequired && !transcript) {
+      logger?.log("telegram", `media normalization unavailable for chat ${route.transportChatId}: ${toolResult?.error || toolResult?.missingConfig?.join(", ") || "unknown error"}`);
+    }
+    const prompt = buildPrompt({ ctx, artifact, transcript, toolResult });
+    if (!isGeneralWorkspaceRoute(route)) return prompt;
+    const [topics, recentProposals] = await Promise.all([
+      workspaceTopics.listTopics(route.ownerChatId, route.transportChatId),
+      workspaceTopics.listRecentProposals(route.ownerChatId, route.transportChatId)
+    ]);
+    return appendGeneralReplyRoutingInstruction(prompt, topics, recentProposals);
+  }
+
+  async function processPromptForChat({ chatId, prompt, ctx = null, executionReceipt = null }) {
+    const route = ctx ? contextRoute(ctx) : directChatRoute(chatId);
+    const sessionId = route.sessionId;
+    const bridge = createTelegramSessionBridge(route);
+    const messageOptions = (extra = {}) => route.workspace && route.threadId
+      ? { ...extra, message_thread_id: route.threadId }
+      : extra;
+    const work = async () => {
+      await ensureWorkspaceTopicModelSelection(route);
+      if (route.workspace && route.threadId) {
+        const handoff = await sessionSeeds.consume(sessionId);
+        if (handoff) {
+          agentManager.resetSession(sessionId, { handoff });
+          await agentManager.waitForSessionClose(sessionId);
+        }
+      }
+      const sessionContext = await agentManager.getSessionContext(sessionId, bridge, {
+        scopeChatId: route.scopeChatId,
+        accessGuard: createWorkspaceAccessGuard(route)
+      });
+      const { session, speedController } = sessionContext;
+      let text = "";
+      const chatState = getChatState(sessionId);
+      chatState.activeSession = session;
+      chatState.activeRoute = route;
+      try {
+        text = await withPromptSpeed(scheduledPromptSpeedOptions({
+          prompt,
+          session,
+          speedController,
+          configuredSpeed: resolveChatSpeed(config, sessionId)
+        }), () => collectText(session, prompt, {
+          logger,
+          chatId: sessionId,
+          onSlowPrompt: () => api.sendMessage(
+            route.transportChatId,
+            "This is taking longer than 5 minutes, so I will keep the current session running instead of starting over. Send /new if you want to abandon it and start fresh.",
+            messageOptions()
+          )
+        }));
+      } catch (error) {
+        agentManager.resetSession(sessionId);
+        if (error && typeof error === "object") {
+          error.retryable = false;
+          error.outcomeUncertain = true;
+        }
+        throw error;
+      } finally {
+        if (chatState.activeSession === session) chatState.activeSession = null;
+        chatState.activeRoute = null;
+        await sessionContext.release?.();
+      }
+      executionReceipt?.resolve({ status: "executed" });
+      if (!text) return;
+      const topics = route.workspace && route.ownerChatId
+        ? await workspaceTopics.listTopics(route.ownerChatId, route.transportChatId)
+        : [];
+      const routedReply = routeGeneralWorkspaceReply({ route, text, topics });
+      if (routedReply.proposal) {
+        await workspaceTopics.recordProposal(route.ownerChatId, route.transportChatId, routedReply.proposal);
+        logger?.log("telegram", `recorded topic proposal ${routedReply.proposal} for workspace ${route.transportChatId}`);
+      }
+      if (!routedReply.text) return;
+      const deliveryRoute = routedReply.route;
+      const deliveryOptions = (extra = {}) => deliveryRoute.workspace && deliveryRoute.threadId
+        ? { ...extra, message_thread_id: deliveryRoute.threadId }
+        : extra;
+      await createWorkspaceAccessGuard(deliveryRoute)();
+      if (routedReply.topic) {
+        logger?.log("telegram", `routing General reply to topic ${routedReply.topic.threadId} (${routedReply.topic.name})`);
+      }
+      await sendTextReply({
+        sendText: (message, extra) => api.sendMessage(deliveryRoute.transportChatId, message, deliveryOptions(extra)),
+        sendDocument: (file, extra) => api.sendDocument(deliveryRoute.transportChatId, file, deliveryOptions(extra)),
+        chatId: sessionId,
+        artifactChatId: deliveryRoute.scopeChatId,
+        text: routedReply.text
+      });
+    };
+
+    return agentManager.runTurn({
+      priority: executionReceipt?.priority || "interactive",
+      label: executionReceipt?.label || `interactive prompt for ${sessionId}`,
+      queueTtlMs: executionReceipt?.queueTtlMs
+    }, () => {
+      executionReceipt?.start?.();
+      return ctx ? withTyping(ctx, work) : work();
+    });
+  }
+
+  function processChatPromptQueue({ chatId, prompt, label, ctx = null, beforeInitialPrompt, initialReceipt = null }) {
+    const chatState = getChatState(chatId);
+    return drainChatPromptQueue({
+      chatState,
+      initialPrompt: prompt,
+      initialCtx: ctx,
+      initialReceipt,
+      beforeInitialPrompt,
+      processPrompt: ({ prompt: currentPrompt, ctx: currentCtx, receipt }) => {
+        logger?.log("telegram", `prompt dispatch for chat ${chatId}`);
+        return processPromptForChat({ chatId, prompt: currentPrompt, ctx: currentCtx, executionReceipt: receipt });
+      },
+      onPromptInterrupted: (error) => {
+        logger?.log("telegram", `${label} interrupted by queued /new for chat ${chatId}: ${getErrorMessage(error)}`);
+      },
+      onPromptFailure: async (error) => {
+        const message = getErrorMessage(error);
+        logger?.error("telegram", `${label} failed for chat ${chatId}: ${message}`);
+        await authController.notifyIssueIfNeeded(chatId, error);
+      }
+    });
+  }
+
+  async function enqueuePrompt({
+    chatId,
+    prompt,
+    label,
+    ctx = null,
+    replaceQueued = false,
+    busyMessageMode = "queue",
+    waitForExecution = false,
+    onExecutionStart = null,
+    coalesceQueued = false,
+    turnPriority = "interactive",
+    turnQueueTtlMs = undefined
+  }) {
+    const chatState = getChatState(chatId);
+    const receipt = waitForExecution ? createPromptExecutionReceipt(onExecutionStart, {
+      priority: turnPriority,
+      label,
+      queueTtlMs: turnQueueTtlMs,
+      deferStart: true
+    }) : null;
+
+    if (chatState.processing) {
+      const incomingRoute = ctx ? contextRoute(ctx) : null;
+      const activeRoute = chatState.activeRoute;
+      const sameDelivery = !incomingRoute || !activeRoute || (
+        incomingRoute.transportChatId === activeRoute.transportChatId
+        && incomingRoute.threadId === activeRoute.threadId
+      );
+      const routed = await routeBusyPrompt({
+        chatState,
+        prompt,
+        mode: sameDelivery ? busyMessageMode : "queue",
+        replaceQueued,
+        ctx,
+        receipt,
+        coalesceQueued
+      });
+      if (routed.disposition === "steered") {
+        logger?.log("telegram", `chat ${chatId} busy, steering ${label}`);
+      } else if (routed.disposition === "coalesced") {
+        logger?.log("telegram", `chat ${chatId} busy, coalescing ${label} into pending direct turn`);
+      } else {
+        logger?.log("telegram", `chat ${chatId} busy, queueing ${label}`);
+        if (routed.steerError) {
+          logger?.log("telegram", `steer failed for chat ${chatId}, queued instead: ${getErrorMessage(routed.steerError)}`);
+        }
+      }
+      if (replaceQueued) chatState.continueAfterClose = true;
+      return receipt ? receipt.promise : undefined;
+    }
+
+    chatState.processing = true;
+    logger?.log("telegram", `processing ${label} in chat ${chatId}`);
+    const draining = processChatPromptQueue({ chatId, prompt, label, ctx, initialReceipt: receipt });
+    if (!receipt) return draining;
+    draining.catch(() => {});
+    return receipt.promise;
+  }
+
+  async function enqueueOrProcess(ctx) {
+    const route = contextRoute(ctx);
+    const chatState = getChatState(route.sessionId);
+
+    if (chatState.processing) {
+      await ensureQueuedTyping(chatState, ctx);
+      const incomingPrompt = await buildIncomingPrompt(ctx, route);
+      const busyMessageMode = resolveBusyMessageMode({
+        config,
+        route,
+        message: ctx.message
+      });
+      return enqueuePrompt({
+        chatId: route.sessionId,
+        prompt: incomingPrompt,
+        label: `message ${ctx.msg.message_id}`,
+        busyMessageMode,
+        coalesceQueued: busyMessageMode === "steer" && typeof ctx.message?.text === "string",
+        ctx
+      });
+    }
+
+    const incomingPrompt = await buildIncomingPrompt(ctx, route);
+    return enqueuePrompt({
+      chatId: route.sessionId,
+      prompt: incomingPrompt,
+      label: `message ${ctx.msg.message_id}`,
+      ctx
+    });
+  }
+
+  async function summarizeSessionBeforeReset(chatId, route = directChatRoute(chatId)) {
+    let context;
+    try {
+      context = await agentManager.getSessionContext(chatId, createTelegramSessionBridge(route), {
+        scopeChatId: route.scopeChatId,
+        accessGuard: createWorkspaceAccessGuard(route)
+      });
+      const parentSession = context.session.sessionFile || "";
+      if (!context.session.messages.length) return { handoff: "", parentSession: "" };
+
+      const summary = await collectText(context.session, buildSessionHandoffPrompt(), { logger, chatId });
+      return { handoff: sanitizeSessionHandoff(summary), parentSession };
+    } catch (error) {
+      logger?.log("agent", `session handoff summary failed for chat ${chatId}: ${getErrorMessage(error)}`);
+      return { handoff: "", parentSession: "" };
+    } finally {
+      await context?.release?.();
+    }
+  }
+
+  async function handleNewCommand(ctx) {
+    const route = contextRoute(ctx);
+    const sessionId = route.sessionId;
+    const chatState = getChatState(sessionId);
+    const wasProcessing = chatState.processing;
+    chatState.historyRevision += 1;
+    const commandRevision = chatState.historyRevision;
+    const prompt = buildNewSessionPrompt(ctx);
+
+    if (wasProcessing) {
+      logger?.log("telegram", `chat ${sessionId} busy, queueing new-session command`);
+      queueChatPrompt(chatState, prompt, { replace: true, ctx });
+      chatState.continueAfterClose = true;
+      const reset = (async () => {
+        await sessionSeeds.clear(sessionId);
+        agentManager.resetSession(sessionId);
+      })();
+      chatState.beforeNextPrompt = reset;
+      try {
+        await reset;
+      } finally {
+        if (chatState.beforeNextPrompt === reset) chatState.beforeNextPrompt = null;
+      }
+      return;
+    }
+
+    chatState.processing = true;
+    logger?.log("telegram", `processing new-session command in chat ${sessionId}`);
+    await processChatPromptQueue({
+      chatId: sessionId,
+      prompt,
+      label: "new-session command",
+      ctx,
+      beforeInitialPrompt: async () => {
+        const handoff = await withTyping(ctx, () => summarizeSessionBeforeReset(sessionId, route));
+        if (chatState.historyRevision !== commandRevision) return;
+        if (route.workspace && route.threadId) {
+          await sessionSeeds.set(sessionId, handoff.handoff);
+        } else {
+          await sessionSeeds.clear(sessionId);
+        }
+        if (chatState.historyRevision !== commandRevision) return;
+        agentManager.resetSession(sessionId, handoff);
+      }
+    });
+  }
+
+  return {
+    buildIncomingPrompt,
+    enqueueOrProcess,
+    enqueuePrompt,
+    handleNewCommand,
+    processChatPromptQueue,
+    processPromptForChat,
+    summarizeSessionBeforeReset
+  };
+}

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

@@ -1,6 +1,6 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { getChatTelegramWorkspacesFile } from "../../runtime/paths.js";
+import { getChatTelegramWorkspacesFile } from "../../platform/paths.js";
 
 const recentProposalWindowMs = 30 * 24 * 60 * 60 * 1000;
 

package/test/agent-session-lifecycle.test.js

@@ -46,8 +46,17 @@ test("session lifecycle diagnostics remain available after extraction", async ()
     harness: "pi",
     sessions: 1,
     closingSessions: 0,
+    cache: {
+      maxSessions: 3,
+      maxPersistedBytes: 48 * 1024 * 1024,
+      sessions: 1,
+      persistedBytes: 0
+    },
     contexts: [{
       chatId: "123",
+      activeUsers: 0,
+      persistedBytes: 0,
+      lastAccessedAt: null,
       messages: 2,
       estimatedTokens: 42,
       tokens: 42,
@@ -56,3 +65,86 @@ test("session lifecycle diagnostics remain available after extraction", async ()
     }]
   });
 });
+
+test("evicts the least recently used inactive session without touching active work", async () => {
+  const closed = [];
+  const lifecycle = new AgentSessionLifecycle({
+    logger: null,
+    summarizeContext: () => ({}),
+    cachePolicy: { maxSessions: 2, maxPersistedBytes: 1_000 }
+  });
+  lifecycle.sessions.set("active-old", {
+    activeUsers: 1,
+    lastAccessedAt: 1,
+    persistedBytes: 100,
+    session: { async close() { closed.push("active-old"); } }
+  });
+  lifecycle.sessions.set("inactive-old", {
+    activeUsers: 0,
+    lastAccessedAt: 2,
+    persistedBytes: 100,
+    session: { async close() { closed.push("inactive-old"); } }
+  });
+  lifecycle.sessions.set("current", {
+    activeUsers: 1,
+    lastAccessedAt: 3,
+    persistedBytes: 100,
+    session: { async close() { closed.push("current"); } }
+  });
+
+  const evicted = await lifecycle.enforceCachePolicy({ protectedSessionKeys: ["current"] });
+
+  assert.deepEqual(evicted, [{ sessionKey: "inactive-old", persistedBytes: 100 }]);
+  assert.deepEqual(closed, ["inactive-old"]);
+  assert.deepEqual([...lifecycle.sessions.keys()], ["active-old", "current"]);
+});
+
+test("pressure eviction closes every inactive session while preserving active work", async () => {
+  const closed = [];
+  const lifecycle = new AgentSessionLifecycle({
+    logger: null,
+    summarizeContext: () => ({})
+  });
+  lifecycle.sessions.set("active", {
+    activeUsers: 1,
+    lastAccessedAt: 1,
+    session: { async close() { closed.push("active"); } }
+  });
+  lifecycle.sessions.set("idle-old", {
+    lastAccessedAt: 2,
+    session: { async close() { closed.push("idle-old"); } }
+  });
+  lifecycle.sessions.set("idle-new", {
+    lastAccessedAt: 3,
+    session: { async close() { closed.push("idle-new"); } }
+  });
+
+  const evicted = await lifecycle.evictInactive();
+
+  assert.deepEqual(evicted.map((item) => item.sessionKey), ["idle-old", "idle-new"]);
+  assert.deepEqual(closed, ["idle-old", "idle-new"]);
+  assert.deepEqual([...lifecycle.sessions.keys()], ["active"]);
+});
+
+test("uses persisted session weight as a second cache bound", async () => {
+  const lifecycle = new AgentSessionLifecycle({
+    logger: null,
+    summarizeContext: () => ({}),
+    cachePolicy: { maxSessions: 10, maxPersistedBytes: 100 }
+  });
+  lifecycle.sessions.set("large-old", {
+    lastAccessedAt: 1,
+    persistedBytes: 80,
+    session: { close() {} }
+  });
+  lifecycle.sessions.set("recent", {
+    lastAccessedAt: 2,
+    persistedBytes: 40,
+    session: { close() {} }
+  });
+
+  await lifecycle.enforceCachePolicy({ protectedSessionKeys: ["recent"] });
+
+  assert.deepEqual([...lifecycle.sessions.keys()], ["recent"]);
+  assert.deepEqual(lifecycle.cacheUsage(), { sessions: 1, persistedBytes: 40 });
+});

package/test/agent-turn-coordinator.test.js

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { AgentTurnCoordinator } from "../src/core/agent/agent-turn-coordinator.js";
+
+test("interactive turns run before queued background turns without overlapping", async () => {
+  const coordinator = new AgentTurnCoordinator();
+  const releaseActive = await coordinator.acquire({ priority: "background", label: "active background" });
+  let backgroundStarted = false;
+  const background = coordinator.acquire({ priority: "background", label: "queued background" }).then((release) => {
+    backgroundStarted = true;
+    return release;
+  });
+  const interactive = coordinator.acquire({ priority: "interactive", label: "interactive" });
+
+  releaseActive();
+  const releaseInteractive = await interactive;
+  assert.equal(backgroundStarted, false);
+  assert.equal(coordinator.diagnostic().active.priority, "interactive");
+  releaseInteractive();
+  const releaseBackground = await background;
+  assert.equal(backgroundStarted, true);
+  releaseBackground();
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(coordinator.diagnostic().active, null);
+  assert.equal(coordinator.diagnostic().completed, 3);
+});
+
+test("background turns expire safely before execution when their queue TTL elapses", async () => {
+  const coordinator = new AgentTurnCoordinator();
+  const releaseActive = await coordinator.acquire({ priority: "interactive", label: "active" });
+  await assert.rejects(
+    coordinator.acquire({ priority: "background", label: "stale batch", queueTtlMs: 10 }),
+    (error) => error.code === "AGENT_TURN_QUEUE_EXPIRED" && error.retryable === true && error.outcomeUncertain === false
+  );
+  assert.equal(coordinator.diagnostic().expired, 1);
+  releaseActive();
+});
+
+test("run releases exclusive admission after failures", async () => {
+  const coordinator = new AgentTurnCoordinator();
+  await assert.rejects(coordinator.run({ priority: "background" }, async () => { throw new Error("failed"); }), /failed/);
+  const result = await coordinator.run({ priority: "interactive" }, async () => "ok");
+  assert.equal(result, "ok");
+  assert.equal(coordinator.diagnostic().completed, 2);
+});

package/test/architecture-boundaries.test.js

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const coreDir = path.join(packageDir, "src", "core");
+
+async function javascriptFiles(directory) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  const nested = await Promise.all(entries.map((entry) => {
+    const target = path.join(directory, entry.name);
+    if (entry.isDirectory()) return javascriptFiles(target);
+    return entry.isFile() && entry.name.endsWith(".js") ? [target] : [];
+  }));
+  return nested.flat();
+}
+
+test("core does not depend on the runtime composition layer", async () => {
+  const violations = [];
+  for (const file of await javascriptFiles(coreDir)) {
+    const source = await readFile(file, "utf8");
+    if (/from\s+["'][^"']*\/runtime\//.test(source)) {
+      violations.push(path.relative(packageDir, file));
+    }
+  }
+  assert.deepEqual(violations, []);
+});

package/test/bootstrap.test.js

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { buildConfig } from "../src/runtime/bootstrap.js";
+import {
+  buildBootstrapConfig,
+  parseYesNo,
+  selectByIndex,
+  selectPiLoginOption,
+  sortBootstrapModels,
+  sortBootstrapProviders
+} from "../src/runtime/bootstrap-config.js";
+
+
+test("bootstrap facade preserves the shared config builder", () => {
+  assert.equal(buildConfig, buildBootstrapConfig);
+  const config = buildConfig({
+    telegramApiKey: "telegram-token",
+    telegramMaxChatIds: 2,
+    authorizedChatIds: [123],
+    chatMeta: { 123: { languageCode: "es" } },
+    provider: "openai-codex",
+    model: "gpt-5.5",
+    piApiKey: "pi-key"
+  });
+
+  assert.equal(config.telegram.token, "telegram-token");
+  assert.equal(config.telegram.maxChatIds, 2);
+  assert.deepEqual(config.telegram.authorizedChatIds, [123]);
+  assert.equal(config.pi.provider, "openai-codex");
+  assert.equal(config.pi.model, "gpt-5.5");
+  assert.equal(config.pi.apiKey, "pi-key");
+});
+
+test("shared bootstrap policy keeps provider and model ordering stable", () => {
+  const providers = [
+    { provider: "anthropic" },
+    { provider: "openai-codex" },
+    { provider: "google" }
+  ];
+  assert.deepEqual(
+    sortBootstrapProviders(providers).map((item) => item.provider),
+    ["openai-codex", "anthropic", "google"]
+  );
+  assert.deepEqual(providers.map((item) => item.provider), ["anthropic", "openai-codex", "google"]);
+
+  const models = [{ id: "older" }, { id: "gpt-5.5" }, { id: "newer" }];
+  assert.deepEqual(
+    sortBootstrapModels("openai-codex", models).map((item) => item.id),
+    ["gpt-5.5", "newer", "older"]
+  );
+  assert.equal(selectByIndex(models, "99"), models[2]);
+});
+
+test("shared bootstrap input policy preserves localized yes/no and login preference", () => {
+  assert.equal(parseYesNo("sí"), true);
+  assert.equal(parseYesNo("no"), false);
+  assert.equal(parseYesNo("maybe"), null);
+  assert.equal(parseYesNo("", false), false);
+
+  const selected = selectPiLoginOption([
+    { id: "browser", label: "Browser OAuth" },
+    { id: "device", label: "Device code" }
+  ]);
+  assert.equal(selected.id, "device");
+});

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

@@ -395,6 +395,7 @@ test("selectScheduledTasks bounds history while keeping active tasks", () => {
     status: "done"
   }));
   tasks[0] = { id: "pending-1", status: "pending" };
+  tasks[1] = { id: "blocked-1", status: "blocked_auth" };
 
   const result = selectScheduledTasks(tasks);
 
@@ -402,7 +403,7 @@ test("selectScheduledTasks bounds history while keeping active tasks", () => {
   assert.equal(result.returned, 50);
   assert.equal(result.limit, 50);
   assert.equal(result.truncated, true);
-  assert.equal(result.tasks[0].id, "pending-1");
+  assert.deepEqual(result.tasks.slice(0, 2).map((task) => task.id), ["blocked-1", "pending-1"]);
 });
 
 test("selectScheduledTasks honors an explicit status and limit", () => {

package/test/daemon-process-invocation.test.js

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { daemonProcessInvocation } from "../src/core/tools/daemon-processes.js";
+
+test("gives Linux tool daemons a higher OOM kill priority than core", () => {
+  assert.deepEqual(daemonProcessInvocation("/tool/index.js", {
+    platform: "linux",
+    nodePath: "/usr/bin/node",
+    oomAdjustAvailable: true
+  }), {
+    command: "/usr/bin/choom",
+    args: ["-n", "500", "--", "/usr/bin/node", "/tool/index.js", "daemon"],
+    oomProtected: true
+  });
+});
+
+test("starts tool daemons directly when OOM adjustment is unavailable", () => {
+  assert.deepEqual(daemonProcessInvocation("/tool/index.js", {
+    platform: "darwin",
+    nodePath: "/usr/bin/node",
+    oomAdjustAvailable: false
+  }), {
+    command: "/usr/bin/node",
+    args: ["/tool/index.js", "daemon"],
+    oomProtected: false
+  });
+});