forgedock 1.38.0 → 1.39.0

package/bin/engine/projector.mjs

@@ -14,12 +14,16 @@ export const MAX_LEASE_TTL_MS = 3 * 600_000;
 const PROVENANCE_QUERY = "query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){"
   + "issue(number:$number){body authorAssociation author{login __typename} editor{login __typename}}}}";
 
-export function makeProjector(io) {
+export function makeProjector(io, { repo } = {}) {
   const gh = io.gh;
 
+  // Throws on an unreadable body: an empty string would make writeState wipe the issue (#4860).
   async function getBody(issue) {
-    const out = await gh(["issue", "view", String(issue), "--json", "body"]);
-    try { return JSON.parse(out).body ?? ""; } catch { return ""; }
+    const out = await gh(["issue", "view", String(issue), "--json", "body", ...(repo ? ["-R", repo] : [])]);
+    let body;
+    try { body = JSON.parse(out).body; } catch { throw new Error(`issue #${issue}: body read returned non-JSON output`); }
+    if (typeof body !== "string") throw new Error(`issue #${issue}: body read returned no body`);
+    return body;
   }
 
   /**
@@ -64,16 +68,21 @@ export function makeProjector(io) {
     },
 
     async writeState(issue, index) {
-      const body = upsertStateBlock(await getBody(issue), index);
-      await gh(["issue", "edit", String(issue), "--body", body]);
+      const old = await getBody(issue);
+      const body = upsertStateBlock(old, index);
+      // Each run of issue text around a FORGE:STATE block must survive on its own: the block is replaced in place, so text
+      // before and after it stays apart and a joined string would never match (#4871).
+      const dropped = old.split(/<!-- FORGE:STATE\s*[\s\S]*?-->/).map((t) => t.trim()).filter(Boolean).some((t) => !body.includes(t));
+      if (dropped) throw new Error(`issue #${issue}: refusing a state write that drops existing issue text`);
+      await gh(["issue", "edit", String(issue), "--body", body, ...(repo ? ["-R", repo] : [])]);
     },
 
     async setLabel(issue, label) {
-      await gh(["issue", "edit", String(issue), "--add-label", label]);
+      await gh(["issue", "edit", String(issue), "--add-label", label, ...(repo ? ["-R", repo] : [])]);
     },
 
     async removeLabel(issue, label) {
-      await gh(["issue", "edit", String(issue), "--remove-label", label]);
+      await gh(["issue", "edit", String(issue), "--remove-label", label, ...(repo ? ["-R", repo] : [])]);
     },
   };
 }

package/bin/engine/telemetry-seam.mjs

@@ -9,6 +9,7 @@
  *                          builder_tier/class/model/escalated 0|1, forge#4394)
  *   SANDBOX_USAGE       -> `sandbox_usage` (provider, sandbox_id, minutes, cost_usd, batch; one per settled remote lane, forge#4255)
  *   DECISION_ENGINE     -> `decision_engine` (decided, escalated, vetoed, reversed, mode, needs_human_before/after; forge#4766)
+ *   PRODWATCH_METRICS   -> `prodwatch_metrics` (source, sample, invalid, fp_rate, fix_ineffective_rate, recurrence_rate, signal_to_issue/merge/verified_ms; forge#4837)
  *   STRUCTURE_DELTA     -> `structure_delta` (edges_added/removed, import_files_added/removed, boundary_changed/loosened 0|1; forge#4159)
  *                          lean's merge-time record (forge#4165) adds milestone, the pr and string lists: deps_added and
  *                          new_edges / removed_edges as "from:to" comma-joined, top_growth "file+N", decisions "K1:lint",
@@ -84,6 +85,11 @@ export function mapRecord(rec, wallMs) {
     return { event: "decision_engine", phase: null, payload: compact({ decided: rec.decided, escalated: rec.escalated, vetoed: rec.vetoed, reversed: rec.reversed, mode: rec.mode,
       needs_human_before: rec.needs_human_before, needs_human_after: rec.needs_human_after }) };
   }
+  if (rec.event === "PRODWATCH_METRICS") { // #4837
+    return { event: "prodwatch_metrics", phase: null, payload: compact({ source: rec.source, sample: rec.sample, invalid: rec.invalid, fix_ineffective: rec.fix_ineffective, recurred: rec.recurred,
+      fp_rate: rec.fp_rate, fix_ineffective_rate: rec.fix_ineffective_rate, recurrence_rate: rec.recurrence_rate,
+      signal_to_issue_ms: rec.signal_to_issue_ms, signal_to_merge_ms: rec.signal_to_merge_ms, signal_to_verified_ms: rec.signal_to_verified_ms }) };
+  }
   if (rec.event === "CI_PENDING_WAIT") {
     return { event: "ci_pending_wait", phase: rec.phase ?? "review", payload: compact({ pr: rec.pr, minutes_waited: rec.minutes_waited, result: rec.result, polls: rec.polls, rate_limit_sleeps: rec.rate_limit_sleeps }) };
   }

package/bin/engine/telemetry-seam.test.mjs

@@ -27,6 +27,12 @@ describe("engine telemetry seam", () => {
     assert.equal("baseline_tokens" in q, false); assert.equal("lane_profile" in q, false);
   });
 
+  it("forge#4837: PRODWATCH_METRICS maps to prodwatch_metrics, absent values omitted", () => {
+    const m = mapRecord({ event: "PRODWATCH_METRICS", source: "memo", sample: 7, fp_rate: 0.25, signal_to_issue_ms: 1000, signal_to_merge_ms: null }, 0);
+    assert.equal(m.event, "prodwatch_metrics");
+    assert.deepEqual(m.payload, { source: "memo", sample: 7, fp_rate: 0.25, signal_to_issue_ms: 1000 });
+  });
+
   it("forge#4257: phase_attempt carries the backend, omitted when unreported", () => {
     assert.equal(mapRecord({ event: "PHASE_ATTEMPT_USAGE", phase: "build", attempt: 1, backend: "api" }, 0).payload.backend, "api");
     // #4407: the per-attempt cost and the session running total ride along; absent fields are omitted

package/bin/engine-cli.mjs

@@ -23,6 +23,7 @@ import { makeEventEmitter, probeSweepEvents, experimentEvent } from "./engine/ev
 import { readExperiment } from "./experiment.mjs";
 import { readBranches, resolveLane, isDefaultLane } from "./lean/lane.mjs";
 import { parseVerify } from "./lean/verify.mjs";
+import { viewIssue } from "./lean/gh-assoc.mjs";
 import { parseExecution, detectNeeds, placementText } from "./lean/execution.mjs";
 import { relayPrefetchCommands } from "./lean/relay.mjs";
 import { parseTurnBudgets, formatTurnSummary, TURN_BUDGET_DEFAULTS } from "./lean/budget.mjs";
@@ -288,6 +289,13 @@ export async function readPostDeployMinAge(cwd = process.cwd()) {
 export function readMilestoneCloseOn(cwd = process.cwd()) {
   try { return String(parseForgeYaml(readFileSync(join(cwd, "forge.yaml"), "utf8"))?.milestones?.close_on ?? "").trim().toLowerCase() === "staging" ? "staging" : "default"; } catch { return "default"; }
 }
+/** forge.yaml `agents.subagent_model` (#4843): the default model of subagents in sessions ForgeDock launches; null when unset or invalid. */
+export function readSubagentModel(cwd = process.cwd()) {
+  try {
+    const v = String(parseForgeYaml(readFileSync(join(cwd, "forge.yaml"), "utf8"))?.agents?.subagent_model ?? "").trim();
+    return /^[A-Za-z0-9._:[\]-]+$/.test(v) ? v : null;
+  } catch { return null; }
+}
 /** forge.yaml `lean.explore` (on|off) and `lean.explore_model` (#4391): the builder's explorer subagent; undefined when neither is set or valid. */
 export function readExplore(cwd = process.cwd()) {
   try {
@@ -1031,7 +1039,7 @@ export async function resumeStalledFromCli(argv, deps = {}) {
   await assertRepoMatchesCwd(io, repo, { sleep: deps.sleep });
   await assertLaneNotDefault(io, lane, repo);
   const dispatch = deps.dispatch ?? runFromCli;
-  const projector = makeProjector(io);
+  const projector = makeProjector(io, { repo: repo ?? undefined });
   const now = Date.now();
 
   // Collect candidate issue numbers from all non-terminal workflow labels
@@ -1247,7 +1255,7 @@ async function addToBatch({ id, tokens, root, io, viaDaemon = null, print = (l)
   for (const n of new Set(ints)) {
     let st = null;
     let v = null;
-    try { v = JSON.parse(await io.gh(["issue", "view", String(n), ...(repo ? ["-R", repo] : []), "--json", "state,body,author,authorAssociation"])); st = v?.state ?? null; } catch { st = null; }
+    try { v = await viewIssue(io.gh, repo, n, "state,body,author"); st = v?.state ?? null; } catch { st = null; }
     state.set(n, st); records.set(n, v);
   }
   const open = [];
@@ -1854,8 +1862,8 @@ export async function runBatch({ argv, cwd: callerCwd = process.cwd(), env: call
         sink.line(`cross-lane: #${e.issue} (${e.lane}) depends on #${e.dependency} (${e.dependencyLane}); its fix will not be on ${e.lane}: re-milestone #${e.dependency} or wait for a milestone sync`);
       },
       readBody: maint || registry || hybrid
-        ? async (n) => { const v = JSON.parse(await leanIo.gh(["issue", "view", String(n), "-R", repo, "--json", "body,labels,comments,author,authorAssociation"])); trustedOf.set(n, bodyTrusted(v)); labelsOf.set(n, (v.labels ?? []).map((x) => x.name)); needsOf.set(n, detectNeeds(placementText(v), execForNeeds)); if (execForNeeds?.relay) prefetchOf.set(n, relayPrefetchCommands(v, execForNeeds.relay)); return v.body; }
-        : async (n) => { const v = JSON.parse(await leanIo.gh(["issue", "view", String(n), "-R", repo, "--json", "body,comments,author,authorAssociation"])); trustedOf.set(n, bodyTrusted(v)); needsOf.set(n, detectNeeds(placementText(v), execForNeeds)); if (execForNeeds?.relay) prefetchOf.set(n, relayPrefetchCommands(v, execForNeeds.relay)); return v.body; }, // #4785: decisions and the frozen contract's validate commands too
+        ? async (n) => { const v = await viewIssue(leanIo.gh, repo, n, "body,labels,comments,author"); trustedOf.set(n, bodyTrusted(v)); labelsOf.set(n, (v.labels ?? []).map((x) => x.name)); needsOf.set(n, detectNeeds(placementText(v), execForNeeds)); if (execForNeeds?.relay) prefetchOf.set(n, relayPrefetchCommands(v, execForNeeds.relay)); return v.body; }
+        : async (n) => { const v = await viewIssue(leanIo.gh, repo, n, "body,comments,author"); trustedOf.set(n, bodyTrusted(v)); needsOf.set(n, detectNeeds(placementText(v), execForNeeds)); if (execForNeeds?.relay) prefetchOf.set(n, relayPrefetchCommands(v, execForNeeds.relay)); return v.body; }, // #4785: decisions and the frozen contract's validate commands too
       onUpdate: (r) => sink.row(r),
     });
   } finally { for (const [sig, f] of Object.entries(handlers)) off(sig, f); }
@@ -2219,7 +2227,7 @@ export async function schedFromCli(argv, deps = {}) {
   throw new Error(usage);
 }
 
-/** #4773: is the author of a `gh issue view --json author,authorAssociation` record trusted (the engine admission's `isTrustedActor`)? */
+/** #4773: is the author of a `viewIssue` record (author plus the REST association, #4859) trusted (the engine admission's `isTrustedActor`)? */
 const bodyTrusted = (v) => isTrustedActor({ association: v?.authorAssociation, type: v?.author?.is_bot ? "Bot" : "User", login: v?.author?.login });
 
 /**

package/bin/forgedock.mjs

@@ -3360,6 +3360,7 @@ function help() {
     ["npx forgedock milestone train <slug...> [--parallel-milestones N] | --resume <id> | --insert <id> <slug> [--before s|--after s] | --show <id>", "Unattended multi-milestone train: one durable state file (order, active set, lifecycle), typed STOP reasons, resumable; never edits forge.yaml"],
     ["npx forgedock guards list [--path p] [--json] | backfill --since <date> [--dry-run]", "Fix guards: list the FORGE:GUARD records (test files + protected hunks of merged fixes) covering a path, or build them for already-merged lean lanes"],
     ["npx forgedock issue-watch run [--name <w>] [--repo owner/repo] [--once] [--dry-run] | status [--name <w>]", "Named, scoped, capped watches (forge.yaml issue_watch.watches) that claim matching open issues into lanes or one long-lived orchestrate batch, or (mode: release) pool them and cut themed releases; see docs/ISSUE-WATCH.md"],
+    ["npx forgedock prod-watch run [--repo owner/repo] [--once] [--interval <s>] [--dry-run] | status", "Production-side watcher (forge.yaml prod_watch): read-only signal sources -> triage -> governor -> issues, kill-switch file, owner digest; see docs/PROD-WATCH.md"],
     ["npx forgedock limits show | clear <id>|--all", "Show or clear per-account usage-limit holds shared by orchestrate batches"],
     ["npx forgedock decisions list [--stale] [--refresh]", "List anchored decisions (FORGE:DECISION); --stale shows those with an anchor missing on the base"],
     ["npx forgedock sched show | cap <N>|--clear | weight <owner/repo> <N>|--clear", "Show the host lane registry, set the host-wide lane cap shared by orchestrate batches, or set a repo's share of slots within a priority (default equal)"],
@@ -3946,7 +3947,7 @@ async function watch() {
 const SPLASH_COMMANDS = new Set(["run", "bootstrap", "run-issue", "orchestrate", "triage", "probe", "gc", "resume-stalled", "demo", "doctor", "watch", "help", "--help", "-h"]);
 const KNOWN_COMMANDS = new Set([
   "install", "init", "enable", "disable", "status", "uninstall", "update",
-  "run", "bootstrap", "backend-check", "run-issue", "orchestrate", "milestone", "milestone-sync", "guards", "triage", "probe", "review-staging", "gc", "resume-stalled", "demo", "doctor", "watch", "issue-watch", "labels", "config", "stats", "limits", "decisions", "sched", "schedd", "pool", "check", "help", "--help", "-h",
+  "run", "bootstrap", "backend-check", "run-issue", "orchestrate", "milestone", "milestone-sync", "guards", "triage", "probe", "review-staging", "gc", "resume-stalled", "demo", "doctor", "watch", "issue-watch", "prod-watch", "labels", "config", "stats", "limits", "decisions", "sched", "schedd", "pool", "check", "help", "--help", "-h",
   "version", "--version", "-v",
 ]);
 if (SPLASH_COMMANDS.has(command) || !KNOWN_COMMANDS.has(command)) splash(command);
@@ -4217,6 +4218,16 @@ switch (command) {
     }
     break;
   }
+  case "prod-watch": {
+    const { prodWatchFromCli } = await import("./lean/prodwatch.mjs");
+    try {
+      await prodWatchFromCli(restArgs);
+    } catch (err) {
+      process.stderr.write(`${RED}${err.message}${RESET}\n`);
+      exitCode = 1;
+    }
+    break;
+  }
   case "limits": {
     const { limitsFromCli } = await import("./engine-cli.mjs");
     try {

package/bin/lean/batch.test.mjs

@@ -538,7 +538,7 @@ describe("#4408: issues added to a running batch (forgedock orchestrate --add)",
     assert.deepEqual(b.readAdded(), [2, 3, 5]);
     assert.deepEqual(b.unrunAdds(), [2, 3, 5]);
     const views = [];
-    const io = { gh: async (a) => { views.push(a); if (a[2] === "8") throw new Error("gh down"); return JSON.stringify({ state: a[2] === "7" ? "CLOSED" : "OPEN" }); } };
+    const io = { gh: async (a) => { if (a[0] === "api") return "OWNER\n"; views.push(a); if (a[2] === "8") throw new Error("gh down"); return JSON.stringify({ state: a[2] === "7" ? "CLOSED" : "OPEN" }); } };
     const res = await quiet(() => orchestrateFromCli(["--add", "b1", "6", "7", "8", "3", "x"], { batchRoot: root, io }));
     assert.deepEqual(res.added, [6]);
     assert.deepEqual(res.skipped.map((x) => [x.issue, x.reason]).sort(), [[3, "already in batch"], [7, "closed"], [8, "unreadable"], ["x", "not an integer"]]);
@@ -553,7 +553,7 @@ describe("#4408: issues added to a running batch (forgedock orchestrate --add)",
     b.writePlan({ argv: [], repo: "o/r" }); // no issues: the resume stops with the usage error after its adds
     b.store.save({ order: [1] });
     const views = [];
-    const io = { gh: async (a) => { views.push(a[2]); return JSON.stringify({ state: "OPEN" }); } };
+    const io = { gh: async (a) => { if (a[0] === "api") return "OWNER\n"; views.push(a[2]); return JSON.stringify({ state: "OPEN" }); } };
     await assert.rejects(quiet(() => orchestrateFromCli(["--resume", "b1", "--parallel", "5"], { batchRoot: root, io })), /usage/);
     assert.deepEqual(views, [], "no issue read for a flag value");
     assert.deepEqual(b.readAdded(), []);

package/bin/lean/effects.mjs

@@ -8,8 +8,8 @@ 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";
-import { makeIo } from "../engine-cli.mjs";
+import { runCliBackendAsync, resolveClaudeCliBinary, getClaudeCliCapabilities, buildLeanSessionFlags, buildReadOnlyToolFlags, sanitizeCliModel } from "../runner.mjs";
+import { makeIo, readSubagentModel } from "../engine-cli.mjs";
 import { makeProjector } from "../engine/projector.mjs";
 import { makeLedger, countLiveLanes, ledgerRoot } from "./ledger.mjs";
 import { makeDepCache } from "./depcache.mjs";
@@ -76,21 +76,39 @@ export const noToolFlags = (caps) => (caps?.strictMcp ? ["--tools", ""]
 
 /** #4456: `--settings` registering the re-read nudge (bin/hooks/reread-nudge.mjs) as a PostToolUse hook on Read and Bash. */
 export const REREAD_HOOK = fileURLToPath(new URL("../hooks/reread-nudge.mjs", import.meta.url));
-export const rereadNudgeFlags = (node = process.execPath, hook = REREAD_HOOK) => {
+export const rereadHooks = (node = process.execPath, hook = REREAD_HOOK) => {
   const hooks = [{ type: "command", command: `${JSON.stringify(node)} ${JSON.stringify(hook)}` }];
   // #4580: the same script denies a full-file Read of an unchanged path already read twice (PreToolUse)
-  return ["--settings", JSON.stringify({ hooks: { PostToolUse: [{ matcher: "Read|Bash", hooks }], PreToolUse: [{ matcher: "Read", hooks }] } })];
+  return { PostToolUse: [{ matcher: "Read|Bash", hooks }], PreToolUse: [{ matcher: "Read", hooks }] };
 };
+export const rereadNudgeFlags = (node = process.execPath, hook = REREAD_HOOK) => ["--settings", JSON.stringify({ hooks: rereadHooks(node, hook) })];
 
-export function makeLeanRunner({ runCli = runCliBackendAsync, probe = systemdRunAvailable } = {}) {
+/**
+ * #4843: ForgeDock owns the subagent model of the sessions it launches. An operator settings.json `env` such as
+ * CLAUDE_CODE_SUBAGENT_MODEL=sonnet + _FORCE=1 would otherwise override every subagent, the #4391 Haiku explorer
+ * included, and a child env var cannot undo it (settings env wins); a `--settings` flag does. FORCE=0 lets a
+ * ForgeDock-defined agent's own `model` win. CLAUDE_CODE_SUBAGENT_MODEL (the default for agents without one) is
+ * set only from forge.yaml `agents.subagent_model`; unset leaves the operator's own default alone (#4849).
+ */
+export const ownedModelEnv = (subagentModel = null) => {
+  const m = sanitizeCliModel(subagentModel);
+  return { ...(m ? { CLAUDE_CODE_SUBAGENT_MODEL: m } : {}), CLAUDE_CODE_SUBAGENT_MODEL_FORCE: "0" };
+};
+/** The one `--settings` of a lean session: the owned model env, plus the re-read hooks for builder sessions (#4456). */
+export const leanSettingsFlags = ({ subagentModel = null, reread = false } = {}) =>
+  ["--settings", JSON.stringify({ env: ownedModelEnv(subagentModel), ...(reread ? { hooks: rereadHooks() } : {}) })];
+
+export function makeLeanRunner({ runCli = runCliBackendAsync, probe = systemdRunAvailable, subagentModel = null } = {}) {
   return async ({ role, issue, cwd, model, resume, system, prompt, readOnly = false, noTools = false, rereadNudge = false, maxTurns = null, agents = null, env = null, idleMs = 0, maxMs = 0, laneLimits = null, control = null, onSpawn = null, contextMax = 0, turnMax = 0, busy = null, busyMs = 0, onIdleExtend = null }) => {
     const bin = resolveClaudeCliBinary(cwd) || "claude";
     const caps = getClaudeCliCapabilities(cwd);
     // #4391: custom subagents (the explorer) for the builder session; null leaves argv unchanged
-    const flags = [...buildLeanSessionFlags(caps), ...(noTools ? noToolFlags(caps) : readOnly ? buildReadOnlyToolFlags(caps) : []), ...(agents ? ["--agents", JSON.stringify(agents)] : []),
-      ...(rereadNudge && !readOnly && !noTools ? rereadNudgeFlags() : [])]; // #4456: builder sessions only
+    const flags = [...buildLeanSessionFlags(caps), ...(noTools ? noToolFlags(caps) : readOnly ? buildReadOnlyToolFlags(caps) : []), ...(agents ? ["--agents", JSON.stringify(agents)] : [])];
+    // #4843 owned models, in extraArgs so FORGEDOCK_FULL_SESSION=1 (which drops sessionFlags) keeps them (#4848 BUG-1);
+    // #4456 re-read hooks: builder sessions only, and like the other session flags not in a full session
+    const settings = leanSettingsFlags({ subagentModel, reread: rereadNudge && !readOnly && !noTools && process.env.FORGEDOCK_FULL_SESSION !== "1" });
     const r = await runCli({ spec: { name: `core-${role}` }, userMessage: prompt, systemPrompt: resume ? "" : system,
-      args: [String(issue)], cwd, bin, model, maxTurns: caps?.maxTurns ? maxTurns : null, env, sessionFlags: flags, extraArgs: resume ? ["--resume", resume] : [],
+      args: [String(issue)], cwd, bin, model, maxTurns: caps?.maxTurns ? maxTurns : null, env, sessionFlags: flags, extraArgs: [...(resume ? ["--resume", resume] : []), ...settings],
       logger: { log() {} },
       idleMs, maxMs, stream: idleMs > 0, control, onSpawn, busy, busyMs, onIdleExtend, ...(contextMax > 0 ? { contextMax } : {}), ...(turnMax > 0 ? { turnMax } : {}), wrap: probe() ? (b, a) => wrapLaneLimits(b, a, laneLimits) : null });
     // #4395: a resumed session's first turn carries the prior history, so only a fresh session reports a baseline.
@@ -275,12 +293,12 @@ export function makeGhCache({ root = null, tmp = tmpdir() } = {}) {
   };
 }
 
-export function makeLeanIo({ repo }) {
+export function makeLeanIo({ repo, subagentModel = readSubagentModel() }) {
   const base = makeIo();
   const run = (bin) => async (args, opts = {}) => (await pexec(bin, args, { cwd: opts.cwd, maxBuffer: 100 * 1024 * 1024, timeout: 120000, ...(opts.env ? { env: { ...process.env, ...opts.env } } : {}) })).stdout;
   return {
     ghCache: (root) => makeGhCache({ root }),
-    gh: run("gh"), git: run("git"), docker: run("docker"), killGroup: async (pid, marker) => killLedgerPid(pid, marker), ledger: (opts) => makeLedger(opts), runTmp: makeRunTmp(), host: makeHostProbe(), heavy: makeHeavyIo({ host: makeHostProbe() }), projector: makeProjector({ gh: base.gh }), runner: makeLeanRunner(), waitCiGreen: base.waitCiGreen,
+    gh: run("gh"), git: run("git"), docker: run("docker"), killGroup: async (pid, marker) => killLedgerPid(pid, marker), ledger: (opts) => makeLedger(opts), runTmp: makeRunTmp(), host: makeHostProbe(), heavy: makeHeavyIo({ host: makeHostProbe() }), projector: makeProjector({ gh: base.gh }, { repo }), runner: makeLeanRunner({ subagentModel }), waitCiGreen: base.waitCiGreen,
     /** Shared dependency cache (#4220): the repo's own package manager, argv only, bounded by the cache's timeout. */
     deps: makeDepCache({ exec: async (cmd, args, { cwd, env, timeoutMs } = {}) => String((await pexec(cmd, args, { cwd, env: { ...process.env, ...(env ?? {}) }, timeout: timeoutMs ?? 0, maxBuffer: 100 * 1024 * 1024 })).stdout) }),
     /** Names of the checks the base branch requires: classic protection plus rulesets (#4158). [] when neither has any. */

package/bin/lean/explore.test.mjs

@@ -42,7 +42,7 @@ describe("explorer subagent config (#4391)", () => {
     const [plain, withAgents] = seen;
     assert.ok(!plain.includes("--agents"));
     const i = withAgents.indexOf("--agents");
-    assert.deepEqual(withAgents.slice(0, i), plain);
+    assert.deepEqual([...withAgents.slice(0, i), ...withAgents.slice(i + 2)], plain, "only the --agents pair is added");
     assert.deepEqual(JSON.parse(withAgents[i + 1]), agents);
   });
 

package/bin/lean/fixtures/prodwatch/expected.json

@@ -0,0 +1,85 @@
+{
+ "memos": 70,
+ "clusters": [
+  {
+   "name": "pg-conn",
+   "class": "defect",
+   "count": 15
+  },
+  {
+   "name": "api-5xx",
+   "class": "incident",
+   "count": 1
+  },
+  {
+   "name": "queue-lag",
+   "class": "defect",
+   "count": 1
+  },
+  {
+   "name": "cert",
+   "class": "defect",
+   "count": 1
+  },
+  {
+   "name": "disk",
+   "class": "defect",
+   "count": 1
+  },
+  {
+   "name": "deploy",
+   "class": "deploy-fallout",
+   "count": 1
+  },
+  {
+   "name": "mon-bug",
+   "class": "monitoring-bug",
+   "count": 1
+  },
+  {
+   "name": "mem-leak",
+   "class": "defect",
+   "count": 1
+  },
+  {
+   "name": "t1",
+   "class": "transient",
+   "count": 1
+  },
+  {
+   "name": "t2",
+   "class": "transient",
+   "count": 1
+  },
+  {
+   "name": "t3",
+   "class": "transient",
+   "count": 1
+  },
+  {
+   "name": "t4",
+   "class": "transient",
+   "count": 1
+  },
+  {
+   "name": "e1",
+   "class": "expected-class",
+   "count": 11
+  },
+  {
+   "name": "e2",
+   "class": "expected-class",
+   "count": 11
+  },
+  {
+   "name": "e3",
+   "class": "expected-class",
+   "count": 11
+  },
+  {
+   "name": "e4",
+   "class": "expected-class",
+   "count": 11
+  }
+ ]
+}