forgedock 1.7.1 → 1.8.0

package/bin/engine/phases.mjs

@@ -116,6 +116,23 @@ async function commitsAhead(lane, branch, io) {
  */
 function has(blob, marker) { return blob.includes(marker); }
 
+/**
+ * The interactive workflow persists its conservative complexity decision in a
+ * FORGE:FAST_PATH comment. The engine must consume that decision too; otherwise
+ * its separate context/architect phases negate the documented trivial path.
+ * Only an exact TRIVIAL value is eligible to skip work, so malformed or absent
+ * annotations continue through the full pipeline.
+ */
+function complexityBand(comments) {
+  for (let i = comments.length - 1; i >= 0; i--) {
+    const body = comments[i];
+    if (!body?.includes("FORGE:FAST_PATH")) continue;
+    const match = body.match(/\*\*COMPLEXITY_BAND\*\*:\s*([A-Z_]+)/);
+    if (match) return match[1];
+  }
+  return null;
+}
+
 /**
  * Fetch the issue's live `state` (OPEN/CLOSED) and `labels` in one call.
  *
@@ -254,10 +271,13 @@ export const PHASES = [
     command: "work-on/build/context",
     entryCondition: (s) => s.committed.includes("investigate"),
     async reconcile(state, io) {
+      const markers = await issueMarkers(state.issue, io);
+      if (complexityBand(markers.comments) === "TRIVIAL") {
+        return { satisfied: true, outputs: { skipped: "trivial-complexity-band", phase: "context" } };
+      }
       // Idempotent resume: FORGE:CONTEXT:COMPLETE present → skip the LLM re-run.
       // Bare FORGE:CONTEXT matches a partial/interrupted annotation — require :COMPLETE.
-      const { blob } = await issueMarkers(state.issue, io);
-      return has(blob, PHASE_MARKERS.context.completionMarker) ? { satisfied: true } : { satisfied: false };
+      return has(markers.blob, PHASE_MARKERS.context.completionMarker) ? { satisfied: true } : { satisfied: false };
     },
     async detectOutcome(state, io) {
       const { blob } = await issueMarkers(state.issue, io);
@@ -271,10 +291,13 @@ export const PHASES = [
     command: "work-on/build/architect",
     entryCondition: (s) => s.committed.includes("context"),
     async reconcile(state, io) {
+      const markers = await issueMarkers(state.issue, io);
+      if (complexityBand(markers.comments) === "TRIVIAL") {
+        return { satisfied: true, outputs: { skipped: "trivial-complexity-band", phase: "architect" } };
+      }
       // Idempotent resume: FORGE:ARCHITECT:COMPLETE present → skip the LLM re-run.
       // Bare FORGE:ARCHITECT matches a partial/interrupted annotation — require :COMPLETE.
-      const { blob } = await issueMarkers(state.issue, io);
-      return has(blob, PHASE_MARKERS.architect.completionMarker) ? { satisfied: true } : { satisfied: false };
+      return has(markers.blob, PHASE_MARKERS.architect.completionMarker) ? { satisfied: true } : { satisfied: false };
     },
     async detectOutcome(state, io) {
       const { blob } = await issueMarkers(state.issue, io);
@@ -356,7 +379,7 @@ export const PHASES = [
       if (!pr) return { status: "failed", detail: "no PR created" };
       if (pr.merged) return { status: "committed", outputs: { pr: pr.number } };
       if (pr.needsHuman) return { status: "blocked", detail: "review escalated", outputs: { pr: pr.number } };
-      return { status: "failed", detail: "PR open, not merged" };
+      return { status: "failed", detail: "PR open, not merged", retryable: false };
     },
   },
   {
@@ -370,23 +393,9 @@ export const PHASES = [
     // phase table (closing the literal "remediate appears nowhere in the
     // engine" gap) and is fully unit-tested via `pickPhase`/`detectOutcome`.
     //
-    // KNOWN LIMITATION (documented, not fixed here — see forge#2379
-    // investigation "What We Found"): `review`'s `"blocked"` outcome (the
-    // needs-human escalation) causes `bin/engine.mjs`'s `runIssue()` to
-    // `terminate()` immediately, before `review` is ever added to
-    // `state.committed` — and the divergence guard just above that also
-    // pauses before any non-`close` phase once the issue carries
-    // `needs-human`. So a single continuous `runIssue()` walk cannot reach
-    // this phase's `entryCondition` today. In practice `remediate.md` is
-    // (correctly, per `work-on.md` Phase 0A.1) invoked as its own separate
-    // top-level entry point (`/work-on <pr> --remediate`), not as a
-    // continuation of the original run — this phase entry documents and
-    // tests the target state shape for a future run that reconstructs
-    // `committed`/`terminalReason` from live GitHub state (e.g. a dedicated
-    // remediation-run entry point) rather than from a fresh local run-log.
-    // Making that live wiring real is out of this issue's scope — it needs
-    // changes to `review`'s `"blocked"` contract and to `bin/tests/engine.test.mjs`,
-    // both outside this issue's declared file set.
+    // A blocked review is committed with terminalReason "needs-human" before
+    // the engine selects this phase, preserving the review verdict while
+    // handing the PR to remediation in the same run.
     id: "remediate",
     command: "work-on/remediate",
     entryCondition: (s) => s.committed.includes("review") && s.terminalReason === "needs-human",

package/bin/engine/resolve.mjs

@@ -94,7 +94,14 @@
  * @returns {ClassifiedInput}
  */
 export function classifyInputPattern(input) {
-  const trimmed = (input ?? "").trim();
+  // Orchestration control flags authorize or tune the dispatcher; they are not
+  // part of the issue-set predicate. Strip them here so a confirmed OpenCode
+  // fast path and the full shared resolver classify the same query.
+  const trimmed = String(input ?? "")
+    .replace(/(?:^|\s)(?:--auto|--confirm|--deep-plan)(?=\s|$)/gi, " ")
+    .replace(/(?:^|\s)--max-concurrent(?:=|\s+)[1-9]\d*(?=\s|$)/gi, " ")
+    .replace(/\s+/g, " ")
+    .trim();
   const tokens = trimmed.length > 0 ? trimmed.split(/\s+/) : [];
 
   // literal-numbers: every token is a bare integer or a (optionally

package/bin/engine/resolve.test.mjs

@@ -55,6 +55,11 @@ describe("classifyInputPattern — query patterns", () => {
     assert.equal(classifyInputPattern("fast-lane").kind, "query");
   });
 
+  it("ignores orchestration control flags when classifying the issue predicate", () => {
+    assert.equal(classifyInputPattern("fast-lane --auto --max-concurrent 4").pattern, "fast-lane");
+    assert.equal(classifyInputPattern("1 2 --confirm").kind, "literal");
+  });
+
   it("classifies priority:P0 / priority:P1 as a query (both label schemas, forge#2232)", () => {
     assert.equal(classifyInputPattern("priority:P0").pattern, "priority");
     assert.equal(classifyInputPattern("priority:P1").kind, "query");

package/bin/engine.mjs

@@ -331,7 +331,9 @@ export async function runIssue(opts) {
         // the same reason composes with that existing contract instead of
         // conflating "paused pending a human" with "dead". Deliberately does
         // NOT check `workflow:invalid`/CLOSED here — those are handled above.
-        if (snap.labels.includes("needs-human")) {
+        // A blocked review is deliberately handed to remediation in this same
+        // run. All other needs-human states remain paused for human action.
+        if (snap.labels.includes("needs-human") && phase.id !== "remediate") {
           const detail = `issue ${issue} carries needs-human — pausing before phase ${phase.id}`;
           return await terminate(state, "needs-human", detail);
         }
@@ -520,21 +522,24 @@ export async function runIssue(opts) {
       }
     }
 
+    const isRemediationHandoff = outcome.status === "blocked" &&
+      phase.id === "review" && (outcome.reason || "needs-human") === "needs-human";
     if (outcome.status === "blocked") {
       emitProgress({ event: "phase_exit", phase: phase.id, status: "blocked", detail: outcome.detail });
-      return await terminate(state, outcome.reason || "needs-human", outcome.detail);
+      if (!isRemediationHandoff)
+        return await terminate(state, outcome.reason || "needs-human", outcome.detail);
+    } else {
+      // committed
+      // forge#2321: only report a phase_exit if a matching phase_enter was
+      // actually emitted for this phase this iteration. A reconcile-satisfied
+      // phase (short-circuited above without ever entering the `else` branch)
+      // never "started" this run — emitting phase_exit for it produced a
+      // dangling exit with no preceding enter (bin/engine-cli.mjs prints
+      // "✓ phase X committed" with no prior "→ phase X started" line).
+      // Suppressing the unmatched exit is correct here rather than fabricating
+      // a synthetic phase_enter, since the phase's runner genuinely never ran.
+      if (phaseEntered) emitProgress({ event: "phase_exit", phase: phase.id, status: "committed" });
     }
-
-    // committed
-    // forge#2321: only report a phase_exit if a matching phase_enter was
-    // actually emitted for this phase this iteration. A reconcile-satisfied
-    // phase (short-circuited above without ever entering the `else` branch)
-    // never "started" this run — emitting phase_exit for it produced a
-    // dangling exit with no preceding enter (bin/engine-cli.mjs prints
-    // "✓ phase X committed" with no prior "→ phase X started" line).
-    // Suppressing the unmatched exit is correct here rather than fabricating
-    // a synthetic phase_enter, since the phase's runner genuinely never ran.
-    if (phaseEntered) emitProgress({ event: "phase_exit", phase: phase.id, status: "committed" });
     // forge#2377: `outcome.usage` is populated by runPhaseWithRetry() below
     // from the injected runner()'s (== bin/runner.mjs's runCommand()) return
     // value — null when the backend doesn't report usage (CLI backend today)
@@ -544,7 +549,10 @@ export async function runIssue(opts) {
     // owned by phase.detectOutcome() (bin/engine/phases.mjs).
     appendEvent(dir, issue, { event: "PHASE_COMMIT", phase: phase.id, outputs: outcome.outputs || {}, usage: outcome.usage ?? null });
     state = deriveState(readLog(dir, issue));
-    if (outcome.terminalReason) state.terminalReason = outcome.terminalReason;
+    const terminalReason = outcome.status === "blocked"
+      ? (outcome.reason || "needs-human")
+      : outcome.terminalReason;
+    if (terminalReason) state.terminalReason = terminalReason;
     await projector.writeState(issue, { ...state, lease: { by: agentId, until: now() + leaseTtlMs } });
 
     // forge#2379: the "investigate" phase reporting terminalReason "decomposed"
@@ -564,9 +572,10 @@ export async function runIssue(opts) {
     // is seen), phase.id is "decompose" — not "investigate" — so this
     // exemption does not apply and the normal terminate() path below fires,
     // ending the run for real.
-    const isDecomposeHandoff = phase.id === "investigate" && outcome.terminalReason === "decomposed";
-    if (outcome.terminalReason && TERMINAL_REASONS.includes(outcome.terminalReason) && !isDecomposeHandoff)
-      return await terminate(state, outcome.terminalReason);
+    const isDecomposeHandoff = phase.id === "investigate" && terminalReason === "decomposed";
+    if (terminalReason && TERMINAL_REASONS.includes(terminalReason) &&
+        !isDecomposeHandoff && !isRemediationHandoff)
+      return await terminate(state, terminalReason, outcome.detail);
     if (phase.isTerminalAfter && phase.isTerminalAfter(state))
       return await terminate(state, state.terminalReason || "merged");
   }

package/bin/forgedock.mjs

@@ -1417,7 +1417,7 @@ async function relinkAndHint() {
   // version-check path), so wiring it here covers "refreshed after every
   // successful update" without duplicating the call at each branch. Note:
   // this is NOT reached by install's already-managed-active short-circuit
-  // (that path calls statusScreen(), never relinkAndHint()) — see the
+  // (that path is also used by managed-active install) — see the
   // writeInstallReceipt() JSDoc in journey.mjs for the full picture.
   await writeInstallReceipt(c, { forged });
   await refreshManagedOpenCodeAdapter();
@@ -2416,6 +2416,16 @@ async function doctor(fix = false) {
                 broken++;
                 brokenLinks.push(rel);
                 symlinkOk = false;
+              } else {
+                try {
+                  // readlink() only validates the stored target. Opening the
+                  // link also catches platform-specific traversal failures.
+                  readFileSync(tgt);
+                } catch {
+                  broken++;
+                  brokenLinks.push(`${rel} (unreadable — link resolves but cannot be traversed)`);
+                  symlinkOk = false;
+                }
               }
             } else {
               // Regular file — copy-mode install (Windows without Developer Mode).
@@ -3266,6 +3276,7 @@ function help() {
  *   FORGEDOCK_BACKEND      Default backend ("cli"|"api"|"auto") when --backend is omitted.
  *   FORGEDOCK_MODEL        Default model id when --model is omitted.
  *   FORGEDOCK_CLI_TIMEOUT_MS  Wall-clock timeout (ms) for the cli backend invocation.
+ *                              Overrides forge.yaml pipeline.cli_timeout_minutes.
  *   FORGEDOCK_SHELL        Override the shell used by run_bash / the cli backend.
  *                          Defaults to bash when found (Git Bash / WSL on
  *                          Windows, /bin/bash on POSIX), falling back to the
@@ -3808,7 +3819,9 @@ switch (command) {
       }
     }
     if (existsSync(join(c.cwd, "forge.yaml")) && resolveState(c.cwd) === "managed-active") {
-      await statusScreen(c);
+      // A configured directory may still have missing commands after uninstall.
+      // Refresh managed files without re-running the configuration journey.
+      await relinkAndHint();
     } else {
       exitCode = await runJourney(c);
       // Record persistHome()'s outcome (set on c.persistHomeResult inside