arisa 5.1.68 → 5.2.7

package/test/memory-pressure.test.js

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { memoryPressureReason, readMemoryPressure } from "../src/core/tools/memory-pressure.js";
+
+test("reads Linux available memory, swap pressure, and worker RSS", async () => {
+  const snapshot = await readMemoryPressure({
+    platform: "linux",
+    readMemInfo: async () => [
+      "MemTotal:        1000000 kB",
+      "MemAvailable:     200000 kB",
+      "SwapTotal:        500000 kB",
+      "SwapFree:         100000 kB"
+    ].join("\n"),
+    freeMemory: () => 1,
+    totalMemory: () => 2,
+    processMemory: () => ({ rss: 123 * 1024 * 1024 })
+  });
+
+  assert.equal(snapshot.availableBytes, 200_000 * 1024);
+  assert.equal(snapshot.swapUsedPercent, 80);
+  assert.equal(snapshot.workerRssBytes, 123 * 1024 * 1024);
+});
+
+test("classifies each configured memory pressure boundary", () => {
+  const policy = { maxWorkerRssMb: 384, maxSwapUsedPercent: 95 };
+  assert.match(memoryPressureReason({
+    workerRssBytes: 400 * 1024 * 1024,
+    swapTotalBytes: 0,
+    swapUsedPercent: 0
+  }, policy), /worker RSS/);
+  assert.match(memoryPressureReason({
+    workerRssBytes: 100 * 1024 * 1024,
+    swapTotalBytes: 100,
+    swapUsedPercent: 96
+  }, policy), /swap use/);
+});

package/test/model-selection.test.js

@@ -302,7 +302,17 @@ test("centralizes Telegram and Pi defaults in config", () => {
   assert.equal(config.telegram.busyMessageMode, "steer");
   assert.equal(config.toolExecution.defaultCapacity, toolExecutionConfigDefaults.defaultCapacity);
   assert.equal(config.toolExecution.maxQueuedPerClass, 100);
-  assert.deepEqual(config.toolExecution.capacities, { orchestrator: 1 });
+  assert.equal(config.toolExecution.maxWorkerRssMb, 384);
+  assert.equal(config.toolExecution.maxSwapUsedPercent, 95);
+  assert.equal(config.toolExecution.initialToolMemoryMb, 384);
+  assert.equal(config.toolExecution.minimumToolMemoryMb, 128);
+  assert.equal(config.toolExecution.maximumToolMemoryMb, 4096);
+  assert.equal(config.toolExecution.systemReserveMb, 128);
+  assert.equal(config.toolExecution.coreReserveMb, 384);
+  assert.equal(config.toolExecution.toolHeapPercent, 65);
+  assert.equal(config.toolExecution.toolMemoryHighPercent, 85);
+  assert.equal(config.toolExecution.toolSwapMaxMb, 128);
+  assert.deepEqual(config.toolExecution.capacities, { browser: 1, orchestrator: 1 });
   assert.equal(config.pi.thinkingLevel, piConfigDefaults.thinkingLevel);
   assert.equal(config.pi.speed, piConfigDefaults.speed);
 });

package/test/official-tool-dependencies.test.js

@@ -12,7 +12,7 @@ test("official orchestrators declare their hard tool dependencies", async () =>
     "pr-campaign": "^0.1.0",
     "gmail-workspace": "^0.1.0"
   });
-  assert.deepEqual((await manifest("x-campaign-runner")).toolDependencies, { "x-dm": "^0.2.0" });
+  assert.deepEqual((await manifest("x-campaign-runner")).toolDependencies, { "x-dm": "^0.4.0" });
   assert.deepEqual((await manifest("x-dm")).toolDependencies, { "browser-session-bridge": "^0.1.0" });
   assert.deepEqual((await manifest("x-session-reader")).toolDependencies, { "browser-session-bridge": "^0.1.0" });
   assert.deepEqual((await manifest("official-tool-sync")).toolDependencies, { trash: "^1.0.0" });

package/test/official-tool-installer.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import crypto from "node:crypto";
-import { cp, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import { cp, mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -60,6 +60,23 @@ test("verifies the exact file set and digests", async (t) => {
   await assert.rejects(() => verifyOfficialToolTree(source, files), /unexpected=extra.js/);
 });
 
+test("every catalog tool is represented in the bundled lock", async () => {
+  const lock = JSON.parse(await readFile(new URL("../src/official-tools.lock.json", import.meta.url), "utf8"));
+  const toolsDir = fileURLToPath(new URL("../../tools/", import.meta.url));
+  const entries = await readdir(toolsDir, { withFileTypes: true });
+  const catalogNames = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    try {
+      await readFile(path.join(toolsDir, entry.name, "tool.manifest.json"), "utf8");
+      catalogNames.push(entry.name);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  assert.deepEqual(Object.keys(lock.tools).sort(), catalogNames.sort());
+});
+
 test("every bundled official tool lock matches the catalog source", async () => {
   const lock = JSON.parse(await readFile(new URL("../src/official-tools.lock.json", import.meta.url), "utf8"));
   for (const [name, entry] of Object.entries(lock.tools)) {

package/test/oom-protection.test.js

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { protectCoreFromOom } from "../src/runtime/oom-protection.js";
+
+test("lowers Linux core OOM priority when permitted", async () => {
+  const writes = [];
+  assert.equal(await protectCoreFromOom({
+    platform: "linux",
+    score: -900,
+    writeScore: async (value) => writes.push(value)
+  }), true);
+  assert.deepEqual(writes, [-900]);
+});
+
+test("keeps running when core OOM priority cannot be changed", async () => {
+  const logs = [];
+  assert.equal(await protectCoreFromOom({
+    platform: "linux",
+    writeScore: async () => { throw Object.assign(new Error("denied"), { code: "EACCES" }); },
+    logger: { log: (...parts) => logs.push(parts.join(" ")) }
+  }), false);
+  assert.match(logs.join("\n"), /could not be lowered: EACCES/);
+});
+
+test("does not touch OOM controls outside Linux", async () => {
+  let called = false;
+  assert.equal(await protectCoreFromOom({
+    platform: "darwin",
+    writeScore: async () => { called = true; }
+  }), false);
+  assert.equal(called, false);
+});

package/test/paths.test.js

@@ -17,9 +17,16 @@ import {
   getToolStateDir,
   stateDir
 } from "../src/runtime/paths.js";
+import * as publicPaths from "../src/runtime/paths.js";
+import * as platformPaths from "../src/platform/paths.js";
 
 const execFileAsync = promisify(execFile);
 
+test("runtime paths remains an exact compatibility facade for platform paths", () => {
+  assert.deepEqual(Object.keys(publicPaths).sort(), Object.keys(platformPaths).sort());
+  for (const name of Object.keys(platformPaths)) assert.equal(publicPaths[name], platformPaths[name]);
+});
+
 test("keeps chat artifact paths scoped below the chat directory", () => {
   const artifactsDir = getChatArtifactsDir("chat-1");
 

package/test/pi-compaction.test.js

@@ -14,6 +14,15 @@ test("provides Pi compaction defaults through Arisa config", () => {
   assert.deepEqual(config.pi.compaction, piConfigDefaults.compaction);
 });
 
+test("merges partial resident session cache overrides with defaults", () => {
+  const config = applyConfigDefaults({ pi: { sessionCache: { maxSessions: 2 } } });
+
+  assert.deepEqual(config.pi.sessionCache, {
+    maxSessions: 2,
+    maxPersistedBytes: 48 * 1024 * 1024
+  });
+});
+
 test("merges partial Pi compaction overrides with defaults", () => {
   const config = applyConfigDefaults({
     pi: { compaction: { reserveTokens: 8_192 } }

package/test/service-manager.test.js

@@ -243,6 +243,7 @@ test("accepts restart handoff from a worker owned by the active supervisor", asy
 test("supervisor restarts an unexpectedly exited worker and forwards shutdown", async () => {
   const children = [];
   const delays = [];
+  const reports = [];
   const spawnProcess = () => {
     const child = new EventEmitter();
     child.pid = 100 + children.length;
@@ -261,13 +262,17 @@ test("supervisor restarts an unexpectedly exited worker and forwards shutdown",
     restartBackoffMaxMs: 20,
     stableRuntimeMs: 60_000,
     spawnProcess,
-    wait: async (ms) => { delays.push(ms); }
+    wait: async (ms) => { delays.push(ms); },
+    onUnexpectedExit: async (report) => { reports.push(report); }
   });
   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]);
+  assert.equal(reports.length, 1);
+  assert.equal(reports[0].code, 1);
+  assert.equal(reports[0].restartDelayMs, 5);
   await supervisor.stop();
   await running;
   assert.equal(children[1].killedWith, "SIGTERM");

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

@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createChatStateStore } from "../src/transport/telegram/chat-queue.js";
+import { createTelegramPromptController } from "../src/transport/telegram/telegram-prompt-controller.js";
+
+function createController(overrides = {}) {
+  const stateStore = createChatStateStore();
+  const calls = { cleared: [], reset: [], steered: [] };
+  const controller = createTelegramPromptController({
+    config: { pi: { chatModels: {} }, telegram: {} },
+    api: {},
+    artifactStore: {},
+    toolRegistry: {},
+    agentManager: {
+      resetSession: (...args) => calls.reset.push(args)
+    },
+    sessionSeeds: {
+      clear: async (chatId) => calls.cleared.push(chatId)
+    },
+    workspaceTopics: {},
+    contextRoute: (ctx) => ctx.route,
+    getChatState: (chatId) => stateStore.get(chatId),
+    createTelegramSessionBridge: () => ({}),
+    createWorkspaceAccessGuard: () => async () => {},
+    sendTextReply: async () => {},
+    authController: { notifyIssueIfNeeded: async () => false },
+    ensureWorkspaceTopicModelSelection: async () => {},
+    ensureQueuedTyping: async () => {},
+    withTyping: async (_ctx, work) => work(),
+    resolveBusyMessageMode: () => "steer",
+    ...overrides
+  });
+  return { controller, stateStore, calls };
+}
+
+test("busy /new resets only the active session and replaces its queued prompt", async () => {
+  const { controller, stateStore, calls } = createController();
+  const route = {
+    workspace: true,
+    sessionId: "topic-87",
+    scopeChatId: "owner",
+    transportChatId: "group",
+    threadId: 87
+  };
+  const state = stateStore.get(route.sessionId);
+  state.processing = true;
+  state.pendingPrompts.push("stale prompt");
+
+  await controller.handleNewCommand({ route, from: { language_code: "es" } });
+
+  assert.deepEqual(calls.cleared, [route.sessionId]);
+  assert.deepEqual(calls.reset, [[route.sessionId]]);
+  assert.equal(state.pendingPrompts.length, 1);
+  assert.match(state.pendingPrompts[0], /System event: \/new requested/);
+  assert.equal(state.continueAfterClose, true);
+});
+
+test("a busy prompt for another topic queues instead of steering the active session", async () => {
+  const { controller, stateStore, calls } = createController();
+  const state = stateStore.get("topic-session");
+  state.processing = true;
+  state.activeRoute = { transportChatId: "group", threadId: 87 };
+  state.activeSession = {
+    isStreaming: true,
+    steer: async (prompt) => calls.steered.push(prompt)
+  };
+  const ctx = {
+    route: { transportChatId: "group", threadId: 114 }
+  };
+
+  await controller.enqueuePrompt({
+    chatId: "topic-session",
+    prompt: "different destination",
+    label: "cross-topic prompt",
+    ctx,
+    busyMessageMode: "steer"
+  });
+
+  assert.deepEqual(calls.steered, []);
+  assert.deepEqual(state.pendingPrompts, ["different destination"]);
+});

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

@@ -110,6 +110,36 @@ test("surfaces Telegram forwarding provenance in the prompt", () => {
   assert.match(prompt, /forwardedAt: 2026-/);
 });
 
+test("surfaces Telegram selected quote text when the replied message has no body", () => {
+  const ctx = createTextContext("update that too");
+  ctx.message.reply_to_message = {
+    message_id: 824,
+    from: { username: "ArisaWaybot" }
+  };
+  ctx.message.quote = { text: "master-slave 0.1.9" };
+
+  const prompt = buildPrompt({ ctx });
+
+  assert.match(prompt, /quotedMessageId: 824/);
+  assert.match(prompt, /quotedSelection: master-slave 0\.1\.9/);
+  assert.doesNotMatch(prompt, /no textual body available/);
+});
+
+test("surfaces quoted Telegram forum topic metadata", () => {
+  const ctx = createTextContext("continue here");
+  ctx.message.reply_to_message = {
+    message_id: 824,
+    from: { username: "ArisaWaybot" },
+    forum_topic_created: { name: "storybot" }
+  };
+
+  const prompt = buildPrompt({ ctx });
+
+  assert.match(prompt, /quotedKind: forum_topic_created/);
+  assert.match(prompt, /quotedTopicName: storybot/);
+  assert.doesNotMatch(prompt, /no textual body available/);
+});
+
 test("formats Telegram reaction changes as lightweight feedback", () => {
   const prompt = buildReactionPrompt({
     reaction: {

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

@@ -8,7 +8,9 @@ const homeDir = await mkdtemp(path.join(os.tmpdir(), "arisa-tool-registry-home-"
 process.env.HOME = homeDir;
 process.env.USERPROFILE = homeDir;
 
-const { ToolRegistry, createToolOutputParser } = await import("../src/core/tools/tool-registry.js");
+const { ToolRegistry, createToolOutputParser, isolatedToolProcessInvocation } = 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 {
   arisaHomeDir,
   arisaPackageDir,
@@ -98,6 +100,33 @@ setInterval(() => {}, 1_000);
   return dir;
 }
 
+test("preserves process helpers through the ToolRegistry compatibility facade", () => {
+  assert.equal(createToolOutputParser, directToolOutputParser);
+  assert.equal(isolatedToolProcessInvocation, directToolProcessInvocation);
+});
+
+test("wraps declared Linux tool processes in a memory-limited cgroup", () => {
+  assert.deepEqual(isolatedToolProcessInvocation(
+    ["--max-old-space-size=192", "/tool/index.js", "run"],
+    { maxMemoryMb: 384 },
+    { platform: "linux", systemdAvailable: true, oomAdjustAvailable: true }
+  ), {
+    command: "systemd-run",
+    args: [
+      "--scope", "--quiet", "--collect", "--slice=arisa-tools.slice",
+      "-p", "MemoryHigh=326M",
+      "-p", "MemoryMax=384M",
+      "-p", "MemorySwapMax=128M",
+      "--", "choom", "-n", "500", "--", "node", "--max-old-space-size=192", "/tool/index.js", "run"
+    ],
+    isolated: true
+  });
+  assert.equal(isolatedToolProcessInvocation(["tool.js"], { maxMemoryMb: 384 }, {
+    platform: "darwin",
+    systemdAvailable: false
+  }).isolated, false);
+});
+
 test("loads and lists installed tools from the user tools directory", async () => {
   await resetHome();
   await createFakeTool("fake-tool", {
@@ -172,7 +201,10 @@ test("loads weighted execution metadata from the tool manifest", async () => {
   assert.deepEqual(registry.get("heavy-tool").execution, {
     resourceClass: "browser",
     weight: 2,
-    deduplicateConcurrent: false
+    deduplicateConcurrent: false,
+    maxHeapMb: 4096,
+    maxMemoryMb: 16_384,
+    maxOutputBytes: 1_048_576
   });
 });
 
@@ -232,7 +264,14 @@ test("wraps declared tool runs in the shared execution governor", async () => {
   assert.deepEqual(calls, [
     {
       type: "acquire",
-      execution: { resourceClass: "browser", weight: 1, deduplicateConcurrent: false },
+      execution: {
+        resourceClass: "browser",
+        weight: 1,
+        deduplicateConcurrent: false,
+        maxHeapMb: 4096,
+        maxMemoryMb: 16_384,
+        maxOutputBytes: 1_048_576
+      },
       label: "heavy-tool"
     },
     { type: "release", label: "heavy-tool" }
@@ -252,7 +291,13 @@ await new Promise((resolve) => setTimeout(resolve, 100));
 process.stdout.write(JSON.stringify({ ok: true, output: { text: request.args.value } }));
 `, "utf8");
   const counterFile = path.join(homeDir, "single-flight-count.txt");
-  const registry = new ToolRegistry({ executionPolicy: { capacities: { orchestrator: 1 } } });
+  const registry = new ToolRegistry({
+    executionPolicy: {
+      capacities: { orchestrator: 1 },
+      maxWorkerRssMb: 4096,
+      maxSwapUsedPercent: 100
+    }
+  });
   await registry.load();
   const invocation = {
     name: "single-flight-tool",
@@ -398,6 +443,57 @@ test("parses fragmented NDJSON incrementally and keeps stderr diagnostic-only",
   assert.doesNotMatch(JSON.stringify(events), /stream diagnostic/);
 });
 
+test("contains an isolated tool heap failure and keeps the registry alive", async () => {
+  await resetHome();
+  const dir = await createFakeTool("heap-bomb-tool", {
+    execution: {
+      resourceClass: "browser",
+      weight: 1,
+      maxHeapMb: 64,
+      maxMemoryMb: 128,
+      maxOutputBytes: 65_536
+    }
+  });
+  await writeFile(path.join(dir, "index.js"), `
+const retained = [];
+while (true) retained.push(new Array(1_000_000).fill("heap-pressure"));
+`, "utf8");
+  await createFakeTool("healthy-after-oom");
+  const registry = new ToolRegistry({
+    runTimeoutMs: 30_000,
+    executionPolicy: { maxWorkerRssMb: 4096, maxSwapUsedPercent: 100 }
+  });
+  await registry.load();
+
+  const failed = await registry.run({ name: "heap-bomb-tool", chatId: "chat-1", request: { args: {} } });
+  assert.equal(failed.ok, false);
+  assert.equal(failed.status, "outcome_uncertain");
+
+  const healthy = await registry.run({ name: "healthy-after-oom", chatId: "chat-1", request: { args: {} } });
+  assert.equal(healthy.ok, true);
+});
+
+test("terminates oversized isolated tool output without taking down the registry", async () => {
+  await resetHome();
+  const dir = await createFakeTool("oversized-tool", {
+    execution: { resourceClass: "browser", weight: 1, maxOutputBytes: 65_536 }
+  });
+  await writeFile(path.join(dir, "index.js"), `process.stdout.write("x".repeat(70_000));`, "utf8");
+  await createFakeTool("healthy-tool");
+  const registry = new ToolRegistry({
+    executionPolicy: { maxWorkerRssMb: 4096, maxSwapUsedPercent: 100 }
+  });
+  await registry.load();
+
+  const oversized = await registry.run({ name: "oversized-tool", chatId: "chat-1", request: { args: {} } });
+  assert.equal(oversized.ok, false);
+  assert.equal(oversized.status, "outcome_uncertain");
+  assert.match(oversized.error, /exceeds 65536 bytes/);
+
+  const healthy = await registry.run({ name: "healthy-tool", chatId: "chat-1", request: { args: {} } });
+  assert.equal(healthy.ok, true);
+});
+
 test("rejects invalid NDJSON sequences and a second terminal event", async () => {
   const invalidSequence = createToolOutputParser("sequence-tool");
   await invalidSequence.push(`${JSON.stringify({ version: 1, jobId: "job", type: "accepted", sequence: 1, payload: {} })}\n`);
@@ -414,6 +510,14 @@ test("rejects invalid NDJSON sequences and a second terminal event", async () =>
   );
 });
 
+test("bounds accumulated legacy output before parsing", async () => {
+  const parser = createToolOutputParser("legacy-tool", { maxOutputBytes: 10 });
+  await assert.rejects(
+    () => parser.push("12345678901"),
+    (error) => error.code === "TOOL_OUTPUT_LIMIT"
+  );
+});
+
 test("preserves pretty-printed single JSON tool responses", async () => {
   const parser = createToolOutputParser("legacy-tool");
   const output = JSON.stringify({ ok: true, output: { text: "legacy" } }, null, 2);

package/test/tui.test.js

@@ -0,0 +1,41 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createTuiCapabilityTools, resolveTuiChatId } from "../src/runtime/tui.js";
+
+test("uses the first authorized owner scope for TUI capabilities", () => {
+  assert.equal(resolveTuiChatId({ telegram: { authorizedChatIds: [879964957, 2] } }), 879964957);
+  assert.throws(() => resolveTuiChatId({ telegram: { authorizedChatIds: [] } }), /authorized chat/);
+});
+
+test("adapts Pi TUI tools to the running Arisa IPC service", async () => {
+  const calls = [];
+  const client = {
+    tools: {
+      list: async (params) => { calls.push(["list", params]); return { tools: [] }; },
+      help: async () => "help",
+      skills: async () => [],
+      setConfig: async () => ({ ok: true }),
+      run: async () => ({ ok: true })
+    },
+    tasks: {
+      list: async () => [],
+      cancel: async () => ({ ok: true }),
+      cancelAll: async () => ({ ok: true })
+    }
+  };
+  const tools = createTuiCapabilityTools(client);
+  assert.deepEqual(tools.map((tool) => tool.name), [
+    "list_tools",
+    "tool_help",
+    "tool_skills",
+    "set_tool_config",
+    "run_tool",
+    "list_scheduled_tasks",
+    "cancel_scheduled_task",
+    "cancel_all_scheduled_tasks"
+  ]);
+
+  const result = await tools[0].execute("call", { query: "email" });
+  assert.deepEqual(calls, [["list", { query: "email" }]]);
+  assert.match(result.content[0].text, /"tools"/);
+});

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

@@ -12,11 +12,24 @@ function deferred() {
   return { promise, resolve };
 }
 
+const safeMemoryPressure = async () => ({
+  availableBytes: 512 * 1024 * 1024,
+  totalBytes: 4 * 1024 * 1024 * 1024,
+  workerRssBytes: 100 * 1024 * 1024,
+  swapTotalBytes: 1024,
+  swapUsedPercent: 50
+});
+
+const settle = () => new Promise((resolve) => setImmediate(resolve));
+
 test("normalizes manifest weights and configurable class capacities", () => {
   assert.deepEqual(normalizeToolExecution({ resourceClass: "browser", weight: 2 }), {
     resourceClass: "browser",
     weight: 2,
-    deduplicateConcurrent: false
+    deduplicateConcurrent: false,
+    maxHeapMb: 4096,
+    maxMemoryMb: 16_384,
+    maxOutputBytes: 1_048_576
   });
   assert.equal(normalizeToolExecution({
     resourceClass: "orchestrator",
@@ -33,6 +46,16 @@ test("normalizes manifest weights and configurable class capacities", () => {
   }), {
     defaultCapacity: 3,
     maxQueuedPerClass: 12,
+    maxWorkerRssMb: 384,
+    maxSwapUsedPercent: 95,
+    initialToolMemoryMb: 384,
+    minimumToolMemoryMb: 128,
+    maximumToolMemoryMb: 4096,
+    systemReserveMb: 128,
+    coreReserveMb: 384,
+    toolHeapPercent: 65,
+    toolMemoryHighPercent: 85,
+    toolSwapMaxMb: 128,
     capacities: { browser: 4 }
   });
 });
@@ -42,13 +65,15 @@ test("queues weighted work fairly within one resource class", async () => {
   const governor = new WeightedResourceGovernor({
     policy: { defaultCapacity: 2 },
     now: () => time,
-    memoryUsage: () => ({ rss: 100 * 1024 * 1024 })
+    memoryUsage: () => ({ rss: 100 * 1024 * 1024 }),
+    memoryPressure: safeMemoryPressure
   });
   const execution = { resourceClass: "browser", weight: 1 };
   const first = await governor.acquire(execution, "first");
   const second = await governor.acquire(execution, "second");
   const thirdLease = governor.acquire(execution, "third");
   const fourthLease = governor.acquire(execution, "fourth");
+  await settle();
 
   assert.deepEqual(governor.snapshot().resources.browser, {
     capacity: 2,
@@ -72,26 +97,52 @@ test("queues weighted work fairly within one resource class", async () => {
   assert.equal(governor.snapshot().resources.browser.activeWeight, 0);
 });
 
-test("undeclared lightweight work bypasses constrained resource queues", async () => {
-  const governor = new WeightedResourceGovernor({ policy: { defaultCapacity: 1 } });
+test("undeclared work bypasses the optional resource governor", async () => {
+  const governor = new WeightedResourceGovernor({ policy: { defaultCapacity: 1 }, memoryPressure: safeMemoryPressure });
   const heavy = await governor.acquire({ resourceClass: "browser", weight: 1 }, "heavy");
   const queued = governor.acquire({ resourceClass: "browser", weight: 1 }, "queued");
+  await settle();
   const light = await governor.acquire(null, "light");
   assert.equal(light.waitedMs, 0);
+  assert.equal(light.memoryLimitMb, undefined);
+  assert.equal(light.heapLimitMb, undefined);
   assert.equal(governor.snapshot().resources.browser.queued, 1);
   light.release();
   heavy.release();
   (await queued).release();
 });
 
+test("rejects declared heavy tools before spawn when memory pressure is unsafe", async () => {
+  const logs = [];
+  const governor = new WeightedResourceGovernor({
+    policy: { maxWorkerRssMb: 384, maxSwapUsedPercent: 95 },
+    memoryPressure: async () => ({
+      availableBytes: 80 * 1024 * 1024,
+      workerRssBytes: 400 * 1024 * 1024,
+      swapTotalBytes: 1024,
+      swapUsedPercent: 50
+    }),
+    logger: { log: (...parts) => logs.push(parts.join(" ")) }
+  });
+
+  await assert.rejects(
+    () => governor.acquire({ resourceClass: "browser", weight: 1 }, "web-browser"),
+    (error) => error.code === "TOOL_RESOURCE_PRESSURE" && /was not started/.test(error.message)
+  );
+  assert.match(logs.join("\n"), /web-browser rejected for browser/);
+  assert.equal(governor.snapshot().resources.browser.activeWeight, 0);
+});
+
 test("larger weights consume shared capacity and worker RSS peaks are retained", async () => {
   let rss = 120 * 1024 * 1024;
   const governor = new WeightedResourceGovernor({
     policy: { defaultCapacity: 3 },
-    memoryUsage: () => ({ rss })
+    memoryUsage: () => ({ rss }),
+    memoryPressure: safeMemoryPressure
   });
   const large = await governor.acquire({ resourceClass: "browser", weight: 2 }, "large");
   const waiting = governor.acquire({ resourceClass: "browser", weight: 2 }, "waiting");
+  await settle();
   assert.equal(governor.snapshot().resources.browser.queued, 1);
   rss = 180 * 1024 * 1024;
   large.release();
@@ -99,3 +150,44 @@ test("larger weights consume shared capacity and worker RSS peaks are retained",
   assert.equal(governor.snapshot().peakRssBytes, rss);
   next.release();
 });
+
+test("shares one host memory budget across independent resource classes", async () => {
+  const pressure = async () => ({
+    availableBytes: 512 * 1024 * 1024,
+    totalBytes: 1024 * 1024 * 1024,
+    workerRssBytes: 100 * 1024 * 1024,
+    swapTotalBytes: 0,
+    swapUsedPercent: 0
+  });
+  const governor = new WeightedResourceGovernor({
+    policy: { systemReserveMb: 128, coreReserveMb: 384, initialToolMemoryMb: 384 },
+    memoryPressure: pressure
+  });
+  const browser = await governor.acquire({ resourceClass: "browser" }, "browser");
+  const queued = governor.acquire({ resourceClass: "orchestrator" }, "orchestrator");
+  await settle();
+
+  assert.equal(governor.snapshot().memory.budgetMb, 512);
+  assert.equal(governor.snapshot().memory.activeMb, 384);
+  assert.equal(governor.snapshot().resources.orchestrator.queued, 1);
+
+  browser.release({ success: true });
+  const orchestrator = await queued;
+  assert.equal(orchestrator.memoryLimitMb, 384);
+  orchestrator.release({ success: true });
+});
+
+test("raises a tool memory recommendation after an isolated limit failure", async () => {
+  const governor = new WeightedResourceGovernor({
+    policy: { initialToolMemoryMb: 256 },
+    memoryPressure: safeMemoryPressure
+  });
+  const first = await governor.acquire({}, "growing-tool");
+  assert.equal(first.memoryLimitMb, 256);
+  first.release({ memoryLimited: true });
+
+  const second = await governor.acquire({}, "growing-tool");
+  assert.equal(second.memoryLimitMb, 384);
+  assert.equal(governor.snapshot().memory.profiles["growing-tool"].memoryLimitFailures, 1);
+  second.release({ success: true });
+});