machine-bridge-mcp 2.0.0 → 3.0.0-beta.102

package/src/local/resource-cmake-concurrency.mjs

@@ -0,0 +1,42 @@
+const CMAKE_INT_MAX = 2_147_483_647;
+
+export function cmakeBuildJobPlan(argv, environment = {}, maximum = 1024) {
+  const buildIndex = (argv || []).findIndex((value, index) => index > 0 && String(value) === "--build");
+  if (buildIndex < 0) return null;
+  const args = argv.slice(buildIndex + 1); const separator = args.indexOf("--");
+  const cmakeArgs = separator < 0 ? args : args.slice(0, separator);
+  if (hasPreset(cmakeArgs) || separator >= 0 && separator < args.length - 1) return unboundedPlan(true);
+  return directPlan(cmakeArgs, maximum) || environmentPlan(environment, maximum);
+}
+
+function directPlan(args, maximum) {
+  let plan = null;
+  for (let index = 0; index < args.length; index += 1) {
+    const value = String(args[index] || ""); const flag = value.startsWith("--parallel") ? "--parallel" : value.startsWith("-j") ? "-j" : null;
+    if (!flag) continue;
+    if (value === flag) {
+      const next = args[index + 1];
+      if (next === undefined || cmakeIsFlag(next)) plan = unboundedPlan(false);
+      else { plan = numericPlan(next, maximum, false); index += 1; }
+    } else {
+      let suffix = value.slice(flag.length); if (suffix.startsWith("=")) suffix = suffix.slice(1);
+      plan = suffix ? numericPlan(suffix, maximum, false) : invalidPlan(false);
+    }
+    if (plan.invalid) return plan;
+  }
+  return plan;
+}
+function environmentPlan(environment, maximum) {
+  if (!Object.prototype.hasOwnProperty.call(environment || {}, "CMAKE_BUILD_PARALLEL_LEVEL")) return null;
+  const value = String(environment.CMAKE_BUILD_PARALLEL_LEVEL ?? "");
+  return value === "" ? unboundedPlan(true) : numericPlan(value, maximum, true);
+}
+function numericPlan(value, maximum, preserve) {
+  const text = String(value); if (!/^\+?\d+$/.test(text)) return invalidPlan(preserve);
+  const parsed = Number(text); if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > CMAKE_INT_MAX) return invalidPlan(preserve);
+  return parsed <= maximum ? { jobs: parsed, elastic: false, unbounded: false, preserve } : unboundedPlan(preserve);
+}
+function cmakeIsFlag(value) { const text = String(value || ""); return text.startsWith("-") && !/^-\d/.test(text); }
+function hasPreset(args) { return args.some((value) => String(value) === "--preset" || String(value).startsWith("--preset=")); }
+function invalidPlan(preserve) { return { jobs: null, elastic: false, unbounded: false, preserve, invalid: true }; }
+function unboundedPlan(preserve) { return { jobs: null, elastic: false, unbounded: true, preserve }; }

package/src/local/resource-command-concurrency.mjs

@@ -0,0 +1,37 @@
+import { availableParallelism } from "node:os";
+import { cargoExplicitJobPlan } from "./resource-cargo-concurrency.mjs";
+import { cmakeBuildJobPlan } from "./resource-cmake-concurrency.mjs";
+import { goJobPlan } from "./resource-go-concurrency.mjs";
+import { gradleJobPlan } from "./resource-gradle-concurrency.mjs";
+import { makeCommandJobPlan, makeFlagsJobPlan } from "./resource-make-concurrency.mjs";
+import { mavenJobPlan } from "./resource-maven-concurrency.mjs";
+import { ninjaCommandJobPlan } from "./resource-ninja-command-concurrency.mjs";
+import { ninjaJobserverPlan } from "./resource-ninja-concurrency.mjs";
+export const DEFAULT_COMPILER_JOBS = 3;
+export function cargoJobPlan(argv, environment = {}) { return cargoExplicitJobPlan(argv, environment) || { jobs: DEFAULT_COMPILER_JOBS, elastic: true, unbounded: false }; }
+export function genericBuildJobPlan(base, argv, _text, options = {}) {
+  if (!["make", "ninja", "cmake", "gradle", "gradlew", "mvn", "mvnw", "go"].includes(base)) return null;
+  const fallback = { jobs: DEFAULT_COMPILER_JOBS, elastic: true, unbounded: false };
+  if (base === "make") return makeCommandJobPlan(argv) || makeFlagsJobPlan(options.environment) || fallback;
+  if (base === "go") return goJobPlan(argv, options.environment) || { jobs: DEFAULT_COMPILER_JOBS, elastic: true, unbounded: false };
+  if (base === "cmake") return cmakeBuildJobPlan(argv, options.environment) || { jobs: DEFAULT_COMPILER_JOBS, elastic: true, unbounded: false };
+  if (base === "ninja") return ninjaCommandJobPlan(argv) || ninjaJobserverPlan(argv, options.environment) || { jobs: DEFAULT_COMPILER_JOBS, elastic: true, unbounded: false };
+  if (["gradle", "gradlew"].includes(base)) return gradleJobPlan(argv, options.environment) || fallback;
+  return mavenJobPlan(argv, options.environment) || fallback;
+}
+
+export function verificationFanoutPlan(environment = {}) {
+  const value = environment?.MBM_CHECK_CONCURRENCY;
+  if (hasConfiguredValue(value)) {
+    const configured = configuredJobs(value, 16);
+    return configured === null ? unboundedPlan() : { jobs: configured, elastic: false, unbounded: false };
+  }
+  return { jobs: Math.max(1, Math.min(4, availableParallelism())), elastic: true, unbounded: false };
+}
+function configuredJobs(value, maximum) {
+  if (!hasConfiguredValue(value)) return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 1 && parsed <= maximum ? parsed : null;
+}
+function hasConfiguredValue(value) { return value !== undefined && value !== null && value !== ""; }
+function unboundedPlan() { return { jobs: null, elastic: false, unbounded: true }; }

package/src/local/resource-command-profile.mjs

@@ -0,0 +1,176 @@
+import { homedir } from "node:os";
+import { basename, isAbsolute, resolve } from "node:path";
+import { cargoJobPlan, DEFAULT_COMPILER_JOBS, genericBuildJobPlan, verificationFanoutPlan } from "./resource-command-concurrency.mjs";
+import { markElasticCompilerJobs, markPreservedCompilerJobs } from "./resource-elastic-request.mjs";
+import { pytestWorkerPlan } from "./resource-pytest-concurrency.mjs";
+import { swiftJobPlan } from "./resource-swift-concurrency.mjs";
+import { xcodeResourcePlan } from "./resource-xcode-concurrency.mjs";
+import { xcodeIsLightCommand } from "./resource-xcode-command.mjs";
+import { xcodeNonBuildResourcePlan } from "./resource-xcode-non-build.mjs";
+import { isTrustedLightExecutable } from "./resource-light-command.mjs";
+import { releaseControlCommandIsLight } from "./resource-release-control-classification.mjs";
+import { commandHeadIn, commandHeadIs, commandTokens, heavyShellScript, pythonModuleHeadIs, pythonModuleTokens, shellPayload, shellSegments } from "./resource-shell-analysis.mjs";
+import { directInterpreterHeavyScript, packageManagerTokensHeavy, verificationPlanCommand } from "./resource-script-classification.mjs";
+const GIB = 1024 ** 3;
+export function resourceCommandProfile(command, args = [], options = {}) {
+  const rawCommand = String(command || "");
+  const argv = [rawCommand, ...args.map(String)];
+  const base = basename(argv[0]).toLowerCase();
+  const shellText = shellPayload(base, argv.slice(1));
+  const shellTokens = shellText ? shellSegments(shellText).map(commandTokens) : [];
+  const text = shellText || argv.join(" ");
+  const priority = normalizePriority(options.priority);
+
+  if (isTrustedDiskReclaimExecutable(rawCommand)) return profile("disk-reclaim", "io", 0.25, 0.75, 256, 0, priority);
+  if (isTrustedLightExecutable(rawCommand)) return lightProfile(priority);
+  if (base === "xcodebuild" && xcodeIsLightCommand(argv.slice(1))) return lightProfile(priority);
+  if (base === "xcodebuild") { const plan = xcodeNonBuildResourcePlan(argv.slice(1));
+    if (plan) return profile(plan.family, plan.resourceClass, plan.cpu, plan.io, plan.memoryMb, plan.diskBytes, priority, { unbounded: plan.unbounded, serializeProject: plan.serializeProject }); }
+  const buildProfile = compilerBuildProfile(base, argv, text, shellTokens, priority, options.environment);
+  if (buildProfile) return buildProfile;
+  return remainingCommandProfile(base, argv, text, shellTokens, priority, options.environment, options.releaseControlWorkspace === true);
+}
+function remainingCommandProfile(base, argv, text, shellTokens, priority, environment, releaseControlWorkspace) {
+  if (releaseControlWorkspace && releaseControlCommandIsLight(base, argv.slice(1))) return profile("release-control", "light", 0, 0, 0, 0, priority);
+  if (/^pytest(?:-\d+(?:\.\d+)*)?$/.test(base) || commandHeadIs(text, base, "pytest") || pythonModuleHeadIs(text, base, "pytest")) {
+    const plan = pytestWorkerPlan(argv, text);
+    return profile("pytest", plan.unbounded ? "unbounded" : "cpu", plan.unbounded ? 6 : plan.jobs, 0.12,
+      plan.unbounded ? 3072 : Math.max(768, plan.jobs * 768), 1 * GIB, priority, { unbounded: plan.unbounded });
+  }
+  if (verificationPlanCommand(base, argv.slice(1))
+      || shellTokens.some((tokens) => verificationPlanCommand(tokens[0] || "", tokens.slice(1)))) {
+    const plan = verificationFanoutPlan(environment);
+    return profile("verification-plan", plan.unbounded ? "unbounded" : "mixed", plan.unbounded ? 6 : plan.jobs, 0.6,
+      plan.unbounded ? 4096 : Math.max(2048, plan.jobs * 1024), 3 * GIB, priority, {
+        compilerJobs: plan.jobs, elasticCompilerJobs: plan.elastic, elasticMemoryFloorMb: 2048,
+        unbounded: plan.unbounded, serializeProject: true,
+      });
+  }
+  if (directInterpreterHeavyScript(base, argv.slice(1))
+      || shellTokens.some((tokens) => directInterpreterHeavyScript(tokens[0] || "", tokens.slice(1)))) {
+    return profile("script-heavy", "mixed", 2.5, 0.5, 2048, 3 * GIB, priority, { serializeProject: true });
+  }
+  if (commandHeadIn(text, base, ["rustc", "swiftc", "swift-frontend", "clang++", "clang", "gcc", "g++"])) {
+    return profile("compiler", "cpu", 1, 0.2, 1536, 1 * GIB, priority);
+  }
+  const packageScriptHeavy = packageManagerTokensHeavy([base, ...argv.slice(1)])
+    || shellTokens.some((tokens) => packageManagerTokensHeavy(tokens));
+  if (packageScriptHeavy) {
+    return profile("js-build", "mixed", 2, 0.5, 2048, 3 * GIB, priority, { serializeProject: true });
+  }
+  if (commandHeadIs(text, base, "git") && /(?:^|\s)(?:add|checkout|clone|gc|repack|reset)(?:\s|$)/i.test(text)) {
+    return profile("git-write", "io", 1, 0.8, 768, 3 * GIB, priority, { serializeProject: true });
+  }
+  if (commandHeadIn(text, base, ["rsync", "ditto", "tar", "zip", "unzip"])) {
+    return profile("bulk-io", "io", 1, 0.9, 768, 6 * GIB, priority);
+  }
+  if (["sh", "bash", "zsh"].includes(base) && heavyShellScript(argv.slice(1), text)) {
+    return profile("script-heavy", "mixed", 2.5, 0.5, 2048, 3 * GIB, priority, { serializeProject: true });
+  }
+  return profile("generic-process", "adaptive", 0.5, 0.1, 512, 0, priority);
+}
+
+export function resourceCommandEffectiveCwd(command, args, cwd, request = null) {
+  const baseCwd = resolve(cwd || process.cwd());
+  const base = basename(String(command || "")).toLowerCase();
+  const payload = shellPayload(base, args.map(String));
+  if (!payload || !request?.family) return baseCwd;
+  const expected = familyCommands(request.family);
+  let current = baseCwd;
+  let cwdCertain = true;
+  let resolvedCd = false;
+  for (const segment of shellSegments(payload)) {
+    const tokens = commandTokens(segment);
+    if (!tokens.length) continue;
+    if (tokens[0] === "cd") {
+      const raw = String(tokens[1] || "");
+      const canReanchor = isAbsolute(raw) || raw === "~" || raw.startsWith("~/");
+      const next = cwdCertain || canReanchor ? simpleCdPath(raw, current) : null;
+      if (next) { current = next; cwdCertain = true; resolvedCd = true; }
+      else cwdCertain = false;
+      continue;
+    }
+    if (expected.includes(tokens[0]) || request.family === "pytest" && pythonModuleTokens(tokens, "pytest")) {
+      return cwdCertain ? current : baseCwd;
+    }
+  }
+  return request.serialize_project === true && resolvedCd && cwdCertain ? current : baseCwd;
+}
+
+export function applyResourceProfileEnv(environment, request) {
+  const env = { ...environment };
+  if (request?.family === "cargo" && request.compiler_jobs && !env.CARGO_BUILD_JOBS) {
+    env.CARGO_BUILD_JOBS = String(request.compiler_jobs);
+  }
+  if (request?.family === "verification-plan" && request.compiler_jobs && !env.MBM_CHECK_CONCURRENCY) {
+    env.MBM_CHECK_CONCURRENCY = String(request.compiler_jobs);
+  }
+  return env;
+}
+
+function profile(family, resourceClass, cpu, io, memoryMb, diskBytes, priority, extra = {}) {
+  return markPreservedCompilerJobs(markElasticCompilerJobs({
+    family,
+    resource_class: resourceClass,
+    priority,
+    cpu: Math.max(0, Number(cpu) || 0),
+    io: Math.max(0, Number(io) || 0),
+    memory_mb: Math.max(0, Number(memoryMb) || 0),
+    disk_reserve_bytes: Math.max(0, Number(diskBytes) || 0),
+    heavy: resourceClass !== "light",
+    compiler_jobs: extra.compilerJobs ?? null,
+    unbounded: extra.unbounded === true,
+    serialize_project: extra.serializeProject === true,
+  }, extra.elasticCompilerJobs === true, extra.elasticMemoryFloorMb), extra.preserveCompilerJobs === true);
+}
+function compilerBuildProfile(base, argv, text, shellTokens, priority, environment) {
+  if (commandHeadIs(text, base, "cargo")) {
+    const plan = cargoJobPlan(argv, environment);
+    return profile("cargo", plan.unbounded ? "unbounded" : "mixed", plan.unbounded ? 6 : plan.jobs, 0.55, 3072, 4 * GIB, priority, {
+      compilerJobs: plan.jobs, elasticCompilerJobs: plan.elastic, preserveCompilerJobs: plan.preserve === true,
+      unbounded: plan.unbounded, serializeProject: true,
+    });
+  }
+  if (commandHeadIs(text, base, "swift") && /(?:^|\s)(?:build|test|package)(?:\s|$)/i.test(text)) { const direct = base === "swift";
+    const shellSwift = !direct && shellTokens.length === 1 && basename(String(shellTokens[0]?.[0] || "")).toLowerCase() === "swift" ? shellTokens[0] : null;
+    const explicit = swiftJobPlan(direct ? argv : shellSwift); if (direct && explicit?.invalid) return profile("build-validation", "light", 0, 0, 0, 0, priority);
+    const plan = explicit || (direct ? { jobs: DEFAULT_COMPILER_JOBS, elastic: true, unbounded: false } : { jobs: null, elastic: false, unbounded: true }); const controllable = !plan.invalid && !plan.unbounded;
+    return profile("swift", controllable ? "mixed" : "unbounded", controllable ? plan.jobs : 6, 0.55, 3072, 4 * GIB, priority, { compilerJobs: controllable ? plan.jobs : null, elasticCompilerJobs: direct && plan.elastic, unbounded: !controllable, serializeProject: true });
+  }
+  if (commandHeadIs(text, base, "xcodebuild")) {
+    const plan = xcodeResourcePlan(base, argv, DEFAULT_COMPILER_JOBS); if (plan?.invalid) return profile("build-validation", "light", 0, 0, 0, 0, priority);
+    return profile("xcodebuild", plan.resourceClass, plan.cpu, 0.75, 4096, 8 * GIB, priority, { compilerJobs: plan.compilerJobs, elasticCompilerJobs: plan.elastic, unbounded: plan.unbounded, serializeProject: true });
+  }
+  const generic = commandHeadIn(text, base, ["make", "ninja", "gradle", "gradlew"])
+    || commandHeadIs(text, base, "cmake") && /(?:^|\s)--build(?:\s|$)/.test(text)
+    || commandHeadIn(text, base, ["mvn", "mvnw"]) && /(?:^|\s)(?:test|package|install)(?:\s|$)/.test(text)
+    || commandHeadIs(text, base, "go") && /(?:^|\s)(?:test|build)(?:\s|$)/.test(text);
+  if (!generic) return null;
+  const plan = genericBuildJobPlan(base, argv, text, { environment });
+  if (plan?.invalid) return profile("build-validation", "light", 0, 0, 0, 0, priority);
+  const controllable = Boolean(plan && !plan.unbounded);
+  return profile("generic-build", controllable ? "mixed" : "unbounded", controllable ? plan.jobs : 6, 0.65, 3072, 5 * GIB, priority, {
+    compilerJobs: controllable ? plan.jobs : null, elasticCompilerJobs: controllable && plan.elastic,
+    preserveCompilerJobs: plan?.preserve === true, unbounded: !controllable, serializeProject: true,
+  });
+}
+function lightProfile(priority) { return profile("light", "light", 0, 0, 0, 0, priority); }
+function normalizePriority(value) { return ["interactive", "ordinary", "background"].includes(value) ? value : "ordinary"; }
+function isTrustedDiskReclaimExecutable(command) {
+  return ["/bin/rm", "/usr/bin/rm", "/bin/rmdir", "/usr/bin/rmdir", "/usr/bin/unlink"].includes(command);
+}
+function familyCommands(family) {
+  if (family === "verification-plan") return ["npm", "pnpm", "yarn", "bun", "node"];
+  if (family === "js-build") return ["npm", "pnpm", "yarn", "bun"];
+  if (family === "generic-build") return ["make", "ninja", "cmake", "gradle", "gradlew", "mvn", "mvnw", "go"];
+  if (family === "bulk-io") return ["rsync", "ditto", "tar", "zip", "unzip"];
+  if (family === "compiler") return ["rustc", "swiftc", "swift-frontend", "clang++", "clang", "gcc", "g++"];
+  return [family];
+}
+function simpleCdPath(value, cwd) {
+  const raw = String(value || "");
+  if (!raw || raw === "-" || /[$`'"*?{}[\]]/.test(raw)) return null;
+  if (raw === "~") return homedir();
+  if (raw.startsWith("~/")) return resolve(homedir(), raw.slice(2));
+  return isAbsolute(raw) ? resolve(raw) : resolve(cwd, raw);
+}

package/src/local/resource-coordinator-accounting.mjs

@@ -0,0 +1,21 @@
+import { aggregateResourceLeases, resourceLeaseAccountingContext } from "./resource-lease-accounting.mjs";
+
+export function resourceCoordinatorEvaluator(evaluate, processParents, fallbackPid) {
+  return (host, leases, request, now, candidate = null) => evaluate(host, leases, request, now, {
+    accounting: resourceLeaseAccountingContext(
+      leases, processParents, candidate?.owner?.pid || fallbackPid,
+    ),
+  });
+}
+
+export function resourceCoordinatorAccounting(leases, processParents, requesterPid = 0) {
+  const accounting = resourceLeaseAccountingContext(leases, processParents, requesterPid);
+  const used = aggregateResourceLeases(leases, accounting);
+  return {
+    accounting,
+    resources: {
+      cpu: used.cpu, io: used.io, memory_mb: used.memory_mb,
+      disk_reserve_bytes: used.disk_reserve_bytes,
+    },
+  };
+}

package/src/local/resource-cpu-window.mjs

@@ -0,0 +1,20 @@
+import { aggregateResourceLeases } from "./resource-lease-accounting.mjs";
+
+export function unobservedResourceCpu(leases, accounting = {}, sampledAtMs = 0) {
+  const sampledAt = Number(sampledAtMs);
+  if (!Number.isFinite(sampledAt) || sampledAt <= 0) return 0;
+  const all = aggregateResourceLeases(leases, accounting);
+  const observed = aggregateResourceLeases(
+    (leases || []).filter((lease) => leaseObservedBySample(lease, sampledAt)),
+    accounting,
+  );
+  return Math.max(0, all.cpu - observed.cpu);
+}
+
+function leaseObservedBySample(lease, sampledAtMs) {
+  const boundAt = Date.parse(String(lease?.bound_at || ""));
+  if (Number.isFinite(boundAt)) return boundAt <= sampledAtMs;
+  if (lease?.owner?.kind !== "process") return false;
+  const acquiredAt = Date.parse(String(lease?.acquired_at || ""));
+  return Number.isFinite(acquiredAt) && acquiredAt <= sampledAtMs;
+}

package/src/local/resource-disk-headroom.mjs

@@ -0,0 +1,13 @@
+const GIB = 1024 ** 3;
+
+export function resourceDiskHardFloorBytes(totalBytes) {
+  const total = Number(totalBytes);
+  if (!Number.isFinite(total) || total <= 0) return 0;
+  return Math.min(50 * GIB, Math.max(5 * GIB, total * 0.10));
+}
+
+export function resourceDiskSoftFloorBytes(totalBytes) {
+  const total = Number(totalBytes);
+  if (!Number.isFinite(total) || total <= 0) return 0;
+  return Math.min(80 * GIB, Math.max(8 * GIB, total * 0.15));
+}

package/src/local/resource-elastic-memory.mjs

@@ -0,0 +1,19 @@
+export function elasticMemoryJobLimit(request, pressure, maximumJobs, floorValue) {
+  if (floorValue === null || floorValue === undefined || floorValue === "") return maximumJobs;
+  const floor = Number(floorValue); const limit = Number(pressure?.limits?.memory_mb);
+  const overcommit = Number(pressure?.limits?.memory_overcommit); const used = Number(pressure?.used?.memory_mb);
+  if (![floor, limit, overcommit, used].every(Number.isFinite)) return maximumJobs;
+  const incremental = Number(pressure?.requested?.memory_mb);
+  const covered = Number.isFinite(incremental) ? Math.max(0, Number(request.memory_mb) - incremental) : 0;
+  const available = Math.max(0, limit * overcommit + 1 - Math.max(0, used) + covered);
+  for (let jobs = maximumJobs; jobs >= 1; jobs -= 1) {
+    if (elasticMemoryMb(request, jobs, floor) <= available) return jobs;
+  }
+  return 1;
+}
+
+export function elasticMemoryMb(request, jobs, floorValue) {
+  const floor = Number(floorValue);
+  if (!Number.isFinite(floor)) return request.memory_mb;
+  return Math.min(request.memory_mb, Math.max(floor, Math.ceil(request.memory_mb * jobs / request.compiler_jobs)));
+}

package/src/local/resource-elastic-request.mjs

@@ -0,0 +1,36 @@
+import { elasticMemoryJobLimit, elasticMemoryMb } from "./resource-elastic-memory.mjs";
+
+const ELASTIC_COMPILER_JOBS = Symbol("resource.elasticCompilerJobs");
+const PRESERVE_COMPILER_JOBS = Symbol("resource.preserveCompilerJobs");
+
+export function markPreservedCompilerJobs(request, enabled = true) {
+  if (enabled) request[PRESERVE_COMPILER_JOBS] = true;
+  return request;
+}
+export function preservesCompilerJobs(request) { return request?.[PRESERVE_COMPILER_JOBS] === true; }
+export function markElasticCompilerJobs(request, enabled = true, memoryFloorMb = null) {
+  if (enabled && Number.isInteger(request?.compiler_jobs) && request.compiler_jobs > 1) {
+    request[ELASTIC_COMPILER_JOBS] = memoryFloorMb !== null && memoryFloorMb !== undefined && memoryFloorMb !== "" && Number.isFinite(Number(memoryFloorMb))
+      ? { memory_floor_mb: Math.max(0, Number(memoryFloorMb)) } : {};
+  }
+  return request;
+}
+export function isElasticCompilerRequest(request) { return Boolean(request?.[ELASTIC_COMPILER_JOBS]); }
+
+export function fitElasticRequestToPressure(request, pressure) {
+  if (!isElasticCompilerRequest(request) || !pressure || pressure.state === "red") return request;
+  const limit = Number(pressure.limits?.cpu); const busy = Number(pressure.observed?.cpu_busy_cores);
+  const unobserved = Number(pressure.observed?.unobserved_reserved_cpu ?? 0);
+  if (!Number.isFinite(limit) || !Number.isFinite(busy) || !Number.isFinite(unobserved)) return request;
+  const used = Number(pressure.used?.cpu); const overcommit = Number(pressure.limits?.cpu_overcommit); const incremental = Number(pressure.requested?.cpu);
+  const covered = Number.isFinite(incremental) ? Math.max(0, Number(request.cpu) - incremental) : 0;
+  const hostAvailable = Math.floor(limit + 0.25 - busy - Math.max(0, unobserved) + covered);
+  const reservedAvailable = Number.isFinite(used) && Number.isFinite(overcommit)
+    ? Math.floor(limit * overcommit + 0.01 - Math.max(0, used) + covered) : request.compiler_jobs;
+  const floor = request[ELASTIC_COMPILER_JOBS]?.memory_floor_mb;
+  let jobs = Math.max(1, Math.min(request.compiler_jobs, hostAvailable, reservedAvailable));
+  jobs = Math.min(jobs, elasticMemoryJobLimit(request, pressure, jobs, floor));
+  if (jobs >= request.compiler_jobs) return request;
+  return { ...request, cpu: Math.min(Math.max(0, Number(request.cpu) || 0), jobs),
+    memory_mb: elasticMemoryMb(request, jobs, floor), compiler_jobs: jobs };
+}

package/src/local/resource-foreground-wait.mjs

@@ -0,0 +1,29 @@
+const DEFAULT_MINIMUM_WAIT_MS = 2_000;
+const DEFAULT_MAXIMUM_WAIT_MS = 10_000;
+const REMOTE_PROCESS_SESSION_WAIT_MS = 0;
+const MAXIMUM_CONFIGURED_WAIT_MS = 30 * 60_000;
+const DEFAULT_TIMEOUT_FRACTION = 0.2;
+
+export function foregroundResourceWaitMs(executionTimeoutMs, configuredWaitMs = undefined) {
+  if (configuredWaitMs !== undefined) return configuredResourceWaitMs(configuredWaitMs);
+  const timeout = positiveInteger(executionTimeoutMs, "foreground execution timeout");
+  const proportional = Math.floor(timeout * DEFAULT_TIMEOUT_FRACTION);
+  return Math.min(timeout, DEFAULT_MAXIMUM_WAIT_MS, Math.max(DEFAULT_MINIMUM_WAIT_MS, proportional));
+}
+
+export function processSessionResourceWaitMs(configuredWaitMs = undefined, options = {}) {
+  if (configuredWaitMs !== undefined) return configuredResourceWaitMs(configuredWaitMs);
+  return options.remote === true ? REMOTE_PROCESS_SESSION_WAIT_MS : DEFAULT_MAXIMUM_WAIT_MS;
+}
+
+function configuredResourceWaitMs(value) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric < 0) throw new TypeError("resource wait must be a non-negative finite duration");
+  return Math.min(MAXIMUM_CONFIGURED_WAIT_MS, Math.floor(numeric));
+}
+
+function positiveInteger(value, label) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) throw new TypeError(`${label} must be positive`);
+  return Math.max(1, Math.floor(numeric));
+}

package/src/local/resource-go-concurrency.mjs

@@ -0,0 +1,43 @@
+export function goJobPlan(argv, environment = {}, maximum = 1024) { const inherited = goFlagsJobPlan(environment, maximum); return inherited?.fatal ? inherited : directGoPlan(argv, maximum) || inherited; }
+export function goFlagsJobPlan(environment = {}, maximum = 1024) {
+  if (!Object.prototype.hasOwnProperty.call(environment || {}, "GOFLAGS")) return null;
+  const tokens = splitGoFlags(environment.GOFLAGS); if (!tokens) return invalidPlan(true, true);
+  let plan = null;
+  for (const value of tokens) {
+    if (["-p", "--p"].includes(value)) return invalidPlan(true, true);
+    if (/^--?p=/.test(value)) { plan = numericPlan(value.slice(value.indexOf("=") + 1), maximum, true); if (plan.fatal) return plan; }
+  }
+  return plan;
+}
+function directGoPlan(argv, maximum) { let plan = null; let ambiguous = false; let packageList = false; let inPackages = false; const testMode = argv?.[1] === "test";
+  for (let index = 2; index < (argv || []).length; index += 1) { const value = String(argv[index] || ""); if (["--", "-args", "--args"].includes(value)) break;
+    if (!value.startsWith("-")) {
+      if (!testMode) break; if (!packageList || inPackages) { packageList = true; inPackages = true; continue; }
+      if (ambiguous) continue; break;
+    }
+    if (testMode && inPackages) inPackages = false; let current = null;
+    if (["-p", "--p"].includes(value)) { if (ambiguous) return unboundedPlan(false); current = numericPlan(argv[index + 1], maximum, false); index += 1; }
+    else if (/^--?p=/.test(value)) { if (ambiguous) return unboundedPlan(false); current = numericPlan(value.slice(value.indexOf("=") + 1), maximum, false); }
+    else if (/^-p[-+]?\d/.test(value)) { if (ambiguous) return unboundedPlan(false); current = invalidPlan(false, true); }
+    else if (!value.includes("=")) ambiguous = true;
+    if (current?.fatal) return current; if (current) plan = current;
+  }
+  return plan;
+}
+function splitGoFlags(value) {
+  let text = String(value || ""); const result = [];
+  while (text.length) {
+    text = text.replace(/^[ \t\n\r]+/, ""); if (!text) break;
+    if (text[0] === "'" || text[0] === '"') {
+      const quote = text[0]; const end = text.indexOf(quote, 1); if (end < 0) return null;
+      result.push(text.slice(1, end)); text = text.slice(end + 1); continue;
+    }
+    const match = /^[^ \t\n\r]+/.exec(text); result.push(match[0]); text = text.slice(match[0].length);
+  }
+  return result;
+}
+function numericPlan(value, maximum, preserve) { const parsed = Number(value); if (!Number.isSafeInteger(parsed)) return invalidPlan(preserve, true);
+  if (parsed <= 0) return invalidPlan(preserve, false); return parsed <= maximum ? { jobs: parsed, elastic: false, unbounded: false, preserve } : unboundedPlan(preserve);
+}
+function invalidPlan(preserve, fatal) { return { jobs: null, elastic: false, unbounded: false, preserve, invalid: true, fatal }; }
+function unboundedPlan(preserve) { return { jobs: null, elastic: false, unbounded: true, preserve }; }

package/src/local/resource-gradle-concurrency.mjs

@@ -0,0 +1,57 @@
+const WORKERS_PROPERTY = "org.gradle.workers.max";
+const GRADLE_INT_MAX = 2_147_483_647;
+
+export function gradleJobPlan(argv, environment = {}, maximum = 1024) {
+  const property = gradlePropertyPlan(argv, environment, maximum); if (property?.invalid) return property;
+  return gradleCliPlan(argv, maximum) || property;
+}
+function gradleCliPlan(argv, maximum) {
+  const values = [];
+  for (let index = 1; index < (argv || []).length; index += 1) {
+    const value = String(argv[index] || ""); if (value === "--") break;
+    if (value === "--max-workers") { values.push(argv[index + 1]); index += 1; }
+    else if (value.startsWith("--max-workers=")) values.push(value.slice("--max-workers=".length));
+  }
+  if (values.length > 1) return invalidPlan(false);
+  return values.length ? numericPlan(values[0], maximum, false) : null;
+}
+function gradlePropertyPlan(argv, environment, maximum) {
+  let property;
+  for (const key of ["JAVA_OPTS", "GRADLE_OPTS"]) {
+    if (!Object.prototype.hasOwnProperty.call(environment || {}, key)) continue;
+    const tokens = splitJvmOptions(environment[key]); if (!tokens) return unboundedPlan(true);
+    for (const token of tokens) { const value = propertyValue(token); if (value !== undefined) property = value; }
+  }
+  for (let index = 1; index < (argv || []).length; index += 1) {
+    const token = String(argv[index] || ""); if (token === "--") break;
+    const inline = propertyValue(token); if (inline !== undefined) property = inline;
+    else if (["-D", "--system-prop"].includes(token)) {
+      const next = String(argv[index + 1] || ""); if (next.startsWith(`${WORKERS_PROPERTY}=`)) property = next.slice(WORKERS_PROPERTY.length + 1);
+      index += 1;
+    }
+  }
+  return property === undefined ? null : numericPlan(property, maximum, true);
+}
+function propertyValue(token) {
+  for (const prefix of [`-D${WORKERS_PROPERTY}=`, `--system-prop=${WORKERS_PROPERTY}=`]) if (String(token).startsWith(prefix)) return String(token).slice(prefix.length);
+  return undefined;
+}
+function splitJvmOptions(value) {
+  const result = []; let token = ""; let quote = ""; let escaped = false; let active = false;
+  for (const char of String(value || "")) {
+    if (escaped) { token += char; escaped = false; active = true; }
+    else if (char === "\\" && quote !== "'") { escaped = true; active = true; }
+    else if (quote) { if (char === quote) quote = ""; else token += char; active = true; }
+    else if (["'", '"'].includes(char)) { quote = char; active = true; }
+    else if (/\s/.test(char)) { if (active) { result.push(token); token = ""; active = false; } }
+    else { token += char; active = true; }
+  }
+  if (quote || escaped) return null; if (active) result.push(token); return result;
+}
+function numericPlan(value, maximum, preserve) {
+  const text = String(value ?? ""); if (!/^[+-]?\d+$/.test(text)) return invalidPlan(preserve);
+  const parsed = Number(text); if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > GRADLE_INT_MAX) return invalidPlan(preserve);
+  return parsed <= maximum ? { jobs: parsed, elastic: false, unbounded: false, preserve } : unboundedPlan(preserve);
+}
+function invalidPlan(preserve) { return { jobs: null, elastic: false, unbounded: false, preserve, invalid: true }; }
+function unboundedPlan(preserve) { return { jobs: null, elastic: false, unbounded: true, preserve }; }

package/src/local/resource-host-cache.mjs

@@ -0,0 +1,39 @@
+const HOST_SAMPLE_FRESH_MS = 500;
+const HOST_CPU_PREVIOUS_MAX_AGE_MS = 2_000;
+const HOST_IO_SAMPLE_FRESH_MS = 5_000;
+const HOST_IO_HINT_MAX_AGE_MS = 30_000;
+
+export function resourceHostNeedsFreshIo(request) {
+  return request?.resource_class === "io" || request?.resource_class === "unbounded";
+}
+
+export async function freshResourceHostSnapshot({ cached, current, sampleHost, cwd, request = null, scope = "" }) {
+  const scopedCached = cached?.sample_scope === scope ? cached : null;
+  const sampleAge = scopedCached ? current - Number(scopedCached.sampled_at_ms) : Number.POSITIVE_INFINITY;
+  const globalAge = cached ? current - Number(cached.sampled_at_ms) : Number.POSITIVE_INFINITY;
+  const cpuPrevious = cached && globalAge >= 0 && globalAge <= HOST_CPU_PREVIOUS_MAX_AGE_MS ? cached : null;
+  const needsIo = resourceHostNeedsFreshIo(request);
+  if (scopedCached && sampleAge >= 0 && sampleAge <= HOST_SAMPLE_FRESH_MS && (!needsIo || scopedCached.io_sampled === true)) return scopedCached;
+  const ioSampledAt = Number(scopedCached?.io_sampled_at_ms ?? scopedCached?.sampled_at_ms);
+  const ioAge = current - ioSampledAt;
+  if (!needsIo) {
+    const quick = { ...await Promise.resolve(sampleHost({ cwd, quick: true, previous: cpuPrevious })), sample_scope: scope };
+    if (scopedCached?.io_sampled !== true || !Number.isFinite(ioAge) || ioAge < 0 || ioAge > HOST_IO_HINT_MAX_AGE_MS) return quick;
+    return withCachedIo(quick, scopedCached);
+  }
+  if (scopedCached?.io_sampled === true && Number.isFinite(ioAge) && ioAge >= 0 && ioAge <= HOST_IO_SAMPLE_FRESH_MS) {
+    const quick = { ...await Promise.resolve(sampleHost({ cwd, quick: true, previous: cpuPrevious })), sample_scope: scope };
+    return withCachedIo(quick, scopedCached);
+  }
+  return { ...await Promise.resolve(sampleHost({ cwd, quick: false, previous: cpuPrevious })), sample_scope: scope };
+}
+
+function withCachedIo(sample, cached) {
+  return {
+    ...sample,
+    disk_mb_per_s: cached.disk_mb_per_s ?? null,
+    disk_iops: cached.disk_iops ?? null,
+    io_sampled: true,
+    io_sampled_at_ms: Number.isFinite(Number(cached.io_sampled_at_ms)) ? Number(cached.io_sampled_at_ms) : Number(cached.sampled_at_ms),
+  };
+}

package/src/local/resource-host-darwin.mjs

@@ -0,0 +1,54 @@
+import { runResourceProbeAsync, runResourceProbeSync } from "./resource-probe-command.mjs";
+
+export function sampleDarwinHost(sample, options = {}) {
+  const run = options.runCommand || ((command, args, timeoutMs) => runResourceProbeSync(command, args, { timeoutMs }));
+  applyDarwinResults(sample, {
+    pressure: run("/usr/bin/memory_pressure", ["-Q"]),
+    vm: run("/usr/bin/vm_stat", []),
+    io: options.quick === true ? null : run("/usr/sbin/iostat", ["-Id", "disk0", "1", "2"], 2_200),
+    thermal: run("/usr/bin/pmset", ["-g", "therm"]),
+  }, options.quick !== true);
+}
+
+export async function sampleDarwinHostAsync(options = {}) {
+  const run = options.runCommandAsync || ((command, args, timeoutMs) => runResourceProbeAsync(command, args, { timeoutMs }));
+  const [pressure, vm, io, thermal] = await Promise.all([
+    run("/usr/bin/memory_pressure", ["-Q"]),
+    run("/usr/bin/vm_stat", []),
+    options.quick === true ? Promise.resolve(null) : run("/usr/sbin/iostat", ["-Id", "disk0", "1", "2"], 2_200),
+    run("/usr/bin/pmset", ["-g", "therm"]),
+  ]);
+  const sample = {};
+  applyDarwinResults(sample, { pressure, vm, io, thermal }, options.quick !== true);
+  return sample;
+}
+
+function applyDarwinResults(sample, results, sampledIo) {
+  const { pressure, vm, io, thermal } = results;
+  if (pressure?.ok) {
+    const match = /System-wide memory free percentage:\s*(\d+)%/i.exec(pressure.stdout);
+    if (match) sample.memory_free_percent = Number(match[1]);
+  }
+  if (vm?.ok) {
+    sample.pageouts_total = vmCounter(vm.stdout, "Pageouts");
+    sample.swapouts_total = vmCounter(vm.stdout, "Swapouts");
+  }
+  if (sampledIo) {
+    if (io?.ok) {
+      const rows = String(io.stdout || "").split("\n").map((line) => line.trim()).filter((line) => /^\d/.test(line));
+      const fields = rows.at(-1)?.split(/\s+/).map(Number) || [];
+      if (fields.length >= 3 && fields.every(Number.isFinite)) {
+        sample.disk_iops = fields[1];
+        sample.disk_mb_per_s = fields[2];
+        sample.io_sampled = true;
+        sample.io_sampled_at_ms = Date.now();
+      }
+    }
+  }
+  if (thermal?.ok) sample.thermal_warning = !(/No thermal warning level has been recorded/i.test(thermal.stdout) && /No performance warning level has been recorded/i.test(thermal.stdout));
+}
+
+function vmCounter(text, label) {
+  const match = new RegExp(`^${label}:\\s*(\\d+)\\.?$`, "mi").exec(String(text || ""));
+  return match ? Number(match[1]) : null;
+}

package/src/local/resource-host-linux.mjs

@@ -0,0 +1,35 @@
+import { readFileSync } from "node:fs";
+
+export function sampleLinuxHost(sample, options = {}) {
+  const read = options.readFile || readText;
+  const meminfo = read("/proc/meminfo");
+  const totalKb = meminfoKb(meminfo, "MemTotal");
+  const availableKb = meminfoKb(meminfo, "MemAvailable");
+  if (totalKb !== null && totalKb > 0) {
+    sample.total_memory_mb = Math.max(1024, Math.round(totalKb / 1024));
+    if (availableKb !== null) sample.memory_free_percent = Math.max(0, Math.min(100, availableKb * 100 / totalKb));
+  }
+  const cpu = read("/proc/pressure/cpu");
+  const memory = read("/proc/pressure/memory");
+  const io = read("/proc/pressure/io");
+  sample.psi_cpu_some_avg10 = psiAvg10(cpu, "some");
+  sample.psi_memory_some_avg10 = psiAvg10(memory, "some");
+  sample.psi_memory_full_avg10 = psiAvg10(memory, "full");
+  sample.psi_io_some_avg10 = psiAvg10(io, "some");
+  sample.psi_io_full_avg10 = psiAvg10(io, "full");
+  sample.io_sampled = sample.psi_io_some_avg10 !== null || sample.psi_io_full_avg10 !== null;
+}
+
+function meminfoKb(text, key) {
+  const match = new RegExp(`^${key}:\\s*(\\d+)\\s+kB$`, "mi").exec(String(text || ""));
+  return match ? Number(match[1]) : null;
+}
+
+function psiAvg10(text, kind) {
+  const match = new RegExp(`^${kind}\\s+[^\\n]*?avg10=(\\d+(?:\\.\\d+)?)`, "mi").exec(String(text || ""));
+  return match ? Number(match[1]) : null;
+}
+
+function readText(path) {
+  try { return readFileSync(path, "utf8"); } catch { return ""; }
+}