arisa 5.2.7 → 5.2.17

package/src/core/agent/session-preload-migration.js

@@ -0,0 +1,162 @@
+import {
+  closeSync,
+  fsyncSync,
+  openSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import {
+  findMostRecentSessionFile,
+  inspectSessionForPreloadMigration
+} from "./session-history-reader.js";
+import { normalizeSessionRotationPolicy } from "./session-rotation.js";
+
+const contextEntryTypes = new Set([
+  "message",
+  "custom_message",
+  "branch_summary",
+  "thinking_level_change",
+  "model_change"
+]);
+
+function createEntry(type, parentId, fields = {}) {
+  return {
+    type,
+    ...fields,
+    id: randomUUID(),
+    parentId,
+    timestamp: fields.timestamp || new Date().toISOString()
+  };
+}
+
+function appendDurably(filePath, entry) {
+  writeFileSync(filePath, `${JSON.stringify(entry)}\n`, { encoding: "utf8", flag: "a" });
+}
+
+function syncFile(filePath) {
+  const descriptor = openSync(filePath, "r");
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function syncDirectory(directory) {
+  const descriptor = openSync(directory, "r");
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function migratedEntry(source, parentId) {
+  const { id: _id, parentId: _parentId, ...fields } = source;
+  return createEntry(source.type, parentId, fields);
+}
+
+export function createPreloadMigrationChild({
+  sessionDir,
+  cwd,
+  migration,
+  operationalNotes = "",
+  now = new Date()
+}) {
+  const timestamp = now.toISOString();
+  const sessionId = randomUUID();
+  const filenameTimestamp = timestamp.replace(/[:.]/g, "-");
+  const targetFile = path.join(sessionDir, `${filenameTimestamp}_${sessionId}.jsonl`);
+  const temporaryFile = path.join(sessionDir, `.session-migration-${sessionId}.tmp`);
+  const header = {
+    type: "session",
+    version: 3,
+    id: sessionId,
+    timestamp,
+    cwd,
+    parentSession: migration.sourceFile
+  };
+  let parentId = null;
+  let copiedEntries = 0;
+
+  try {
+    writeFileSync(temporaryFile, `${JSON.stringify(header)}\n`, { encoding: "utf8", flag: "wx" });
+    const notes = String(operationalNotes || "").trim();
+    if (notes) {
+      const entry = createEntry("custom_message", parentId, {
+        customType: "arisa-operational-notes",
+        content: notes,
+        display: false,
+        details: { source: "session-start" }
+      });
+      appendDurably(temporaryFile, entry);
+      parentId = entry.id;
+    }
+    const handoff = createEntry("custom_message", parentId, {
+      customType: "arisa-session-handoff",
+      content: [
+        "Automatic session migration before loading. Continue from this checkpoint:",
+        "",
+        migration.summary
+      ].join("\n"),
+      display: false,
+      details: { source: "preload-migration" }
+    });
+    appendDurably(temporaryFile, handoff);
+    parentId = handoff.id;
+
+    for (const sourceEntry of migration.contextEntries) {
+      if (!contextEntryTypes.has(sourceEntry.type)) continue;
+      const entry = migratedEntry(sourceEntry, parentId);
+      appendDurably(temporaryFile, entry);
+      parentId = entry.id;
+      copiedEntries += 1;
+    }
+
+    syncFile(temporaryFile);
+    renameSync(temporaryFile, targetFile);
+    syncDirectory(sessionDir);
+    return {
+      sourceFile: migration.sourceFile,
+      sourceBytes: migration.sourceBytes,
+      targetFile,
+      targetBytes: statSync(targetFile).size,
+      copiedEntries
+    };
+  } catch (error) {
+    try {
+      unlinkSync(temporaryFile);
+    } catch {}
+    throw error;
+  }
+}
+
+export function migrateRecentSessionBeforeLoad({
+  sessionDir,
+  cwd,
+  policy,
+  operationalNotes = ""
+}) {
+  const normalized = normalizeSessionRotationPolicy(policy);
+  if (!normalized.enabled) return null;
+  const sourceFile = findMostRecentSessionFile(sessionDir, cwd);
+  if (!sourceFile) return null;
+  const sourceBytes = statSync(sourceFile).size;
+  if (sourceBytes <= normalized.maxPersistedBytes) return null;
+  const migration = inspectSessionForPreloadMigration(sourceFile, normalized.maxPersistedBytes);
+  if (!migration) {
+    const error = new Error("Oversized Pi session could not be migrated safely before loading");
+    error.code = "PI_SESSION_PRELOAD_MIGRATION_UNAVAILABLE";
+    throw error;
+  }
+  return createPreloadMigrationChild({
+    sessionDir,
+    cwd,
+    migration,
+    operationalNotes
+  });
+}

package/src/core/agent/session-rotation.js

@@ -0,0 +1,29 @@
+const defaultCompactAtPersistedBytes = 24 * 1024 * 1024;
+const defaultMaxPersistedBytes = 32 * 1024 * 1024;
+
+export function normalizeSessionRotationPolicy(policy = {}) {
+  const maxPersistedBytes = Math.max(1, Number(policy?.maxPersistedBytes) || defaultMaxPersistedBytes);
+  return {
+    enabled: policy?.enabled !== false,
+    compactAtPersistedBytes: Math.min(
+      maxPersistedBytes,
+      Math.max(1, Number(policy?.compactAtPersistedBytes) || defaultCompactAtPersistedBytes)
+    ),
+    maxPersistedBytes
+  };
+}
+
+export function compactionRotationRequest(event, persistedBytes, policy = {}) {
+  const normalized = normalizeSessionRotationPolicy(policy);
+  if (!normalized.enabled || event?.type !== "compaction_end" || event.aborted || event.errorMessage) return null;
+  const summary = String(event.result?.summary || "").trim();
+  if (!summary || Math.max(0, Number(persistedBytes) || 0) <= normalized.compactAtPersistedBytes) return null;
+  return {
+    handoff: [
+      "Automatic session rotation after compaction. Continue from this checkpoint:",
+      "",
+      summary
+    ].join("\n"),
+    persistedBytes: Math.max(0, Number(persistedBytes) || 0)
+  };
+}

package/src/core/agent/worker-tool-fanout.js

@@ -0,0 +1,117 @@
+const defaults = Object.freeze({
+  enabled: true,
+  maxConcurrent: 2,
+  pressureConcurrent: 1,
+  serializePercent: 60
+});
+
+function boundedInteger(value, fallback, minimum, maximum) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.min(maximum, Math.max(minimum, Math.floor(number))) : fallback;
+}
+
+function boundedPercent(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.min(99, Math.max(1, number)) : fallback;
+}
+
+export function normalizeToolFanoutConfig(config = {}) {
+  const maxConcurrent = boundedInteger(config.maxConcurrent, defaults.maxConcurrent, 1, 16);
+  return {
+    enabled: config.enabled !== false,
+    maxConcurrent,
+    pressureConcurrent: Math.min(
+      maxConcurrent,
+      boundedInteger(config.pressureConcurrent, defaults.pressureConcurrent, 1, 16)
+    ),
+    serializePercent: boundedPercent(config.serializePercent, defaults.serializePercent)
+  };
+}
+
+export class WorkerToolFanoutController {
+  constructor({ heapCircuitBreaker, logger, config = {} }) {
+    this.heapCircuitBreaker = heapCircuitBreaker;
+    this.logger = logger;
+    this.active = 0;
+    this.queue = [];
+    this.draining = false;
+    this.metrics = {
+      peakActive: 0,
+      peakQueued: 0,
+      pressureSerializations: 0,
+      rejectedAdmissions: 0,
+      completed: 0
+    };
+    this.setConfig(config);
+  }
+
+  setConfig(config = {}) {
+    this.config = normalizeToolFanoutConfig(config);
+    this.drain();
+  }
+
+  capacity() {
+    if (!this.config.enabled) return Number.POSITIVE_INFINITY;
+    const pressure = this.heapCircuitBreaker.sample();
+    if (pressure.percent >= this.config.serializePercent) {
+      this.metrics.pressureSerializations += 1;
+      return this.config.pressureConcurrent;
+    }
+    return this.config.maxConcurrent;
+  }
+
+  async drain() {
+    if (this.draining) return;
+    this.draining = true;
+    try {
+      while (this.queue.length && this.active < this.capacity()) {
+        const job = this.queue.shift();
+        try {
+          await this.heapCircuitBreaker.admit();
+        } catch (error) {
+          this.metrics.rejectedAdmissions += 1;
+          job.reject(error);
+          continue;
+        }
+        this.active += 1;
+        this.metrics.peakActive = Math.max(this.metrics.peakActive, this.active);
+        job.resolve();
+      }
+    } finally {
+      this.draining = false;
+    }
+  }
+
+  acquire() {
+    if (!this.config.enabled) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      this.queue.push({ resolve, reject });
+      this.metrics.peakQueued = Math.max(this.metrics.peakQueued, this.queue.length);
+      this.drain();
+    });
+  }
+
+  release() {
+    if (this.config.enabled) this.active = Math.max(0, this.active - 1);
+    this.metrics.completed += 1;
+    this.drain();
+  }
+
+  async run(work) {
+    await this.acquire();
+    try {
+      return await work();
+    } finally {
+      this.release();
+    }
+  }
+
+  getDiagnostic() {
+    return {
+      ...this.config,
+      active: this.active,
+      queued: this.queue.length,
+      ...this.metrics
+    };
+  }
+}

package/src/core/capabilities/capability-service.js

@@ -71,11 +71,12 @@ export function selectScheduledTasks(tasks = [], { status, limit = defaultSchedu
     maxScheduledTaskListLimit
   );
   const allTasks = Array.isArray(tasks) ? tasks : [];
+  const activeStatuses = new Set(["pending", "running", "blocked_auth"]);
   const orderedTasks = status
     ? [...allTasks].reverse()
     : [
-        ...allTasks.filter((task) => task.status === "pending" || task.status === "running").reverse(),
-        ...allTasks.filter((task) => task.status !== "pending" && task.status !== "running").reverse()
+        ...allTasks.filter((task) => activeStatuses.has(task.status)).reverse(),
+        ...allTasks.filter((task) => !activeStatuses.has(task.status)).reverse()
       ];
   const visibleTasks = orderedTasks.slice(0, resolvedLimit);
   return {

package/src/core/config/config-defaults.js

@@ -72,6 +72,11 @@ export const piConfigDefaults = Object.freeze({
     maxSessions: 3,
     maxPersistedBytes: 48 * 1024 * 1024
   }),
+  sessionRotation: Object.freeze({
+    enabled: true,
+    compactAtPersistedBytes: 24 * 1024 * 1024,
+    maxPersistedBytes: 32 * 1024 * 1024
+  }),
   heapCircuitBreaker: Object.freeze({
     enabled: true,
     softPercent: 70,
@@ -79,6 +84,18 @@ export const piConfigDefaults = Object.freeze({
     waitMs: 15_000,
     pollMs: 500
   }),
+  toolFanout: Object.freeze({
+    enabled: true,
+    maxConcurrent: 2,
+    pressureConcurrent: 1,
+    serializePercent: 60
+  }),
+  turnCoordinator: Object.freeze({
+    enabled: true,
+    backgroundQueueTtlMs: 10 * 60_000,
+    interactiveQueueTtlMs: 0,
+    maxQueued: 100
+  }),
   compaction: Object.freeze({
     enabled: true,
     reserveTokens: 120_000,
@@ -133,10 +150,22 @@ export function applyConfigDefaults(config) {
         ...piConfigDefaults.sessionCache,
         ...(configuredPi.sessionCache || {})
       },
+      sessionRotation: {
+        ...piConfigDefaults.sessionRotation,
+        ...(configuredPi.sessionRotation || {})
+      },
       heapCircuitBreaker: {
         ...piConfigDefaults.heapCircuitBreaker,
         ...(configuredPi.heapCircuitBreaker || {})
       },
+      toolFanout: {
+        ...piConfigDefaults.toolFanout,
+        ...(configuredPi.toolFanout || {})
+      },
+      turnCoordinator: {
+        ...piConfigDefaults.turnCoordinator,
+        ...(configuredPi.turnCoordinator || {})
+      },
       compaction: {
         ...piConfigDefaults.compaction,
         ...(configuredPi.compaction || {})

package/src/core/tasks/task-runner.js

@@ -18,7 +18,8 @@ export function createTaskRunner({ taskStore, dispatch, laneKey = (task) => task
   async function reportTerminalFailure(task, updated, error) {
     const isTerminal = updated?.status === "failed"
       || updated?.status === "outcome_uncertain"
-      || updated?.terminalFailure === true;
+      || updated?.terminalFailure === true
+      || updated?.authBlockedNew === true;
     if (!isTerminal || typeof onTerminalFailure !== "function") return;
     try {
       await onTerminalFailure({ task, result: updated, error });
@@ -37,9 +38,12 @@ export function createTaskRunner({ taskStore, dispatch, laneKey = (task) => task
       logger?.log("tasks", `task ${task.id} completed after confirmed execution`);
       return { taskId: task.id, status: "completed" };
     } catch (error) {
-      const retryOptions = { retryable: error?.retryable !== false };
-      if (error?.outcomeUncertain === true) retryOptions.outcomeUncertain = true;
-      const updated = await taskStore.retryOrFail(task.id, error, retryOptions);
+      const updated = error?.authBlocked === true
+        ? await taskStore.blockAuth(task.id, error, error.authResolution)
+        : await taskStore.retryOrFail(task.id, error, {
+            retryable: error?.retryable !== false,
+            ...(error?.outcomeUncertain === true ? { outcomeUncertain: true } : {})
+          });
       const status = updated?.status || "missing";
       logger?.log("tasks", `task ${task.id} ${status}: ${errorMessage(error)}`);
       await reportTerminalFailure(task, updated, error);

package/src/core/tasks/task-store.js

@@ -170,6 +170,16 @@ function retryDelayMs(task) {
   return Math.max(1, Math.round(seconds * 1000));
 }
 
+function normalizeAuthResolution(resolution = {}) {
+  const value = resolution && typeof resolution === "object" && !Array.isArray(resolution) ? resolution : {};
+  const retryAfterSeconds = Math.max(300, boundedPositiveNumber(value.retryAfterSeconds, 3_600, 86_400));
+  const probeArgs = value.probeArgs && typeof value.probeArgs === "object" && !Array.isArray(value.probeArgs)
+    ? structuredClone(value.probeArgs)
+    : {};
+  if (JSON.stringify(probeArgs).length > 4_096) throw new Error("Authentication probe arguments are too large");
+  return { retryAfterSeconds, probeArgs };
+}
+
 function failTask(task, error) {
   const failedAt = new Date().toISOString();
   task.status = "failed";
@@ -232,7 +242,7 @@ export class TaskStore {
     return this.mutate(async (tasks) => {
       const now = Date.now();
       const due = tasks
-        .filter((task) => task.status === "pending"
+        .filter((task) => ["pending", "blocked_auth"].includes(task.status)
           && task.runAt
           && !Number.isNaN(Date.parse(task.runAt))
           && Date.parse(task.runAt) <= now)
@@ -275,7 +285,7 @@ export class TaskStore {
         if (task.status === "running") {
           const interruptedAt = new Date(now).toISOString();
           if (task.claimedAt && !task.executionStartedAt) {
-            task.status = "pending";
+            task.status = task.authBlock ? "blocked_auth" : "pending";
             task.attempts = Math.max(0, Number(task.attempts || 0) - 1);
             task.lastError = "execution interrupted before start";
             task.lastFailedAt = interruptedAt;
@@ -294,8 +304,11 @@ export class TaskStore {
           delete task.claimedAt;
           delete task.executionStartedAt;
           if (task.kind === "poll_tool") {
-            task.status = "pending";
-            task.runAt = new Date(now + retryDelayMs(task)).toISOString();
+            task.status = task.authBlock ? "blocked_auth" : "pending";
+            const delayMs = task.authBlock
+              ? Number(task.authBlock.retryAfterSeconds || 3_600) * 1_000
+              : retryDelayMs(task);
+            task.runAt = new Date(now + delayMs).toISOString();
             delete task.startedAt;
           } else {
             const nextRunAt = computeNextRunAt(task, now);
@@ -337,6 +350,7 @@ export class TaskStore {
       delete task.error;
       delete task.lastOutcome;
       delete task.consecutiveFailures;
+      delete task.authBlock;
       delete task.claimedAt;
       delete task.executionStartedAt;
       if (nextRunAt) {
@@ -354,6 +368,35 @@ export class TaskStore {
     });
   }
 
+  async blockAuth(taskId, error, resolution = {}) {
+    return this.mutate(async (tasks) => {
+      const task = tasks.find((item) => item.id === taskId);
+      if (!task) return { result: null, changed: false };
+      const now = Date.now();
+      const checkedAt = new Date(now).toISOString();
+      const normalized = normalizeAuthResolution(resolution);
+      const wasBlocked = Boolean(task.authBlock);
+      task.status = "blocked_auth";
+      task.runAt = new Date(now + (normalized.retryAfterSeconds * 1_000)).toISOString();
+      task.attempts = 0;
+      task.authBlock = {
+        firstBlockedAt: task.authBlock?.firstBlockedAt || checkedAt,
+        lastCheckedAt: checkedAt,
+        ...normalized
+      };
+      task.lastError = error instanceof Error ? error.message : String(error);
+      task.lastFailedAt = checkedAt;
+      task.updatedAt = checkedAt;
+      if (task.claimedAt) task.lastClaimedAt = task.claimedAt;
+      if (task.executionStartedAt) task.lastExecutionStartedAt = task.executionStartedAt;
+      delete task.startedAt;
+      delete task.claimedAt;
+      delete task.executionStartedAt;
+      delete task.error;
+      return { result: { ...structuredClone(task), authBlockedNew: !wasBlocked } };
+    });
+  }
+
   async retryOrFail(taskId, error, { retryable = true, outcomeUncertain = false } = {}) {
     return this.mutate(async (tasks) => {
       const task = tasks.find((item) => item.id === taskId);

package/src/core/tools/daemon-processes.js

@@ -280,6 +280,13 @@ export async function unregisterManagedDaemon(toolNameOrOptions, { scope } = {})
   return { toolName: paths.toolName, scope: paths.scope, instanceId: paths.instanceId };
 }
 
+export async function purgeManagedDaemon(toolNameOrOptions, { scope } = {}) {
+  const paths = daemonPaths(toolNameOrOptions, scope);
+  await unregisterManagedDaemon(toolNameOrOptions, { scope });
+  await rm(paths.root, { recursive: true, force: true });
+  return { toolName: paths.toolName, scope: paths.scope, instanceId: paths.instanceId };
+}
+
 export async function stopManagedDaemon(toolNameOrOptions, {
   scope,
   signal = "SIGTERM",

package/src/core/tools/memory-pressure.js

@@ -43,10 +43,10 @@ export async function readMemoryPressure({
   };
 }
 
-export function memoryPressureReason(snapshot, policy) {
+export function memoryPressureReason(snapshot, policy, { ignoreWorkerRss = false } = {}) {
   const mebibyte = 1024 * 1024;
   const workerRssMb = snapshot.workerRssBytes / mebibyte;
-  if (workerRssMb > policy.maxWorkerRssMb) {
+  if (!ignoreWorkerRss && workerRssMb > policy.maxWorkerRssMb) {
     return `worker RSS ${Math.ceil(workerRssMb)} MiB exceeds the ${policy.maxWorkerRssMb} MiB limit`;
   }
   if (snapshot.swapTotalBytes > 0 && snapshot.swapUsedPercent > policy.maxSwapUsedPercent) {

package/src/core/tools/tool-registry.js

@@ -42,6 +42,25 @@ function concurrentExecutionKey(name, chatId, request) {
   return createHash("sha256").update(serialized).digest("hex");
 }
 
+export function readyDaemonAdmission(tool, diagnostic) {
+  const reusable = Boolean(tool?.daemon)
+    && diagnostic?.alive === true
+    && diagnostic?.state === "ready"
+    && diagnostic?.restart?.requested !== true;
+  return reusable ? { ignoreWorkerRss: true } : {};
+}
+
+function declaredDaemonScope(tool, chatId) {
+  if (!tool?.daemon) return null;
+  return tool.daemon.scope === "chat"
+    ? { type: "chat", chatId }
+    : { type: "global" };
+}
+
+function nativeDaemonScope(tool, chatId) {
+  return tool?.daemon?.protocol === "arisa-daemon-v1" ? declaredDaemonScope(tool, chatId) : null;
+}
+
 function executionForLease(execution, lease) {
   if (!execution) return null;
   return {
@@ -399,20 +418,29 @@ export class ToolRegistry {
     let leaseOutcome = {};
     let result;
     try {
-      lease = await this.executionGovernor.acquire(tool.execution, name);
+      const admissionScope = declaredDaemonScope(tool, chatId);
+      let admission = {};
+      if (admissionScope) {
+        const diagnostic = await readDaemonDiagnostic({
+          toolName: name,
+          scope: admissionScope,
+          autoStart: Boolean(tool.daemon.autoStart)
+        }).catch(() => null);
+        admission = readyDaemonAdmission(tool, diagnostic);
+        if (admission.ignoreWorkerRss) this.logger?.log("tools", `reusing ready ${name} daemon without worker RSS spawn admission`);
+      }
+      lease = await this.executionGovernor.acquire(tool.execution, name, admission);
       this.logger?.log("tools", `running ${name}`);
       await mkdir(tmpDir, { recursive: true });
       const skills = await this.resolveSkills(name);
       const enrichedRequest = { ...request, chatId, skills };
-      if (tool.daemon?.protocol === "arisa-daemon-v1") {
-        const scope = tool.daemon.scope === "chat"
-          ? { type: "chat", chatId }
-          : { type: "global" };
+      const runtimeScope = nativeDaemonScope(tool, chatId);
+      if (runtimeScope) {
         const runtime = createDaemonRuntime({
           toolName: name,
           entryPath: tool.entry,
-          scope,
-          startupContext: scope.type === "chat" ? { chatId: String(chatId) } : {},
+          scope: runtimeScope,
+          startupContext: runtimeScope.type === "chat" ? { chatId: String(chatId) } : {},
           autoStart: Boolean(tool.daemon.autoStart)
         });
         result = await runtime.submit(enrichedRequest, { onEvent });

package/src/core/tools/weighted-resource-governor.js

@@ -205,11 +205,11 @@ export class WeightedResourceGovernor {
     request.resolve(this.createLease(request, waitedMs));
   }
 
-  async pressureSnapshot(label, resourceClass) {
+  async pressureSnapshot(label, resourceClass, { ignoreWorkerRss = false } = {}) {
     const pressure = await this.memoryPressure();
     this.lastPressure = pressure;
     this.lastMemoryBudgetMb = this.memoryBudgetMb(pressure);
-    const reason = memoryPressureReason(pressure, this.policy);
+    const reason = memoryPressureReason(pressure, this.policy, { ignoreWorkerRss });
     if (!reason) return pressure;
     const error = new Error(`Tool ${label} was not started because ${reason}`);
     error.code = "TOOL_RESOURCE_PRESSURE";
@@ -234,7 +234,7 @@ export class WeightedResourceGovernor {
           const next = state.queue[0];
           if (!next) continue;
           try {
-            const pressure = await this.pressureSnapshot(next.label, resourceClass);
+            const pressure = await this.pressureSnapshot(next.label, resourceClass, next.admission);
             const budgetMb = this.memoryBudgetMb(pressure);
             next.memoryMb = this.requestedMemoryMb(next.execution, next.label, budgetMb);
             if (next.memoryMb < this.policy.minimumToolMemoryMb || !this.canGrant(next)) continue;
@@ -253,14 +253,14 @@ export class WeightedResourceGovernor {
     }
   }
 
-  async acquire(rawExecution, label = "tool") {
+  async acquire(rawExecution, label = "tool", admission = {}) {
     const execution = normalizeToolExecution(rawExecution);
     if (!execution) return noopLease();
     const resourceClass = execution.resourceClass;
     const capacity = this.capacityFor(resourceClass);
     const weight = Math.min(execution.weight, capacity);
     const state = this.stateFor(resourceClass);
-    const pressure = await this.pressureSnapshot(label, resourceClass);
+    const pressure = await this.pressureSnapshot(label, resourceClass, admission);
     const budgetMb = this.memoryBudgetMb(pressure);
     const memoryMb = this.requestedMemoryMb(execution, label, budgetMb);
     if (budgetMb < this.policy.minimumToolMemoryMb || memoryMb < this.policy.minimumToolMemoryMb) {
@@ -274,7 +274,8 @@ export class WeightedResourceGovernor {
       weight,
       memoryMb,
       label,
-      queuedAt: this.now()
+      queuedAt: this.now(),
+      admission: { ignoreWorkerRss: admission?.ignoreWorkerRss === true }
     };
     if (!state.queue.length && this.canGrant(request)) {
       return new Promise((resolve) => this.grant({ ...request, resolve }));