forgedock 1.21.0 → 1.23.0

package/bin/engine/phases.mjs

@@ -977,6 +977,18 @@ export const PHASES = [
       };
       // forge#3685: a resume that ends HELD posts a non-terminal FORGE:REMEDIATION_HELD record (no COMPLETE).
       // Newest-wins between the held record and COMPLETE, by position in the (trusted, scoped) comment list.
+      // forge#3947: a trail posted after THIS dispatch's marker is this run's outcome; a push that moved the PR
+      // head after it was posted must not reclassify it. Only an older trail is judged against the live head.
+      const headStale = async () => {
+        let dispatchAt = -1, trailAt = -1;
+        const dispatchSentinel = `${REMEDIATION_DISPATCH_MARKER}: pr=${state.pr}`;
+        scoped.forEach((b, i) => {
+          if (state.pr != null && hasSentinelLine(b, dispatchSentinel)) dispatchAt = i;
+          if (startsWithHeader(b, PHASE_MARKERS.remediate.header) && hasSentinelLine(b, completion)) trailAt = i;
+        });
+        if (dispatchAt >= 0 && trailAt > dispatchAt) return false;
+        return remediationHeadStale(state, io);
+      };
       const isHeld = (b) => startsWithHeader(b, REMEDIATION_HELD_MARKER) && hasSentinelLine(b, REMEDIATION_HELD_MARKER);
       let heldAt = -1, completeAt = -1;
       scoped.forEach((b, i) => {
@@ -1039,7 +1051,7 @@ export const PHASES = [
         case "RE-ESCALATED":
         case "UNFIXABLE":
           // forge#3931: a trail recorded against an older PR head must not be replayed as this run's outcome.
-          if (await remediationHeadStale(state, io))
+          if (await headStale())
             return { status: "failed", code: OC.REMEDIATE_NO_MARKER, detail: `stale ${completion} trail: PR head moved since it was recorded` };
           // Both leave the issue at needs-human (a fresh escalation, or a
           // policy judgment call respectively) — reuse the existing
@@ -1053,7 +1065,7 @@ export const PHASES = [
         case "INPR-FIX-REQUESTED": {
           // forge#4021: the re-review approved but posted a FORGE:INPR_FIX work order. One further in-PR fix
           // remediation is allowed (never needs-human on the first request); the bound marker count caps it.
-          if (await remediationHeadStale(state, io))
+          if (await headStale())
             return { status: "failed", code: OC.REMEDIATE_NO_MARKER, detail: `stale ${completion} trail: PR head moved since it was recorded` };
           if (await prMerged()) return mergedResult(reGateOutcome);
           const round = /\*\*INPR round\*\*:\s*(\d+)/.exec(latest)?.[1] ?? null;
@@ -1065,7 +1077,7 @@ export const PHASES = [
           return { status: "committed", code: OC.REMEDIATE_INPR_REQUESTED, outputs: { ...outputs, remediation: "inpr-fix" } };
         }
         case "REREVIEW-REQUIRED":
-          if (await remediationHeadStale(state, io))
+          if (await headStale())
             return { status: "failed", code: OC.REMEDIATE_NO_MARKER, detail: `stale ${completion} trail: PR head moved since it was recorded` };
           return { status: "committed", terminalReason: "needs-human", code: OC.REMEDIATE_RE_ESCALATED, outputs: { reGateOutcome } };
         default:

package/bin/engine-cli.mjs

@@ -85,7 +85,7 @@ export function readCiPendingMaxMinutes(cwd = process.cwd()) {
   } catch { return undefined; }
 }
 
-/** forge.yaml `engine.path` (full|lean|auto) from the cwd checkout; undefined when absent or invalid. */
+/** forge.yaml `engine.path` (core|full|lean|auto) from the cwd checkout; undefined when absent or invalid. */
 export function readEnginePath(cwd = process.cwd()) {
   try {
     const v = String(parseForgeYaml(readFileSync(join(cwd, "forge.yaml"), "utf8"))?.engine?.path ?? "").trim();
@@ -98,7 +98,15 @@ function readLeanSetting(key, cwd = process.cwd()) {
     return /^[A-Za-z0-9._:[\]-]+$/.test(v) ? v : undefined;
   } catch { return undefined; }
 }
-export const ENGINE_PATHS = ["full", "lean", "auto"];
+// core is the default; lean and auto are aliases of core. full is the legacy multi-phase pipeline.
+/** forge.yaml `engine.merge_wait` (required|all|none); undefined when absent or invalid. */
+export function readMergeWait(cwd = process.cwd()) {
+  try {
+    const v = String(parseForgeYaml(readFileSync(join(cwd, "forge.yaml"), "utf8"))?.engine?.merge_wait ?? "").trim();
+    return ["required", "all", "none"].includes(v) ? v : undefined;
+  } catch { return undefined; }
+}
+export const ENGINE_PATHS = ["core", "full", "lean", "auto"];
 
 export function runDir() { return join(homedir(), ".forge", "runs"); }
 
@@ -395,7 +403,7 @@ export function lastLocalRun(dir) {
  *                          run's lease, wait (bounded by the lease TTL) until it
  *                          expires or its same-host pid is dead, then continue.
  *                          Without it, a held lease exits `deferred` (code 75).
- *   --path <full|lean|auto>  Optional (#4081). Engine path; overrides forge.yaml engine.path. Default full.
+ *   --path <core|full|lean|auto>  Engine path; overrides forge.yaml engine.path. Default core (lean work-on); lean/auto are aliases; full is the legacy multi-phase pipeline.
  *   --retry                Optional (forge#3511). Reopen a run that ended `engine-error`
  *                          (e.g. a session-limit hit) and resume from its last committed
  *                          phase. A run that ended `phase-complete` (multi-phase issue, phase merged,
@@ -419,9 +427,9 @@ export async function runFromCli(argv, deps = {}) {
   const pathFlag = flag(argv, "--path");
   if (argv.includes("--path") && (!pathFlag || pathFlag.startsWith("--"))) throw new Error(`--path requires a value: ${ENGINE_PATHS.join("|")}`);
   if (pathFlag && !ENGINE_PATHS.includes(pathFlag)) throw new Error(`--path must be one of ${ENGINE_PATHS.join("|")}`);
-  const enginePath = pathFlag ?? readEnginePath() ?? "full";
+  const enginePath = pathFlag ?? readEnginePath() ?? "core";
   if (enginePath !== "full" && (retry || waitLease)) {
-    throw new Error("--retry and --wait-lease are not supported with the lean path (a rerun resumes from the open PR or remote branch automatically); use --path full for them");
+    throw new Error("--retry and --wait-lease are not supported with the core path (a rerun resumes from the open PR or remote branch automatically); use --path full for them");
   }
   const io = deps.io ?? makeIo();
   await assertRepoMatchesCwd(io, repo);
@@ -451,20 +459,17 @@ export async function runFromCli(argv, deps = {}) {
     else if (e.event === "phase_paused") console.log(`⏸ phase ${e.phase} paused: ${e.detail ?? "session limit"}`);
   };
   if (enginePath !== "full") {
-    // #4081: lean path. `auto` escalates to the full pipeline only when the change is risky AND large.
+    // Core work-on (lean): one builder session, one reviewer, GitHub as the register.
     const leanRepo = repo ?? (await resolveDefaultRepo(io));
-    if (!leanRepo) throw new Error("lean path needs the repo: pass --repo or run inside a checkout with a GitHub remote");
-    const { runLean } = deps.leanModule ?? (await import("./lean/lean.mjs"));
+    if (!leanRepo) throw new Error("core path needs the repo: pass --repo or run inside a checkout with a GitHub remote");
+    const { runCore } = deps.leanModule ?? (await import("./lean/lean.mjs"));
     const leanIo = deps.leanIo ?? (await import("./lean/effects.mjs")).makeLeanIo({ repo: leanRepo });
-    const lres = await runLean({ issue, repo: leanRepo, lane, cwd: process.cwd(), dir, io: leanIo, path: enginePath, onProgress,
+    const lres = await runCore({ issue, repo: leanRepo, lane, cwd: process.cwd(), dir, io: leanIo, path: enginePath, onProgress,
       emitTelemetry: deps.emitTelemetry ?? makeEmitTelemetry({ repo: leanRepo }),
-      ...(model ? { builderModel: model } : {}), ...(readLeanSetting("reviewer_model") ? { reviewerModel: readLeanSetting("reviewer_model") } : {}) });
-    if (lres.terminalReason !== "route-full") {
-      console.log(`issue #${issue} → ${lres.terminalReason}`);
-      if (lres.terminalReason !== "merged") console.log(formatTerminalDiagnostics(dir, issue));
-      return lres;
-    }
-    console.log(`issue #${issue} → routing to the full pipeline (${lres.detail})`);
+      ...(readMergeWait() ? { mergeWait: readMergeWait() } : {}), ...(model ? { builderModel: model } : {}), ...(readLeanSetting("reviewer_model") ? { reviewerModel: readLeanSetting("reviewer_model") } : {}) });
+    console.log(`issue #${issue} → ${lres.terminalReason}`);
+    if (!["merged", "invalid"].includes(lres.terminalReason)) console.log(lres.detail ?? "");
+    return lres;
   }
   const res = await runIssueFn({ issue, dir, agentId, lane, io,
     ...(repo ? { repo } : {}),
@@ -623,3 +628,39 @@ export async function resumeStalledFromCli(argv, deps = {}) {
 }
 
 function flag(argv, name) { const i = argv.indexOf(name); return i >= 0 ? argv[i + 1] : null; }
+
+/**
+ * `forgedock orchestrate <issue...> [--parallel K] [--lane L] [--repo owner/repo]`
+ * Runs core work-on per issue with K concurrency (default 3), honouring `**Depends on**: #X` among the given issues.
+ * Prints a compact summary table. Lane defaults to staging.
+ */
+export async function orchestrateFromCli(argv, deps = {}) {
+  const valued = ["--parallel", "--lane", "--repo", "--model"];
+  const issues = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (valued.includes(argv[i])) { i++; continue; }
+    if (/^#?\d+$/.test(argv[i])) issues.push(parseInt(argv[i].replace("#", ""), 10));
+  }
+  if (!issues.length) throw new Error("usage: forgedock orchestrate <issue...> [--parallel K] [--lane L] [--repo owner/repo]");
+  const parallel = flag(argv, "--parallel") == null ? 3 : parseInt(flag(argv, "--parallel"), 10);
+  if (!Number.isInteger(parallel) || parallel < 1) throw new Error("--parallel must be a positive integer");
+  const lane = flag(argv, "--lane") ?? "staging";
+  const model = flag(argv, "--model");
+  const io = deps.io ?? makeIo();
+  const repo = flag(argv, "--repo") ?? (await resolveDefaultRepo(io));
+  if (!repo) throw new Error("orchestrate needs the repo: pass --repo or run inside a checkout with a GitHub remote");
+  const dir = deps.dir ?? runDir();
+  const { runCore } = deps.leanModule ?? (await import("./lean/lean.mjs"));
+  const { orchestrate, formatTable } = await import("./lean/orchestrate.mjs");
+  const leanIo = deps.leanIo ?? (await import("./lean/effects.mjs")).makeLeanIo({ repo });
+  const emitTelemetry = deps.emitTelemetry ?? makeEmitTelemetry({ repo });
+  const rows = await orchestrate({
+    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") } : {}) }),
+    onUpdate: (r) => console.log(`#${r.issue} → ${r.outcome}${r.detail && r.outcome !== "merged" ? ` (${r.detail})` : ""}`),
+  });
+  console.log("\n" + formatTable(rows));
+  return { rows, ok: rows.every((r) => ["merged", "invalid"].includes(r.outcome)) };
+}

package/bin/forgedock.mjs

@@ -3207,7 +3207,8 @@ function help() {
     ["npx forgedock disable [dir]", "Opt a directory out of ForgeDock"],
     ["npx forgedock status [dir]", "Show ForgeDock state for a directory"],
     ["npx forgedock run <cmd> [args]", "Run a command headlessly (local claude CLI or Anthropic API)"],
-    ["npx forgedock run-issue <issue> --lane <lane> [--path full|lean|auto] [--retry] [--wait-lease]", "Drive one issue through the durable engine (--retry reopens an engine-error run, or a needs-human run once the label is cleared; --wait-lease waits for a held lease; exit 75 = deferred, lease held)"],
+    ["npx forgedock run-issue <issue> --lane <lane> [--path core|full] [--retry] [--wait-lease]", "Run the lean core work-on on one issue (default; --path full = legacy multi-phase pipeline) (--retry reopens an engine-error run, or a needs-human run once the label is cleared; --wait-lease waits for a held lease; exit 75 = deferred, lease held)"],
+    ["npx forgedock orchestrate <issue...> [--parallel K] [--lane L]", "Run core work-on on several issues with bounded concurrency and Depends-on ordering"],
     ["npx forgedock resume-stalled [--dry-run]", "Fleet stall recovery — re-dispatch expired-lease issues"],
     ["npx forgedock demo", "Set up a risk-free demo repo and print next steps"],
     ["npx forgedock labels [setup] [--repo owner/repo]", "Bootstrap ForgeDock-managed labels on a GitHub repo (idempotent)"],
@@ -3781,10 +3782,10 @@ async function watch() {
 // The journey-routed commands render their own branded marks (hero/compact);
 // splash() would double-brand them. Engine-surface commands, help, and
 // unknown-command output keep the logo.
-const SPLASH_COMMANDS = new Set(["run", "run-issue", "resume-stalled", "demo", "doctor", "watch", "help", "--help", "-h"]);
+const SPLASH_COMMANDS = new Set(["run", "run-issue", "orchestrate", "resume-stalled", "demo", "doctor", "watch", "help", "--help", "-h"]);
 const KNOWN_COMMANDS = new Set([
   "install", "init", "enable", "disable", "status", "uninstall", "update",
-  "run", "backend-check", "run-issue", "resume-stalled", "demo", "doctor", "watch", "labels", "config", "stats", "help", "--help", "-h",
+  "run", "backend-check", "run-issue", "orchestrate", "resume-stalled", "demo", "doctor", "watch", "labels", "config", "stats", "help", "--help", "-h",
   "version", "--version", "-v",
 ]);
 if (SPLASH_COMMANDS.has(command) || !KNOWN_COMMANDS.has(command)) splash(command);
@@ -3982,6 +3983,17 @@ switch (command) {
     }
     break;
   }
+  case "orchestrate": {
+    const { orchestrateFromCli } = await import("./engine-cli.mjs");
+    try {
+      const result = await orchestrateFromCli(restArgs);
+      if (result && !result.ok) exitCode = 1;
+    } catch (err) {
+      process.stderr.write(`${RED}${err.message}${RESET}\n`);
+      exitCode = 1;
+    }
+    break;
+  }
   case "resume-stalled": {
     const { resumeStalledFromCli } = await import("./engine-cli.mjs");
     try {

package/bin/lean/effects.mjs

@@ -1,6 +1,6 @@
 // SPDX-FileCopyrightText: Copyright (c) RapierCraft Studios
 // SPDX-License-Identifier: AGPL-3.0-or-later
-/** Lean path (#4081): the real effects behind runLean's injected `io`. Argv only, no shell. */
+/** Core work-on: the real effects behind runCore's injected `io`. Argv only, no shell. */
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { readFileSync, appendFileSync, mkdirSync } from "node:fs";
@@ -13,34 +13,39 @@ import { makeProjector } from "../engine/projector.mjs";
 const pexec = promisify(execFile);
 const script = (n) => fileURLToPath(new URL(`../../scripts/${n}`, import.meta.url));
 
-/** Claude CLI session runner: fresh session, or `--resume <id>` for the warm builder. Resolves usage + session_id. */
+/** Claude CLI session runner: fresh session, or `--resume <id>` for the builder. Resolves usage + session_id. */
 export function makeLeanRunner({ runCli = runCliBackend } = {}) {
   return async ({ role, issue, cwd, model, resume, system, prompt, readOnly = false }) => {
     const bin = resolveClaudeCliBinary(cwd) || "claude";
     const caps = getClaudeCliCapabilities(cwd);
     const flags = [...buildLeanSessionFlags(caps), ...(readOnly ? buildReadOnlyToolFlags(caps) : [])];
-    const r = runCli({ spec: { name: `lean-${role}` }, userMessage: prompt, systemPrompt: resume ? "" : system,
+    const r = runCli({ spec: { name: `core-${role}` }, userMessage: prompt, systemPrompt: resume ? "" : system,
       args: [String(issue)], cwd, bin, model, sessionFlags: flags, extraArgs: resume ? ["--resume", resume] : [],
       logger: { log() {} } });
     return { text: r.text, sessionId: r.sessionId, usage: r.usage, costUsd: r.costUsd, durationMs: r.durationMs, turns: r.turns, model: r.cliModel ?? "default" };
   };
 }
 
-/** A missing or unparseable CI_LOCAL_RESULT means the gate itself is broken (BROKEN); only an explicit DEGRADED passes. */
-export function parseCiLocalResult(out) {
-  return /CI_LOCAL_RESULT:\s*(PASS|FAIL|DEGRADED)\b/.exec(String(out))?.[1] ?? "BROKEN";
-}
-
 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"), projector: makeProjector({ gh: base.gh }), runner: makeLeanRunner(), waitCiGreen: base.waitCiGreen,
-    async ciLocal({ cwd, base: baseRef }) {
-      let out = "";
-      try { out = (await pexec("bash", [script("ci-local.sh"), "run", "--repo", cwd, "--base", baseRef], { maxBuffer: 50 * 1024 * 1024, timeout: 3600000 })).stdout; }
-      catch (e) { out = String(e.stdout ?? "") + String(e.stderr ?? ""); }
-      return { result: parseCiLocalResult(out), tail: out.split("\n").slice(-60).join("\n") };
+    /** Names of the checks the base branch requires (contexts + checks). [] on 404 / no protection. */
+    async requiredChecks(lane) {
+      try {
+        const j = JSON.parse(await run("gh")(["api", `repos/${repo}/branches/${lane}/protection/required_status_checks`]));
+        return [...new Set([...(j.contexts ?? []), ...(j.checks ?? []).map((c) => c.context)].filter(Boolean))];
+      } catch { return []; }
+    },
+    /** [{name, state: success|failure|pending}] for the PR's checks. */
+    async checkStates(pr) {
+      const j = JSON.parse(await run("gh")(["pr", "view", String(pr), "-R", repo, "--json", "statusCheckRollup"]));
+      return (j.statusCheckRollup ?? []).map((c) => {
+        const v = String(c.conclusion || c.state || "").toUpperCase();
+        const state = ["SUCCESS", "NEUTRAL", "SKIPPED"].includes(v) ? "success" : ["FAILURE", "ERROR", "TIMED_OUT", "CANCELLED", "ACTION_REQUIRED", "STARTUP_FAILURE"].includes(v) ? "failure" : "pending";
+        return { name: c.name ?? c.context, state };
+      });
     },
     async transitionLabel(issue, state) { await pexec("bash", [script("transition-label.sh"), String(issue), "-R", repo, state], { timeout: 60000 }); },
     fs: {