forgedock 1.24.1 → 1.24.3

package/bin/engine/outcome-codes.mjs

@@ -35,6 +35,8 @@ export const OUTCOME_CODES = Object.freeze({
   CI_TIMEOUT: "ci.timeout",
   BASE_CONFLICT: "base.conflict",
   RATE_LIMITED: "rate_limited",
+  HOST_BUSY: "host.busy",
+  PATH_SWITCH_CONFLICT: "path.switch_conflict",
   ENGINE_ERROR: "engine.error",
   INFRA_DISK_QUOTA: "infra.disk_quota",
   INFRA_CLI_SPAWN_TRANSIENT: "infra.cli_spawn_transient",

package/bin/engine/runlog.mjs

@@ -56,7 +56,22 @@ export function readLog(dir, issue) {
 }
 
 /** Fold events into a RunState. The commit rule lives here. */
-export function deriveState(events) {
+/**
+ * #4109: the run log is shared by the full and the core path. Keep only the events of runs whose `path` (from RUN_START;
+ * missing means "full", for historic logs) equals `path`, so one path never replays the other's commits or terminals.
+ */
+export function scopeEvents(events, path = "full") {
+  let cur = "full";
+  const out = [];
+  for (const e of events) {
+    if (e.event === "RUN_START") cur = e.path ?? "full";
+    if (cur === path) out.push(e);
+  }
+  return out;
+}
+
+export function deriveState(allEvents, { path = "full" } = {}) {
+  const events = scopeEvents(allEvents, path);
   /** @type {import("./phases.mjs").RunState} */
   const s = { v: 0, run: null, issue: null, lane: "staging", committed: [],
               phase: null, branch: null, pr: null, terminal: false,

package/bin/engine-cli.mjs

@@ -99,6 +99,20 @@ function readLeanSetting(key, cwd = process.cwd()) {
   } catch { return undefined; }
 }
 // core is the default; lean and auto are aliases of core. full is the legacy multi-phase pipeline.
+/**
+ * forge.yaml `engine.admission` (#4105). The parser flattens one nested level into `engine`, so the keys are read as
+ * `engine.enabled|min_free_mem_mb|min_free_tmp_mb|max_load_per_core`, or flat `admission_*` equivalents.
+ */
+export function readAdmission(cwd = process.cwd()) {
+  try {
+    const e = parseForgeYaml(readFileSync(join(cwd, "forge.yaml"), "utf8"))?.engine ?? {};
+    const num = (v) => { const n = Number(v); return v !== undefined && v !== "" && Number.isFinite(n) && n >= 0 ? n : undefined; };
+    const en = String(e.admission_enabled ?? e.enabled ?? "").trim().toLowerCase();
+    return { ...(en === "false" ? { enabled: false } : {}),
+      min_free_mem_mb: num(e.min_free_mem_mb ?? e.admission_min_free_mem_mb), min_free_tmp_mb: num(e.min_free_tmp_mb ?? e.admission_min_free_tmp_mb),
+      max_load_per_core: num(e.max_load_per_core ?? e.admission_max_load_per_core) };
+  } catch { return {}; }
+}
 /** forge.yaml `engine.merge_wait` (required|all|none); undefined when absent or invalid. */
 export function readMergeWait(cwd = process.cwd()) {
   try {
@@ -466,7 +480,8 @@ export async function runFromCli(argv, deps = {}) {
     const leanIo = deps.leanIo ?? (await import("./lean/effects.mjs")).makeLeanIo({ repo: leanRepo });
     const lres = await runCore({ issue, repo: leanRepo, lane, cwd: process.cwd(), dir, io: leanIo, path: enginePath, onProgress,
       emitTelemetry: deps.emitTelemetry ?? makeEmitTelemetry({ repo: leanRepo }),
-      ...(readMergeWait() ? { mergeWait: readMergeWait() } : {}), ...(model ? { builderModel: model } : {}), ...(readLeanSetting("reviewer_model") ? { reviewerModel: readLeanSetting("reviewer_model") } : {}) });
+      admission: readAdmission(), ...(readMergeWait() ? { mergeWait: readMergeWait() } : {}), ...(model ? { builderModel: model } : {}), ...(readLeanSetting("reviewer_model") ? { reviewerModel: readLeanSetting("reviewer_model") } : {}) });
+    if (lres.code === "host.busy") { console.log(`issue #${issue} → deferred (${lres.detail})`); return lres; }
     console.log(`issue #${issue} → ${lres.terminalReason}`);
     if (!["merged", "invalid"].includes(lres.terminalReason)) console.log(lres.detail ?? "");
     return lres;
@@ -495,7 +510,7 @@ export async function runFromCli(argv, deps = {}) {
     return res;
   }
   // forge#3932: refused before any state write (open or unreadable **Depends on**); nothing ran.
-  if (res.terminalReason === "dependency-open" || res.terminalReason === "dependency-unreadable") {
+  if (res.terminalReason === "dependency-open" || res.terminalReason === "dependency-unreadable" || res.code === "path.switch_conflict") {
     console.log(res.detail ?? "run refused: dependency check");
     return res;
   }
@@ -658,7 +673,7 @@ export async function orchestrateFromCli(argv, deps = {}) {
     issues, parallel,
     readBody: async (n) => JSON.parse(await leanIo.gh(["issue", "view", String(n), "-R", repo, "--json", "body"])).body,
     runOne: (n) => runCore({ issue: n, repo, lane, cwd: process.cwd(), dir, io: leanIo, agentId: `orch_${process.pid}_${n}`, emitTelemetry,
-      ...(readMergeWait() ? { mergeWait: readMergeWait() } : {}), ...(model ? { builderModel: model } : {}), ...(readLeanSetting("reviewer_model") ? { reviewerModel: readLeanSetting("reviewer_model") } : {}) }),
+      admission: readAdmission(), ...(readMergeWait() ? { mergeWait: readMergeWait() } : {}), ...(model ? { builderModel: model } : {}), ...(readLeanSetting("reviewer_model") ? { reviewerModel: readLeanSetting("reviewer_model") } : {}) }),
     onUpdate: (r) => console.log(`#${r.issue} → ${r.outcome}${r.detail && r.outcome !== "merged" ? ` (${r.detail})` : ""}`),
   });
   console.log("\n" + formatTable(rows));

package/bin/engine.mjs

@@ -8,7 +8,7 @@ import { readFileSync, rmSync, readdirSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { createHash, scryptSync } from "node:crypto";
 import { hostname as osHostname, homedir } from "node:os";
-import { appendEvent, readLog, deriveState, rewriteLog } from "./engine/runlog.mjs";
+import { appendEvent, readLog, deriveState, rewriteLog, scopeEvents } from "./engine/runlog.mjs";
 import { pickPhase, TERMINAL_REASONS, issueSnapshot, hasInvestigationExit, postCycleMarker, nextCycleNumber, newestCycle, cycleResetProvable, remediationHeadStale, decompositionRevoked, openDependency } from "./engine/phases.mjs";
 import { reconcileState } from "./engine/reconcile.mjs";
 import { makeProjector } from "./engine/projector.mjs";
@@ -440,7 +440,8 @@ export async function runIssue(opts) {
   const projector = makeProjector(io);
 
   // 1. Load + reconcile (GitHub wins).
-  const local = readLog(dir, issue).length ? deriveState(readLog(dir, issue)) : null;
+  // #4109: only this (full) path's own events: core-path commits and terminals in the shared log are never replayed here.
+  const local = scopeEvents(readLog(dir, issue)).length ? deriveState(readLog(dir, issue)) : null;
   let remote = await projector.readState(issue);
   let { state, action } = reconcileState(local, remote);
   const leaseHeld = (r) => !!(r?.lease && r.lease.until > now() && r.lease.by !== agentId &&
@@ -495,6 +496,19 @@ export async function runIssue(opts) {
       };
     }
   }
+  // #4109: an open core-path PR means the work already exists; a second implementation from the full path would duplicate it.
+  {
+    let prs = [];
+    try { prs = JSON.parse(String(await io.gh(["pr", "list", ...(repo ? ["-R", String(repo)] : []), "--head", `feat/issue-${issue}-lean`, "--state", "open", "--json", "number,headRefName"])) || "[]"); } catch { prs = []; }
+    prs = Array.isArray(prs) ? prs.filter((x) => x?.headRefName === `feat/issue-${issue}-lean`) : [];
+    if (Array.isArray(prs) && prs.length && Number.isInteger(prs[0]?.number)) {
+      return {
+        terminalReason: "needs-human",
+        code: OUTCOME_CODES.PATH_SWITCH_CONFLICT,
+        detail: `issue ${issue} has an open core-path PR #${prs[0].number}; rerun on the default path (base-sync) or close that PR first.`,
+      };
+    }
+  }
   // forge#3824: hoisted so RUN_START can carry the repo (lazy, memoised; null when unresolved).
   let repoPromise = null;
   const resolveRepo = () => (repoPromise ??= (async () => {

package/bin/lean/admission.mjs

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Copyright (c) RapierCraft Studios
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * Host-resource admission for the core work-on (#4105): refuse to start a run when the host is out of headroom, so a
+ * batch of lanes does not push the machine into OOM or a full /tmp. Every probe is injected through `host`.
+ */
+export const ADMISSION_DEFAULTS = Object.freeze({ enabled: true, min_free_mem_mb: 2048, min_free_tmp_mb: 1024, max_load_per_core: 4 });
+export const ADMISSION_RETRY_SECONDS = 60;
+
+const gb = (mb) => { const g = mb / 1024; return `${Number.isInteger(g) ? g : g.toFixed(1)}G`; };
+
+/**
+ * @param {{cfg?: object, host: {memAvailableMb?: Function, freeMb?: Function, loadAvg1?: Function, cores?: Function, tmpPaths?: Function}}} p
+ * @returns {Promise<{ok: boolean, reasons: string[], detail: string}>}
+ */
+export async function checkAdmission({ cfg = {}, host }) {
+  const c = { ...ADMISSION_DEFAULTS, ...Object.fromEntries(Object.entries(cfg ?? {}).filter(([, v]) => v !== undefined && v !== null)) };
+  if (c.enabled === false || !host) return { ok: true, reasons: [], detail: "" };
+  const reasons = [];
+  const safe = async (fn, ...a) => { try { const v = await fn?.(...a); return Number.isFinite(v) ? v : null; } catch { return null; } };
+  const mem = await safe(host.memAvailableMb);
+  if (mem !== null && mem < c.min_free_mem_mb) reasons.push(`mem ${gb(mem)} < ${gb(c.min_free_mem_mb)}`);
+  let paths = [];
+  try { paths = (await host.tmpPaths?.()) ?? []; } catch { paths = []; }
+  for (const p of paths) {
+    const free = await safe(host.freeMb, p);
+    if (free !== null && free < c.min_free_tmp_mb) reasons.push(`tmp ${p} ${gb(free)} < ${gb(c.min_free_tmp_mb)}`);
+  }
+  const load = await safe(host.loadAvg1), cores = await safe(host.cores);
+  if (load !== null && cores && load / cores > c.max_load_per_core) reasons.push(`load ${(load / cores).toFixed(1)}/core > ${c.max_load_per_core}`);
+  return { ok: reasons.length === 0, reasons, detail: reasons.length ? `host busy: ${reasons.join(", ")}; retry in ${ADMISSION_RETRY_SECONDS}s` : "" };
+}

package/bin/lean/effects.mjs

@@ -4,7 +4,8 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { readFileSync, appendFileSync, mkdirSync, statSync, existsSync, rmSync, writeFileSync, readdirSync, lstatSync } from "node:fs";
-import { homedir, hostname } from "node:os";
+import { homedir, hostname, freemem, loadavg, cpus, tmpdir } from "node:os";
+import { promises as fsp } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { runCliBackendAsync, resolveClaudeCliBinary, getClaudeCliCapabilities, buildLeanSessionFlags, buildReadOnlyToolFlags } from "../runner.mjs";
@@ -70,11 +71,33 @@ export function makeRunTmp({ root = runTmpRoot(), now = () => Date.now(), alive
   };
 }
 
+/** Real host probes for admission (#4105). MemAvailable from /proc/meminfo (fallback os.freemem), statfs for tmp. */
+export function makeHostProbe() {
+  return {
+    memAvailableMb() {
+      try {
+        const m = /^MemAvailable:\s+(\d+)\s+kB/m.exec(readFileSync("/proc/meminfo", "utf8"));
+        if (m) return Math.floor(Number(m[1]) / 1024);
+      } catch { /* not Linux */ }
+      return Math.floor(freemem() / 1048576);
+    },
+    async freeMb(p) {
+      let dir = p;
+      while (dir && !existsSync(dir) && dirname(dir) !== dir) dir = dirname(dir);
+      const s = await fsp.statfs(dir);
+      return Math.floor((Number(s.bavail) * Number(s.bsize)) / 1048576);
+    },
+    loadAvg1: () => loadavg()[0],
+    cores: () => cpus().length || 1,
+    tmpPaths: () => [...new Set([join(homedir(), ".forge", "tmp"), tmpdir(), "/tmp"].filter((x) => existsSync(x) || x === join(homedir(), ".forge", "tmp")))],
+  };
+}
+
 export function makeLeanIo({ repo }) {
   const base = makeIo();
   const run = (bin) => async (args, opts = {}) => (await pexec(bin, args, { cwd: opts.cwd, maxBuffer: 100 * 1024 * 1024, timeout: 120000 })).stdout;
   return {
-    gh: run("gh"), git: run("git"), runTmp: makeRunTmp(), projector: makeProjector({ gh: base.gh }), runner: makeLeanRunner(), waitCiGreen: base.waitCiGreen,
+    gh: run("gh"), git: run("git"), runTmp: makeRunTmp(), host: makeHostProbe(), projector: makeProjector({ gh: base.gh }), runner: makeLeanRunner(), waitCiGreen: base.waitCiGreen,
     /** Names of the checks the base branch requires (contexts + checks). [] on 404 / no protection. */
     async requiredChecks(lane) {
       try {

package/bin/lean/lean.mjs

@@ -11,6 +11,7 @@ import { appendEvent } from "../engine/runlog.mjs";
 import { codeForTerminalReason, OUTCOME_CODES } from "../engine/outcome-codes.mjs";
 import { ciPollDelayMs, ENGINE_VERSION, DEFAULT_MAX_SESSION_LIMIT_PAUSES, DEFAULT_SESSION_LIMIT_WAIT_MS, parseLeaseHolder, sanitizeLeaseHost } from "../engine.mjs";
 import { openDependency } from "../engine/phases.mjs";
+import { checkAdmission, ADMISSION_RETRY_SECONDS } from "./admission.mjs";
 import { renderInvestigation, renderPlan, renderImplementation, renderReview, renderPrBody, renderTrajectory, capComment, sanitizeMd } from "./render.mjs";
 import { REVIEWER_SYSTEM, LEAN_DIR, RESULT_FILE, INVESTIGATION_FILE, PLAN_FILE, IMPLEMENTATION_FILE, builderPrompt, resumeBuilderPrompt, reviewerPrompt, parseVerdict } from "./prompts.mjs";
 
@@ -214,6 +215,11 @@ export async function runCore(o) {
   }
   const readResult = async () => { try { const j = JSON.parse(await io.fs.read(`${wt}/${RESULT_FILE}`)); return j && typeof j === "object" ? j : null; } catch { return null; } };
 
+  // ---- host admission (#4105): before the lease, the worktree or any GitHub call ----
+  if (io.host && o.admission?.enabled !== false) {
+    const a = await checkAdmission({ cfg: o.admission, host: io.host });
+    if (!a.ok) return { terminalReason: "deferred", code: OUTCOME_CODES.HOST_BUSY, detail: a.detail, retryInSeconds: ADMISSION_RETRY_SECONDS };
+  }
   // ---- admission: Depends-on refusal, then lease ----
   {
     let dep = null;

package/bin/lean/lean.test.mjs

@@ -10,6 +10,9 @@ import { REVIEWER_SYSTEM, approxTokens, builderPrompt, reviewerPrompt, parseVerd
 import { mapRecord } from "../engine/telemetry-seam.mjs";
 import { readLog } from "../engine/runlog.mjs";
 import { makeRunTmp } from "./effects.mjs";
+import { checkAdmission } from "./admission.mjs";
+import { OUTCOME_CODES } from "../engine/outcome-codes.mjs";
+import { readAdmission } from "../engine-cli.mjs";
 import { runFromCli, orchestrateFromCli, ENGINE_PATHS } from "../engine-cli.mjs";
 
 const WT = "/wt/lean-7";
@@ -905,3 +908,74 @@ describe("usage limit, lease takeover, worktree setup, run tmp (#4101-#4104)", (
     assert.equal(seen.ANTHROPIC_API_KEY, undefined);
   });
 });
+
+describe("host admission (#4105)", () => {
+  const host = (o = {}) => ({ memAvailableMb: () => o.mem ?? 8192, freeMb: async (p) => (o.free ?? { "/tmp": 8192, "/home/x/.forge/tmp": 8192 })[p], loadAvg1: () => o.load ?? 1, cores: () => o.cores ?? 8, tmpPaths: () => ["/home/x/.forge/tmp", "/tmp"] });
+  const withHost = (w, h) => { w.io.host = h; w.ghCalls = 0; w.leaseWrites = []; w.io.projector = { readState: async () => { w.leaseReads = (w.leaseReads ?? 0) + 1; return null; }, writeState: async (_i, st) => { w.leaseWrites.push(st); } };
+    const g = w.io.gh; w.io.gh = async (a) => { w.ghCalls++; return g(a); }; return w; };
+
+  it("the outcome code is registered", async () => {
+    assert.equal(OUTCOME_CODES.HOST_BUSY, "host.busy");
+    const { readFileSync } = await import("node:fs");
+    assert.match(readFileSync(new URL("../../docs/OUTCOME-CODES.md", import.meta.url), "utf8"), /`host\.busy`/);
+  });
+
+  it("passes with headroom and runs normally", async () => {
+    const w = withHost(world(), host());
+    assert.equal((await run(w)).terminalReason, "merged");
+    assert.ok(w.ghCalls > 0);
+  });
+
+  it("low memory: deferred host.busy, no lease, no GitHub call, no worktree", async () => {
+    const w = withHost(world(), host({ mem: 1228 }));
+    const r = await run(w);
+    assert.equal(r.terminalReason, "deferred"); assert.equal(r.code, "host.busy");
+    assert.equal(r.detail, "host busy: mem 1.2G < 2G; retry in 60s");
+    assert.equal(w.ghCalls, 0); assert.equal(w.leaseWrites.length, 0); assert.equal(w.leaseReads ?? 0, 0);
+    assert.equal(w.calls.length, 0, "no git or runner calls");
+    assert.deepEqual(w.labels, []);
+  });
+
+  it("low tmp space on the run TMPDIR filesystem or on /tmp is deferred host.busy", async () => {
+    for (const free of [{ "/tmp": 8192, "/home/x/.forge/tmp": 512 }, { "/tmp": 100, "/home/x/.forge/tmp": 8192 }]) {
+      const w = withHost(world(), host({ free }));
+      const r = await run(w);
+      assert.equal(r.code, "host.busy"); assert.match(r.detail, /tmp \S+ \S+G < 1G/);
+      assert.equal(w.ghCalls, 0);
+    }
+  });
+
+  it("high load per core is deferred; disabled admission runs even on a starved host", async () => {
+    const wl = withHost(world(), host({ load: 40, cores: 8 }));
+    assert.match((await run(wl)).detail, /load 5\.0\/core > 4/);
+    const wd = withHost(world(), host({ mem: 1, free: { "/tmp": 1, "/home/x/.forge/tmp": 1 }, load: 99 }));
+    assert.equal((await run(wd, { admission: { enabled: false } })).terminalReason, "merged");
+  });
+
+  it("thresholds are configurable; a failing probe does not block", async () => {
+    assert.equal((await checkAdmission({ cfg: { min_free_mem_mb: 100 }, host: host({ mem: 500 }) })).ok, true);
+    assert.equal((await checkAdmission({ cfg: { min_free_mem_mb: 1000 }, host: host({ mem: 500 }) })).ok, false);
+    assert.equal((await checkAdmission({ host: { memAvailableMb: () => { throw new Error("x"); }, tmpPaths: () => { throw new Error("y"); } } })).ok, true);
+  });
+
+  it("forge.yaml engine.admission is read (nested or flat) and the CLI prints the deferral as the last line", async () => {
+    const { writeFileSync } = await import("node:fs");
+    const d = tmpDir("core-adm-");
+    writeFileSync(`${d}/forge.yaml`, "engine:\n  admission:\n    enabled: false\n    min_free_mem_mb: 4096\n");
+    const a = readAdmission(d);
+    assert.equal(a.enabled, false); assert.equal(a.min_free_mem_mb, 4096);
+    const lines = []; const l = console.log; console.log = (x) => lines.push(String(x));
+    try {
+      await runFromCli(["7", "--lane", "staging", "--repo", "o/r"], { dir: tmpDir("core-adm-"), emitTelemetry: async () => {}, leanIo: {}, io: { gh: async () => "o/r\n" },
+        leanModule: { runCore: async () => ({ terminalReason: "deferred", code: "host.busy", detail: "host busy: mem 1.2G < 2G; retry in 60s" }) } });
+    } finally { console.log = l; }
+    assert.equal(lines.at(-1), "issue #7 → deferred (host busy: mem 1.2G < 2G; retry in 60s)");
+  });
+
+  it("/orchestrate spec requeues host-busy lanes with a lower K and pauses on rate_limited", async () => {
+    const { readFileSync } = await import("node:fs");
+    const spec = readFileSync(new URL("../../commands/orchestrate.md", import.meta.url), "utf8");
+    assert.match(spec, /host busy[\s\S]*lower the effective K by\s+1 for the next 5 minutes, never below 1/);
+    assert.match(spec, /rate_limited[\s\S]*stop launching\s+new lanes until that reset time/);
+  });
+});

package/commands/orchestrate.md

@@ -81,6 +81,12 @@ lanes finish.
 When a lane finishes:
 - `deferred` (lease held by another or a dead session): put it back in the queue and retry after the
   lease time printed in its output.
+- `deferred` with "host busy" (code `host.busy`: the host is short of memory, tmp space or CPU headroom;
+  no lease was taken and nothing was posted): put the issue back in the queue and lower the effective K by
+  1 for the next 5 minutes, never below 1. Before raising K back, start one lane and check that it is not
+  host busy again.
+- `deferred` with `rate_limited` (usage limit; the last output line carries the reset time): stop launching
+  new lanes until that reset time, let running lanes finish, then resume the queue.
 - `dependency-open`: the engine found a dependency you missed. Add the edge and requeue the issue behind it.
 - `merged` or `invalid`: start the next ready issue.
 - `needs-human`: read the issue's last comment for the reason, and mark its dependents skipped.

package/docs/CONFIG.md

@@ -482,6 +482,7 @@ engine:
 | `<key>_max_turns` | integer | No | Positive integer passed as `--max-turns`. Invalid values are ignored. |
 
 | `path` | string | No | `core` (default), `full`, `lean` or `auto`. `core` is the lean work-on (`bin/lean/`): one plain builder session, one read-only two-question reviewer, GitHub as the register (see RELEASE-NOTES v1.22). `lean` and `auto` are aliases of `core`; `full` runs the legacy multi-phase pipeline and is required for `--retry` and `--wait-lease`. The `--path` flag overrides. `lean_reviewer_model` sets the reviewer model (default `claude-sonnet-5-5`); the builder uses `--model` or the CLI default. `forgedock orchestrate <issues...> [--parallel K] [--lane L]` runs the core per issue (K default 3, lane default `staging`) and honours `**Depends on**` ordering among the given issues. |
+| `admission` | map | No | Host-resource admission for the core work-on (#4105), checked before the lease, worktree or any GitHub call. When a check fails the run ends `deferred` (code `host.busy`, exit 75) with a last line such as `issue #N → deferred (host busy: mem 1.2G < 2G; retry in 60s)`; no lease is taken and nothing is posted. Keys: `enabled` (default `true`; `false` disables admission), `min_free_mem_mb` (default 2048; `MemAvailable` from `/proc/meminfo`, else `os.freemem()`), `min_free_tmp_mb` (default 1024; free space of the run TMPDIR filesystem, `~/.forge/tmp`, and of `/tmp`, via `statfs`), `max_load_per_core` (default 4; 1-minute load average divided by cores). Write it nested (`engine:` then `admission:` with the keys indented) or flat as `admission_enabled`, `admission_min_free_mem_mb`, `admission_min_free_tmp_mb`, `admission_max_load_per_core`; the parser reads one nested level into `engine`. `/orchestrate` requeues a host-busy lane and lowers K by 1 for 5 minutes. |
 | `merge_wait` | string | No | Core work-on merge gate. `required` (default): wait only for the status checks the base branch requires under branch protection (`gh api repos/{o}/{r}/branches/{base}/protection/required_status_checks`, contexts and checks); with no protection or no required checks (404 or empty) merge right after review PASS. A failing required check is `needs-human`; a pending one is polled with backoff and never `needs-human`. `all`: wait for every check (`scripts/wait-ci-green.sh`). `none`: merge right after review. Always `--match-head-commit` at the reviewed head. The policy used is recorded in the `FORGE:WORK-ON` comment. |
 | `ci_pending_max_minutes` | integer | No | Minutes the engine waits for CI when the review phase ends BLOCKED with "checks still pending", or the remediate phase holds at its M7 re-gate on "CI pending" (the merge gate's wait window ended while CI was still running). Default: 90. Invalid values are ignored. This key is flat like the others but is not part of the `<key>_model` / `<key>_max_turns` pattern. |
 

package/docs/OUTCOME-CODES.md

@@ -33,6 +33,8 @@ An absent or unknown code is recorded as `unclassified`, with the raw reason kep
 | `ci.red` | CI failed | reserved | `REVIEW_RESULT` carries no CI field yet |
 | `ci.timeout` | CI timed out | reserved | `REVIEW_RESULT` carries no CI field yet |
 | `base.conflict` | Base-branch conflict blocked the PR | reserved | `REVIEW_RESULT` carries no conflict field yet |
+| `path.switch_conflict` | The full path was started on an issue that has an open core-path PR (`feat/issue-<n>-lean`); refused to avoid a second implementation. Rerun on the default path (base-sync) or close that PR first | engine | `bin/engine.mjs` admission |
+| `host.busy` | Core run deferred at admission: free memory, free tmp space or load per core outside `engine.admission` limits; no lease taken, nothing posted | lean | `bin/lean/admission.mjs` |
 | `rate_limited` | Session or usage limit outlasted the pause budget | engine | `err.usageLimit` / `err.resetAtEpochMs` |
 | `engine.error` | Engine or tool failure (missing key/SDK, CLI crash, max turns, unresolved args, runner threw every attempt) | engine | `err.code` |
 | `infra.disk_quota` | Disk full or quota exhausted (EDQUOT/ENOSPC, errno -28/-122); retryable infra failure, never `needs-human` | engine | Runner error text |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgedock",
-  "version": "1.24.1",
+  "version": "1.24.3",
   "description": "Autonomous development pipeline for coding agents. GitHub as institutional memory, with native Claude Code and OpenCode entrypoints.",
   "bin": {
     "forgedock": "bin/forgedock.mjs"