arisa 5.2.7 → 5.2.19

package/test/slave-cli.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { access, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { access, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -8,9 +8,15 @@ import { parseSlaveBootstrapUrl } from "../src/runtime/slave-bootstrap-url.js";
 import { withSecureRequestFile } from "../src/runtime/secure-request-file.js";
 import { ensureMasterSlaveTool, formatSlaveStatus, runSlaveBootstrap, runSlaveCli } from "../src/runtime/slave-cli.js";
 import {
+  buildSlaveLaunchdPlist,
   buildSlaveSystemdUnit,
+  buildSlaveWindowsLauncher,
+  buildSlaveWindowsTaskXml,
+  controlSlaveService,
   getSlavePaths,
+  installSlaveLaunchdService,
   installSlaveSystemdService,
+  installSlaveWindowsService,
   registerSlaveServiceProcess,
   selectSlaveServiceAccount
 } from "../src/runtime/slave-service.js";
@@ -75,6 +81,14 @@ test("selects the invoking service account without prompting", async () => {
     await selectSlaveServiceAccount({ euid: 0, currentUser: "root", environment: {} }),
     { scope: "system", user: "root", root: true, dedicated: false }
   );
+  assert.deepEqual(
+    await selectSlaveServiceAccount({
+      platform: "win32",
+      currentUser: "martin.clasen",
+      environment: { USERDOMAIN: "MCL4SEN", USERNAME: "martin.clasen" }
+    }),
+    { scope: "user", user: "MCL4SEN\\martin.clasen", root: false, dedicated: false }
+  );
 });
 
 test("builds a dedicated headless systemd service with isolated state", () => {
@@ -106,7 +120,7 @@ test("escapes systemd WorkingDirectory paths without quoting the entire value",
 
 test("reports Master connectivity separately from pairing and daemon readiness", () => {
   const text = formatSlaveStatus({
-    systemd: { running: true, status: "active" },
+    service: { running: true, status: "active", serviceManager: "launchd" },
     diagnostic: {
       daemon: { state: "ready" },
       role: "slave",
@@ -118,6 +132,7 @@ test("reports Master connectivity separately from pairing and daemon readiness",
       pendingSecrets: 0
     }
   });
+  assert.match(text, /Service \(launchd\): active/);
   assert.match(text, /Daemon: ready/);
   assert.match(text, /Paired: yes/);
   assert.match(text, /Connected: no/);
@@ -163,6 +178,207 @@ test("installs and restarts the Linux systemd target after pairing", async (t) =
   ]);
 });
 
+test("builds and installs a macOS launchd service with isolated state", async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-launchd-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const account = { scope: "user", user: "tester", root: false, dedicated: false };
+  const slaveHome = path.join(root, "home & state");
+  const entryFile = "/Applications/Arisa & Tools/index.js";
+  const plist = buildSlaveLaunchdPlist({
+    account,
+    slaveHome,
+    entryFile,
+    nodePath: "/opt/homebrew/bin/node",
+    environment: { PATH: "/opt/homebrew/bin:/usr/bin" }
+  });
+  assert.match(plist, /<string>com\.arisa\.slave<\/string>/);
+  assert.match(plist, /<string>\/Applications\/Arisa &amp; Tools\/index\.js<\/string>/);
+  assert.match(plist, /<string>\/opt\/homebrew\/bin:\/usr\/bin<\/string>/);
+  assert.match(plist, /<key>RunAtLoad<\/key>\n  <true\/>/);
+  assert.match(plist, /<key>KeepAlive<\/key>\n  <true\/>/);
+
+  const calls = [];
+  const unitDir = path.join(root, "LaunchAgents");
+  const result = await installSlaveLaunchdService({
+    account,
+    slaveHome,
+    entryFile,
+    execute: async (command, args) => {
+      calls.push([command, args]);
+      if (args[0] === "bootout") throw new Error("not loaded");
+      return { stdout: "", stderr: "" };
+    },
+    environment: { PATH: "/opt/homebrew/bin:/usr/bin" },
+    platform: "darwin",
+    uid: 501,
+    userUnitDir: unitDir
+  });
+  assert.equal(result.serviceManager, "launchd");
+  assert.equal(result.serviceTarget, "gui/501/com.arisa.slave");
+  assert.equal(await access(result.unitFile).then(() => true, () => false), true);
+  assert.deepEqual(calls.slice(1), [
+    ["launchctl", ["bootstrap", "gui/501", result.unitFile]],
+    ["launchctl", ["enable", "gui/501/com.arisa.slave"]],
+    ["launchctl", ["kickstart", "-k", "gui/501/com.arisa.slave"]]
+  ]);
+});
+
+test("controls a persisted macOS launchd service", async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-launchd-control-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const paths = getSlavePaths(root);
+  await mkdir(paths.state, { recursive: true });
+  await writeFile(paths.descriptorFile, `${JSON.stringify({
+    serviceManager: "launchd",
+    serviceTarget: "gui/501/com.arisa.slave",
+    unitFile: "/Users/tester/Library/LaunchAgents/com.arisa.slave.plist"
+  })}\n`);
+  const calls = [];
+  const execute = async (command, args) => {
+    calls.push([command, args]);
+    return { stdout: "", stderr: "" };
+  };
+  const status = await controlSlaveService(paths, "status", { execute });
+  assert.deepEqual(status, { running: true, status: "active", serviceManager: "launchd" });
+  await controlSlaveService(paths, "restart", { execute });
+  assert.deepEqual(calls, [
+    ["launchctl", ["print", "gui/501/com.arisa.slave"]],
+    ["launchctl", ["print", "gui/501/com.arisa.slave"]],
+    ["launchctl", ["enable", "gui/501/com.arisa.slave"]],
+    ["launchctl", ["kickstart", "-k", "gui/501/com.arisa.slave"]]
+  ]);
+});
+
+test("builds, installs, and controls a Windows scheduled Slave task", async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-windows-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const account = { scope: "user", user: "MCL4SEN\\martin.clasen", root: false, dedicated: false };
+  const entryFile = path.join(root, "Arisa & Tools", "index.js");
+  const launcher = buildSlaveWindowsLauncher({
+    slaveHome: path.join(root, "slave's home"),
+    entryFile,
+    nodePath: path.join(root, "Node", "node.exe")
+  });
+  assert.match(launcher, /process\.env\.ARISA_SLAVE_HOME/);
+  assert.match(launcher, /slave's home/);
+  assert.match(launcher, /"--service-runner"/);
+  assert.match(launcher, /windowsHide: true/);
+  assert.doesNotThrow(() => new Function(launcher));
+
+  const taskXml = buildSlaveWindowsTaskXml({
+    account,
+    launcherFile: path.join(root, "arisa-slave-launcher.cjs"),
+    nodePath: path.join(root, "Node", "node.exe")
+  });
+  assert.match(taskXml, /<UserId>MCL4SEN\\martin\.clasen<\/UserId>/);
+  assert.match(taskXml, /<RestartOnFailure>/);
+  assert.match(taskXml, /Node\/node\.exe/);
+  assert.match(taskXml, /arisa-slave-launcher\.cjs/);
+  assert.match(taskXml, /<WorkingDirectory>/);
+
+  const calls = [];
+  const result = await installSlaveWindowsService({
+    account,
+    slaveHome: path.join(root, "home"),
+    entryFile,
+    execute: async (command, args) => {
+      calls.push([command, args]);
+      if (args[0] === "/End") throw new Error("not running");
+      return { stdout: "", stderr: "" };
+    },
+    platform: "win32"
+  });
+  assert.equal(result.serviceManager, "windows-task");
+  assert.equal(result.serviceTarget, "Arisa Slave");
+  assert.equal(await access(result.launcherFile).then(() => true, () => false), true);
+  assert.equal(await access(result.unitFile).then(() => true, () => false), true);
+  const persistedLauncher = await readFile(result.launcherFile);
+  assert.deepEqual([...persistedLauncher.subarray(0, 3)], [0xef, 0xbb, 0xbf]);
+  const persistedTask = await readFile(result.unitFile);
+  assert.deepEqual([...persistedTask.subarray(0, 2)], [0xff, 0xfe]);
+  assert.match(persistedTask.toString("utf16le"), /<Task version="1\.4"/);
+  assert.deepEqual(calls.slice(1), [
+    ["schtasks.exe", ["/Create", "/TN", "Arisa Slave", "/XML", result.unitFile, "/F"]],
+    ["schtasks.exe", ["/Run", "/TN", "Arisa Slave"]]
+  ]);
+
+  const paths = result.paths;
+  await writeFile(paths.descriptorFile, `${JSON.stringify({
+    serviceManager: "windows-task",
+    serviceTarget: "Arisa Slave",
+    unitFile: result.unitFile,
+    launcherFile: result.launcherFile
+  })}\n`);
+  await writeFile(paths.pidFile, `${process.pid}\n`);
+  calls.length = 0;
+  const status = await controlSlaveService(paths, "status", { execute: async (command, args) => {
+    calls.push([command, args]);
+    return { stdout: "", stderr: "" };
+  } });
+  assert.deepEqual(status, { running: true, status: "active", serviceManager: "windows-task" });
+  assert.deepEqual(calls, [["schtasks.exe", ["/Query", "/TN", "Arisa Slave"]]]);
+});
+
+test("bootstraps macOS through launchd and persists its service identity", async (t) => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-macos-bootstrap-"));
+  t.after(() => rm(home, { recursive: true, force: true }));
+  const paths = getSlavePaths(home);
+  const account = { scope: "user", user: "tester", root: false, dedicated: false };
+  const unitFile = "/Users/tester/Library/LaunchAgents/com.arisa.slave.plist";
+  await runSlaveBootstrap(`tcp://198.51.100.12:4719/${secret}`, {
+    paths,
+    entryFile: "/opt/arisa/src/index.js",
+    platform: "darwin",
+    selectAccount: async () => account,
+    ensureTool: async () => {},
+    invokeTool: async () => ({ ok: true }),
+    installService: async (options) => {
+      assert.equal(options.platform, "darwin");
+      return {
+        serviceManager: "launchd",
+        serviceTarget: "gui/501/com.arisa.slave",
+        unitFile
+      };
+    },
+    output: { log: () => {} }
+  });
+  const descriptor = JSON.parse(await readFile(paths.descriptorFile, "utf8"));
+  assert.equal(descriptor.serviceManager, "launchd");
+  assert.equal(descriptor.serviceTarget, "gui/501/com.arisa.slave");
+  assert.equal(descriptor.unitFile, unitFile);
+  assert.deepEqual(descriptor.account, account);
+});
+
+test("bootstraps Windows through Task Scheduler and persists its service identity", async (t) => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-windows-bootstrap-"));
+  t.after(() => rm(home, { recursive: true, force: true }));
+  const paths = getSlavePaths(home);
+  const account = { scope: "user", user: "MCL4SEN\\martin.clasen", root: false, dedicated: false };
+  const launcherFile = path.join(home, "state", "arisa-slave-launcher.cjs");
+  await runSlaveBootstrap(`tcp://198.51.100.12:4719/${secret}`, {
+    paths,
+    entryFile: "/opt/arisa/src/index.js",
+    platform: "win32",
+    selectAccount: async () => account,
+    ensureTool: async () => {},
+    invokeTool: async () => ({ ok: true }),
+    installService: async (options) => {
+      assert.equal(options.platform, "win32");
+      return {
+        serviceManager: "windows-task",
+        serviceTarget: "Arisa Slave",
+        unitFile: path.join(home, "state", "arisa-slave-task.xml"),
+        launcherFile
+      };
+    },
+    output: { log: () => {} }
+  });
+  const descriptor = JSON.parse(await readFile(paths.descriptorFile, "utf8"));
+  assert.equal(descriptor.serviceManager, "windows-task");
+  assert.equal(descriptor.serviceTarget, "Arisa Slave");
+  assert.equal(descriptor.launcherFile, launcherFile);
+});
+
 test("validates before effects and keeps the bootstrap secret out of service metadata", async (t) => {
   const home = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-home-"));
   t.after(() => rm(home, { recursive: true, force: true }));
@@ -298,7 +514,7 @@ test("combines systemd and local tool diagnostics for Slave status", async (t) =
     paths: getSlavePaths(home),
     controlService: async (_paths, operation) => {
       assert.equal(operation, "status");
-      return { running: true, status: "active" };
+      return { running: true, status: "active", serviceManager: "systemd" };
     },
     toolInstalled: async () => true,
     invokeTool: async (_paths, args) => {
@@ -321,8 +537,8 @@ test("combines systemd and local tool diagnostics for Slave status", async (t) =
     },
     output: { log: (line) => output.push(line) }
   });
-  assert.equal(result.systemd.running, true);
-  assert.match(output[0], /Systemd: active/);
+  assert.equal(result.service.running, true);
+  assert.match(output[0], /Service \(systemd\): active/);
   assert.match(output[0], /Daemon: ready/);
   assert.match(output[0], /Role: slave/);
   assert.match(output[0], /Endpoint: tcp:\/\/198\.51\.100\.12:4719/);

package/test/task-store.test.js

@@ -121,6 +121,40 @@ test("recovers interrupted running tasks for retry after restart", async () => {
   );
 });
 
+test("persists auth blocks, claims only due probes, and clears the block after success", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  await store.add({
+    id: "auth-poll",
+    kind: "poll_tool",
+    runAt: new Date(Date.now() - 1000).toISOString(),
+    payload: { toolName: "checker", args: { action: "poll" } },
+    recurrence: { type: "interval", everySeconds: 60 }
+  });
+
+  await store.claimDue();
+  const blocked = await store.blockAuth("auth-poll", "authentication expired", {
+    retryAfterSeconds: 3600,
+    probeArgs: { action: "auth-status" },
+    toolName: "checker"
+  });
+  assert.equal(blocked.status, "blocked_auth");
+  assert.equal(blocked.authBlockedNew, true);
+  assert.deepEqual(blocked.authBlock.probeArgs, { action: "auth-status" });
+  assert.equal(blocked.authBlock.toolName, "checker");
+  assert.deepEqual(await store.claimDue(), []);
+
+  store.tasks.find((task) => task.id === "auth-poll").runAt = new Date(Date.now() - 1000).toISOString();
+  await store.save();
+  const [probe] = await store.claimDue();
+  assert.equal(probe.status, "running");
+  assert.ok(probe.authBlock);
+
+  const completed = await store.complete("auth-poll");
+  assert.equal(completed.status, "pending");
+  assert.equal(completed.authBlock, undefined);
+});
+
 test("completes one-off tasks and re-schedules recurring interval tasks", async () => {
   await resetHome();
   const store = new TaskStore();

package/test/telegram-prompt-controller.test.js

@@ -12,7 +12,8 @@ function createController(overrides = {}) {
     artifactStore: {},
     toolRegistry: {},
     agentManager: {
-      resetSession: (...args) => calls.reset.push(args)
+      resetSession: (...args) => calls.reset.push(args),
+      runTurn: async (_options, work) => work()
     },
     sessionSeeds: {
       clear: async (chatId) => calls.cleared.push(chatId)

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

@@ -7,6 +7,10 @@ function createHarness(overrides = {}) {
   const taskStore = {
     async fail(...args) { calls.push(["fail", ...args]); return { status: "failed" }; },
     async complete(...args) { calls.push(["complete", ...args]); return { status: "done" }; },
+    async blockAuth(taskId, error, resolution) {
+      calls.push(["blockAuth", taskId, error.message, resolution]);
+      return { status: "blocked_auth", authBlockedNew: true, authBlock: resolution, runAt: "2026-09-02T05:00:00.000Z" };
+    },
     async retryOrFail(taskId, error, options) {
       calls.push(["retryOrFail", taskId, error.message, options]);
       return { status: options.retryable ? "pending" : "failed" };
@@ -21,7 +25,10 @@ function createHarness(overrides = {}) {
     artifactStore: { forChat() { throw new Error("unexpected artifact access"); } },
     toolRegistry: {},
     resourceNotes: { async get() { return ""; } },
-    agentManager: { async runTool(input) { calls.push(["runTool", input]); return { ok: true }; } },
+    agentManager: {
+      async runTurn(options, work) { calls.push(["runTurn", options]); return work(); },
+      async runTool(input) { calls.push(["runTool", input]); return { ok: true }; }
+    },
     logger: null,
     ...overrides.dependencies
   });
@@ -74,7 +81,9 @@ test("passes bounded execution deadlines to scheduled prompts", async () => {
 
   const enqueues = calls.filter(([name]) => name === "enqueue");
   assert.equal(enqueues[0][1].timeoutMs, 900);
+  assert.equal(enqueues[0][1].priority, "background");
   assert.equal(enqueues[1][1].timeoutMs, 300);
+  assert.equal(enqueues[1][1].priority, "interactive");
 });
 
 test("acknowledges an agent event before executing it", async () => {
@@ -101,15 +110,121 @@ test("runs poll tools headlessly and confirms their result", async () => {
   });
 
   assert.deepEqual(calls, [
+    ["runTurn", { priority: "background", label: "poll tool checker" }],
     ["runTool", { name: "checker", request: { args: { cursor: "4" } }, chatId: 123 }],
     ["complete", "poll-1"]
   ]);
 });
 
+test("pauses a poll once when its tool reports terminal authentication failure", async () => {
+  const resolution = {
+    type: "reauthentication_required",
+    retryAfterSeconds: 3600,
+    probeArgs: { action: "auth-status" }
+  };
+  const { calls, dispatcher } = createHarness({
+    dependencies: {
+      agentManager: {
+        async runTurn(options, work) { calls.push(["runTurn", options]); return work(); },
+        async runTool(input) {
+          calls.push(["runTool", input]);
+          return { ok: false, status: "blocked_auth", error: "authentication expired", resolution };
+        }
+      }
+    }
+  });
+
+  await dispatcher.runClaimedTask({
+    id: "poll-auth",
+    kind: "poll_tool",
+    payload: { chatId: 123, toolName: "checker", args: { action: "poll" } }
+  });
+
+  assert.deepEqual(calls.at(-2), ["blockAuth", "poll-auth", "authentication expired", { ...resolution, toolName: "checker" }]);
+  assert.deepEqual(calls.at(-1), [
+    "send",
+    123,
+    "⚠️ Arisa automation paused for authentication\nTool: checker\nReason: authentication expired\nNext authentication check: 2026-09-02T05:00:00.000Z",
+    undefined
+  ]);
+});
+
+test("pauses a recurring agent task after a nested tool reports blocked authentication", async () => {
+  const resolution = {
+    type: "reauthentication_required",
+    retryAfterSeconds: 3600,
+    probeArgs: { action: "status" }
+  };
+  const { calls, dispatcher } = createHarness({
+    dependencies: {
+      enqueueAsyncPrompt: async (input) => {
+        calls.push(["enqueue", input]);
+        input.agentTaskExecution.blockedAuth = {
+          toolName: "creator-scout",
+          error: "authentication expired",
+          resolution
+        };
+      }
+    }
+  });
+
+  await dispatcher.runClaimedTask({
+    id: "agent-auth",
+    kind: "agent_task",
+    payload: { chatId: 123, prompt: "run harvest" },
+    recurrence: { type: "interval", everySeconds: 14400 }
+  });
+
+  assert.deepEqual(calls.at(-2), ["blockAuth", "agent-auth", "authentication expired", { ...resolution, toolName: "creator-scout" }]);
+  assert.deepEqual(calls.at(-1), [
+    "send",
+    123,
+    "⚠️ Arisa automation paused for authentication\nTool: creator-scout\nReason: authentication expired\nNext authentication check: 2026-09-02T05:00:00.000Z",
+    undefined
+  ]);
+  assert.equal(calls.some(([name]) => name === "complete"), false);
+});
+
+test("probes a blocked agent task before starting another reasoning turn", async () => {
+  const { calls, dispatcher } = createHarness();
+  await dispatcher.runClaimedTask({
+    id: "agent-resume",
+    kind: "agent_task",
+    authBlock: { toolName: "creator-scout", probeArgs: { action: "status" }, retryAfterSeconds: 3600 },
+    payload: { chatId: 123, prompt: "run harvest" }
+  });
+
+  assert.deepEqual(calls[0], ["runTurn", { priority: "background", label: "authentication probe creator-scout" }]);
+  assert.deepEqual(calls[1], ["runTool", {
+    name: "creator-scout",
+    request: { args: { action: "status" } },
+    chatId: 123
+  }]);
+  assert.equal(calls.filter(([name]) => name === "enqueue").length, 1);
+  assert.deepEqual(calls.at(-1), ["complete", "agent-resume"]);
+});
+
+test("uses a lightweight auth probe before resuming blocked poll work", async () => {
+  const { calls, dispatcher } = createHarness();
+  await dispatcher.runClaimedTask({
+    id: "poll-resume",
+    kind: "poll_tool",
+    authBlock: { probeArgs: { action: "auth-status" }, retryAfterSeconds: 3600 },
+    payload: { chatId: 123, toolName: "checker", args: { action: "poll" } }
+  });
+
+  assert.deepEqual(calls.filter(([name]) => name === "runTool").map((call) => call[1].request.args), [
+    { action: "auth-status" },
+    { action: "poll" }
+  ]);
+  assert.deepEqual(calls.at(-1), ["complete", "poll-resume"]);
+});
+
 test("retries a known poll failure with backoff", async () => {
   const { calls, dispatcher } = createHarness({
     dependencies: {
       agentManager: {
+        async runTurn(options, work) { calls.push(["runTurn", options]); return work(); },
         async runTool(input) {
           calls.push(["runTool", input]);
           return { ok: false, status: "failed", error: "temporary checker failure" };
@@ -220,10 +335,11 @@ test("due-task dispatch retries one failure without blocking another task", asyn
 
   await dispatcher.dispatchDueTasks();
 
-  assert.deepEqual(calls, [
+  assert.deepEqual(calls.slice(0, 3), [
     ["claimDue", 10],
-    ["runTool", { name: "checker", request: { args: {} }, chatId: 123 }],
-    ["complete", "good"],
-    ["retryOrFail", "bad", "queue unavailable", { retryable: true }]
+    ["runTurn", { priority: "background", label: "poll tool checker" }],
+    ["runTool", { name: "checker", request: { args: {} }, chatId: 123 }]
   ]);
+  assert.ok(calls.some((call) => JSON.stringify(call) === JSON.stringify(["complete", "good"])));
+  assert.ok(calls.some((call) => JSON.stringify(call) === JSON.stringify(["retryOrFail", "bad", "queue unavailable", { retryable: true }])));
 });

package/test/tool-registry-run.test.js

@@ -8,7 +8,7 @@ const homeDir = await mkdtemp(path.join(os.tmpdir(), "arisa-tool-registry-home-"
 process.env.HOME = homeDir;
 process.env.USERPROFILE = homeDir;
 
-const { ToolRegistry, createToolOutputParser, isolatedToolProcessInvocation } = await import("../src/core/tools/tool-registry.js");
+const { ToolRegistry, createToolOutputParser, isolatedToolProcessInvocation, readyDaemonAdmission } = await import("../src/core/tools/tool-registry.js");
 const { createToolOutputParser: directToolOutputParser } = await import("../src/core/tools/tool-process-output.js");
 const { isolatedToolProcessInvocation: directToolProcessInvocation } = await import("../src/core/tools/tool-process-runner.js");
 const {
@@ -242,6 +242,15 @@ test("reports dependency status in help and blocks a tool with a missing depende
   );
 });
 
+test("only a live ready declared daemon bypasses worker RSS spawn admission", () => {
+  const tool = { daemon: { scope: "chat", health: "internal" } };
+  assert.deepEqual(readyDaemonAdmission(tool, { alive: true, state: "ready", restart: { requested: false } }), { ignoreWorkerRss: true });
+  assert.deepEqual(readyDaemonAdmission(tool, { alive: false, state: "ready", restart: { requested: false } }), {});
+  assert.deepEqual(readyDaemonAdmission(tool, { alive: true, state: "degraded", restart: { requested: false } }), {});
+  assert.deepEqual(readyDaemonAdmission(tool, { alive: true, state: "ready", restart: { requested: true } }), {});
+  assert.deepEqual(readyDaemonAdmission({}, { alive: true, state: "ready" }), {});
+});
+
 test("wraps declared tool runs in the shared execution governor", async () => {
   await resetHome();
   await createFakeTool("heavy-tool", {

package/test/weighted-resource-governor.test.js

@@ -133,6 +133,34 @@ test("rejects declared heavy tools before spawn when memory pressure is unsafe",
   assert.equal(governor.snapshot().resources.browser.activeWeight, 0);
 });
 
+test("ready daemon jobs bypass only worker RSS spawn admission", async () => {
+  const governor = new WeightedResourceGovernor({
+    policy: { maxWorkerRssMb: 384, maxSwapUsedPercent: 95 },
+    memoryPressure: async () => ({
+      availableBytes: 512 * 1024 * 1024,
+      totalBytes: 4 * 1024 * 1024 * 1024,
+      workerRssBytes: 450 * 1024 * 1024,
+      swapTotalBytes: 100,
+      swapUsedPercent: 50
+    })
+  });
+  const lease = await governor.acquire({ resourceClass: "browser", weight: 1 }, "ready-daemon", { ignoreWorkerRss: true });
+  assert.equal(lease.memoryLimitMb, 384);
+  lease.release({ success: true });
+
+  governor.memoryPressure = async () => ({
+    availableBytes: 512 * 1024 * 1024,
+    totalBytes: 4 * 1024 * 1024 * 1024,
+    workerRssBytes: 450 * 1024 * 1024,
+    swapTotalBytes: 100,
+    swapUsedPercent: 96
+  });
+  await assert.rejects(
+    () => governor.acquire({ resourceClass: "browser", weight: 1 }, "ready-daemon", { ignoreWorkerRss: true }),
+    /swap use/
+  );
+});
+
 test("larger weights consume shared capacity and worker RSS peaks are retained", async () => {
   let rss = 120 * 1024 * 1024;
   const governor = new WeightedResourceGovernor({

package/test/worker-tool-fanout.test.js

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { WorkerToolFanoutController } from "../src/core/agent/worker-tool-fanout.js";
+
+function deferred() {
+  let resolve;
+  const promise = new Promise((done) => { resolve = done; });
+  return { promise, resolve };
+}
+
+function breaker(percent = 20) {
+  return {
+    sample: () => ({ heapUsed: percent, heapLimit: 100, percent }),
+    admit: async () => ({ heapUsed: percent, heapLimit: 100, percent })
+  };
+}
+
+test("admits low-pressure tool calls in pairs", async () => {
+  const controller = new WorkerToolFanoutController({ heapCircuitBreaker: breaker() });
+  const gates = Array.from({ length: 4 }, deferred);
+  let active = 0;
+  let peak = 0;
+  const runs = gates.map((gate) => controller.run(async () => {
+    active += 1;
+    peak = Math.max(peak, active);
+    await gate.promise;
+    active -= 1;
+  }));
+
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(active, 2);
+  gates[0].resolve();
+  gates[1].resolve();
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(active, 2);
+  gates[2].resolve();
+  gates[3].resolve();
+  await Promise.all(runs);
+
+  assert.equal(peak, 2);
+  assert.equal(controller.getDiagnostic().peakQueued, 3);
+});
+
+test("serializes tool calls when the worker heap is elevated", async () => {
+  const controller = new WorkerToolFanoutController({ heapCircuitBreaker: breaker(70) });
+  const gates = Array.from({ length: 3 }, deferred);
+  let active = 0;
+  let peak = 0;
+  const runs = gates.map((gate) => controller.run(async () => {
+    active += 1;
+    peak = Math.max(peak, active);
+    await gate.promise;
+    active -= 1;
+  }));
+
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(active, 1);
+  for (const gate of gates) {
+    gate.resolve();
+    await new Promise((resolve) => setImmediate(resolve));
+  }
+  await Promise.all(runs);
+
+  assert.equal(peak, 1);
+  assert.ok(controller.getDiagnostic().pressureSerializations > 0);
+});
+
+test("rejects a queued tool call when heap admission remains critical", async () => {
+  const expected = Object.assign(new Error("critical"), { code: "WORKER_HEAP_PRESSURE" });
+  const controller = new WorkerToolFanoutController({
+    heapCircuitBreaker: {
+      sample: () => ({ heapUsed: 90, heapLimit: 100, percent: 90 }),
+      admit: async () => { throw expected; }
+    }
+  });
+
+  await assert.rejects(controller.run(async () => "unreachable"), expected);
+  assert.equal(controller.getDiagnostic().rejectedAdmissions, 1);
+});