forgedock 1.23.0 → 1.23.1

package/bin/engine/outcome-codes.mjs

@@ -44,6 +44,13 @@ export const OUTCOME_CODES = Object.freeze({
   DEPENDENCY_UNREADABLE: "dependency.unreadable",
   INVALID: "invalid",
   DECOMPOSED: "decomposed",
+  // Lean core work-on (bin/lean) needs-human causes.
+  BUILDER_BLOCKED: "builder.blocked",
+  BUILDER_NO_EVIDENCE: "builder.no_evidence",
+  BUILDER_NO_COMMIT: "builder.no_commit",
+  REVIEW_FAILED: "review.failed",
+  REVIEW_NO_VERDICT: "review.no_verdict",
+  MERGE_HEAD_MISMATCH: "merge.head_mismatch",
   // Non-failure terminals, so a RUN_TERMINAL for a healthy run is not counted as a gap.
   COMPLETED: "completed",
   AWAITING_MERGE: "awaiting_merge",
@@ -115,7 +122,9 @@ export function codeForTerminalReason(reason) {
     case "phase-complete":
     case "investigation":
       return OUTCOME_CODES.COMPLETED;
-    case "awaiting-merge": return OUTCOME_CODES.AWAITING_MERGE;
+    case "awaiting-merge":
+    case "ci-pending":
+      return OUTCOME_CODES.AWAITING_MERGE;
     case "invalid": return OUTCOME_CODES.INVALID;
     case "decomposed": return OUTCOME_CODES.DECOMPOSED;
     case "engine-error": return OUTCOME_CODES.ENGINE_ERROR;

package/bin/lean/lean.mjs

@@ -76,9 +76,9 @@ export async function runCore(o) {
   }
 
   let done = null, wtCreated = false;
-  async function finish(reason, detail = "", extra = {}) {
+  async function finish(reason, detail = "", extra = {}, codeOverride = null) {
     if (done) return done; // idempotent: exactly one RUN_TERMINAL and one telemetry emit
-    const code = codeForTerminalReason(reason);
+    const code = codeOverride ?? codeForTerminalReason(reason);
     ev({ event: "RUN_TERMINAL", reason, code });
     await emit({ event: "RUN_TERMINAL", reason, code });
     if (["needs-human", "engine-error"].includes(reason)) {
@@ -93,12 +93,12 @@ export async function runCore(o) {
     done = { terminalReason: reason, detail, branch, worktree: wt, cost_usd: usage.cost_usd, tokens: { input: usage.input, output: usage.output, cache: usage.cache }, wall_ms: now() - t0, ...extra };
     return done;
   }
-  async function needsHuman(why) {
+  async function needsHuman(why, code = OUTCOME_CODES.ENGINE_ERROR) {
     try {
       await post("FORGE:NEEDS_HUMAN", `## Needs human\n${why}\n\n_${usageLine()}_`);
       await ghc(["issue", "edit", String(issue), "-R", repo, "--add-label", "needs-human"]);
     } catch { /* best effort */ }
-    return finish("needs-human", why);
+    return finish("needs-human", why, { code }, code);
   }
 
   async function builder(n, prompt, resume) {
@@ -178,7 +178,7 @@ export async function runCore(o) {
       const evidence = (Array.isArray(result?.evidence) ? result.evidence : []).filter((x) => typeof x === "string" && x.trim());
       const verdict = result ? (result.status === "fixed" ? "valid" : result.status) : null;
       const closing = ["invalid", "already-fixed"].includes(result?.status);
-      if (closing && !evidence.length) return await needsHuman(`Builder reported "${result.status}" without evidence, so the issue is not closed automatically.\n\n${result.summary ?? "(no summary)"}`);
+      if (closing && !evidence.length) return await needsHuman(`Builder reported "${result.status}" without evidence, so the issue is not closed automatically.\n\n${result.summary ?? "(no summary)"}`, OUTCOME_CODES.BUILDER_NO_EVIDENCE);
       // The validation comment (no model call): verdict, evidence, one-line summary. For invalid/already-fixed it IS the evidence comment.
       if (verdict) validateUrl = await post("FORGE:VALIDATE", renderValidate(result, verdict));
       if (closing) {
@@ -186,8 +186,8 @@ export async function runCore(o) {
         await label("invalid");
         return await finish("invalid", result.summary ?? result.status);
       }
-      if (result?.status === "blocked") return await needsHuman(`Builder is blocked: ${result.summary ?? "(no summary)"}`);
-      if (!files0.length) return await needsHuman(`Builder made no commit${result ? ` (status "${result.status}")` : " and wrote no result.json"}.\n\n${result?.summary ?? ""}`);
+      if (result?.status === "blocked") return await needsHuman(`Builder is blocked: ${result.summary ?? "(no summary)"}`, OUTCOME_CODES.BUILDER_BLOCKED);
+      if (!files0.length) return await needsHuman(`Builder made no commit${result ? ` (status "${result.status}")` : " and wrote no result.json"}.\n\n${result?.summary ?? ""}`, OUTCOME_CODES.BUILDER_NO_COMMIT);
       planUrl = await post("FORGE:PLAN", renderPlan(result, files0));
     }
 
@@ -208,14 +208,14 @@ export async function runCore(o) {
       return null;
     };
     review = await doReview();
-    if (!review) return await needsHuman("Reviewer returned no parseable verdict twice.");
+    if (!review) return await needsHuman("Reviewer returned no parseable verdict twice.", OUTCOME_CODES.REVIEW_NO_VERDICT);
     if (review.fail) {
-      if (!sessionId) return await needsHuman(`Review FAIL and the builder session id is unknown, cannot resume: ${review.reason}`);
+      if (!sessionId) return await needsHuman(`Review FAIL and the builder session id is unknown, cannot resume: ${review.reason}`, OUTCOME_CODES.REVIEW_FAILED);
       await builder(++attemptN, resumeBuilderPrompt(review.reason), sessionId);
       result = (await readResult()) ?? result;
       review = await doReview();
-      if (!review) return await needsHuman("Reviewer returned no parseable verdict twice (re-review).");
-      if (review.fail) return await needsHuman(`Review FAIL twice. Last reason: ${review.reason}`);
+      if (!review) return await needsHuman("Reviewer returned no parseable verdict twice (re-review).", OUTCOME_CODES.REVIEW_NO_VERDICT);
+      if (review.fail) return await needsHuman(`Review FAIL twice. Last reason: ${review.reason}`, OUTCOME_CODES.REVIEW_FAILED);
     }
     reviewUrl = await post("FORGE:REVIEW", renderReview(review));
     ev({ event: "PHASE_COMMIT", phase: "review" });
@@ -251,13 +251,13 @@ export async function runCore(o) {
         if (policy === "all") {
           const w = await io.waitCiGreen(pr, repo, 0).catch(() => ({ rc: 2, text: "" }));
           if (w.rc === 0) { gateHead = /CI_GATE_HEAD:\s*([0-9a-f]{7,40})/.exec(w.text ?? "")?.[1] ?? null; break; }
-          if (w.rc === 1) return await needsHuman(`Remote CI failed on PR #${pr}:\n${String(w.text).slice(-2000)}`);
+          if (w.rc === 1) return await needsHuman(`Remote CI failed on PR #${pr}:\n${String(w.text).slice(-2000)}`, OUTCOME_CODES.CI_RED);
         } else {
           let states = [];
           try { states = (await io.checkStates(pr)) ?? []; } catch { states = []; }
           const st = (n) => states.find((x) => x.name === n)?.state ?? "pending";
           const failed = required.filter((n) => st(n) === "failure");
-          if (failed.length) return await needsHuman(`Required check(s) failed on PR #${pr}: ${failed.join(", ")}`);
+          if (failed.length) return await needsHuman(`Required check(s) failed on PR #${pr}: ${failed.join(", ")}`, OUTCOME_CODES.CI_RED);
           if (required.every((n) => st(n) === "success")) break;
         }
         if (now() - startedAt >= ciMaxMinutes * 60000) {
@@ -269,7 +269,7 @@ export async function runCore(o) {
         await sleep(ciPollDelayMs(pollIndex++, random));
       }
       if (gateHead && !(localHead.startsWith(gateHead) || gateHead.startsWith(localHead))) {
-        return await needsHuman(`CI passed for ${gateHead.slice(0, 12)} but the reviewed head is ${localHead.slice(0, 12)}; refusing to merge an unreviewed head.`);
+        return await needsHuman(`CI passed for ${gateHead.slice(0, 12)} but the reviewed head is ${localHead.slice(0, 12)}; refusing to merge an unreviewed head.`, OUTCOME_CODES.MERGE_HEAD_MISMATCH);
       }
     }
     await ghc(["pr", "merge", String(pr), "-R", repo, "--merge", "--match-head-commit", localHead]);

package/bin/lean/lean.test.mjs

@@ -194,6 +194,20 @@ describe("core work-on", () => {
     assert.equal((await run(world({ changed: [] }))).terminalReason, "needs-human");
   });
 
+  it("needs-human terminals carry a specific outcome code, never unclassified", async () => {
+    const code = async (w, extra) => {
+      const dir = tmpDir("lean-code-");
+      const r = await run(w, { dir, ...extra });
+      const term = readLog(dir, 7).filter((e) => e.event === "RUN_TERMINAL");
+      assert.equal(term.length, 1);
+      assert.equal(term[0].code, r.code);
+      return term[0].code;
+    };
+    assert.equal(await code(world({ result: { status: "blocked", summary: "need creds" } })), "builder.blocked");
+    assert.equal(await code(world({ changed: [] })), "builder.no_commit");
+    assert.equal(await code(world({ waits: [{ rc: 1, text: "lint failed" }] }), { mergeWait: "all" }), "ci.red");
+  });
+
   it("red remote CI is needs-human; slow CI polls with backoff and ends ci-pending, never needs-human", async () => {
     const w = world({ waits: [{ rc: 1, text: "lint failed" }] });
     assert.equal((await run(w, { mergeWait: "all" })).terminalReason, "needs-human");

package/commands/orchestrate.md

@@ -43,14 +43,17 @@ Do this yourself from issue text and the code. Spawn no sub-agents here.
    - **Logical:** one issue's fix is needed by another (for example, it adds the helper the other uses).
 
    If you find a cycle, break it at the weakest (conflict) edge and say so.
-4. **Show the plan** as one table: issue, title, size, likely files, waits-on, wave. Then proceed
+4. **Show the plan** as one table: issue, title, size, likely files, waits-on. There are no waves. Then proceed
    without asking.
 
 `K` = `--parallel` (default 3). `L` = `--lane` if given, otherwise the repo's base lane from forge.yaml.
 
 ## 3. Launch lanes
 
-Keep at most K lanes running. Start issues in DAG order: every issue whose waits-on have all merged.
+Schedule from the DAG, not in waves. An issue is **ready** when every issue it waits on has merged (or it
+waits on nothing). Keep at most K lanes running. Whenever a lane is free, start the highest-priority ready
+issue right away (priority label first, then the smaller size). Never hold a ready issue back until other
+lanes finish.
 
 - **Shell lane (default, when `forgedock` is on PATH).** One `Bash` call per issue with
   `run_in_background: true`:

package/docs/OUTCOME-CODES.md

@@ -43,6 +43,12 @@ An absent or unknown code is recorded as `unclassified`, with the raw reason kep
 | `dependency.unreadable` | The issue body or a declared dependency could not be read, so the run was refused (fail closed) | engine | Failed or unparsable `gh api` read |
 | `invalid` | Issue is invalid or in a divergent closed state | investigate, engine | `INVESTIGATION:INVALID` marker, or live snapshot |
 | `decomposed` | Issue was decomposed into sub-issues | investigate, decompose | `FORGE:DECOMPOSED` or the decomposition assessment |
+| `builder.blocked` | Core work-on: the builder reported it cannot proceed without a human decision (design, credentials, infra) | lean | `result.json` status `blocked` |
+| `builder.no_evidence` | Core work-on: the builder reported invalid/already-fixed without file:line evidence, so the issue was not closed | lean | `result.json` with empty `evidence` |
+| `builder.no_commit` | Core work-on: the builder made no commit for a fix | lean | No changed files after the builder session |
+| `review.failed` | Core work-on: the fix/regression review failed twice (or could not resume the builder) | lean | Reviewer verdict FAIL |
+| `review.no_verdict` | Core work-on: the reviewer returned no parseable verdict twice | lean | Unparsable reviewer output |
+| `merge.head_mismatch` | Core work-on: CI passed for a head other than the reviewed head; merge refused | lean | Gate head differs from the reviewed head |
 | `completed` | Non-failure terminal (merged, phase-complete, investigation) | engine | Terminal reason |
 | `awaiting_merge` | Clean result held for a merge decision | remediate | Terminal reason `awaiting-merge` |
 | `unclassified` | Fallback for an absent or unknown code | engine | The raw reason is kept alongside |

package/package.json

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