forgedock 1.31.0 → 1.32.1

package/bin/lean/lean.mjs

@@ -25,7 +25,7 @@ import { prepareToolchain } from "./toolchain.mjs";
 import { toolStats } from "./toolstats.mjs";
 import { readTestMap, readTestMapAtRef, factsPath, TEST_MAP_FILE } from "./testmap.mjs";
 import { runChecks, planPrecheck, worktreeFingerprint, selfCheckState, quietFailure, CHECK_PLAN_FILE, SELF_CHECK_FILE, CHECK_LOG_DIR } from "./precheck.mjs";
-import { retrying, PUSH_TRANSIENT_RE, PUSH_PERMANENT_RE, GH_TRANSIENT_RE, MERGE_TRANSIENT_RE, MERGE_CONFLICT_RE } from "./retry.mjs";
+import { retrying, ghCacheRetry, PUSH_TRANSIENT_RE, PUSH_PERMANENT_RE, GH_TRANSIENT_RE, MERGE_TRANSIENT_RE, MERGE_CONFLICT_RE } from "./retry.mjs";
 import { renderInvestigation, renderImplementation, renderReview, renderPrBody, renderTrajectory, renderContract, renderAmendments, renderShadowReview, parseContractComment, contractJson, capComment, sanitizeMd, MAX_COMMENT_CHARS, recoveryEvidence } from "./render.mjs";
 import { parseVerifierConfig, pickVerifierModel, changedSymbols, callersOf, verifierBudget, verifierPrompt, parseVerifierFindings, findingsToFailures, renderVerifierNote, VERIFIER_SYSTEM } from "./verifier.mjs";
 import { computeTrigger, riskPathHits, TRIGGER_MODES } from "./review-trigger.mjs";
@@ -45,8 +45,10 @@ import { writeHeavyShims, sumWaits, isHeavyProcess } from "./heavy.mjs";
 import { priorityFromLabels } from "./sched.mjs";
 import { parseExploreConfig, explorerAgents, explorePlanRule, exploreBuildRule } from "./explore.mjs";
 import { normaliseFacts, renderFactsRecord, FACTS_MARKER } from "./facts.mjs";
-import { parseContextPackConfig, contextPackFor, renderContextRecord, laneType, priorAttempts, linkStateStamp, stateOf } from "./context.mjs";
+import { parseContextPackConfig, contextArm, contextPackFor, renderContextRecord, laneType, priorAttempts, linkStateStamp, stateOf } from "./context.mjs";
 import { buildResumeDigest } from "./resume.mjs";
+import { lightEligibility } from "./light.mjs";
+import { runLightStep, runLightTests, lightBuildPrompt, upgradeNote, renderLiteReceipt } from "./lightlane.mjs";
 
 /**
  * #4267: what a recovery lane does per code. Codebase-agnostic: the repo's own checks and logs only. Keys stay in step
@@ -214,10 +216,11 @@ export async function runCore(o) {
 
   const ev = (e) => appendEvent(dir, issue, e, { repo }); // #4432: the run log is keyed by repo + issue
   const emit = async (rec) => { try { await emitTelemetry?.({ ...rec, issue }); } catch { /* never fails a run */ } };
-  const ghc = (args) => io.gh(args);
+  let ghCache = null; // #4507: the run's own gh HTTP cache (set once the run tmp dir exists)
+  const ghc = (args) => ghCacheRetry((env) => io.gh(args, env ? { env } : undefined), ghCache);
   const sleepFn = io.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   /** gh writes (comment, pr create, issue edit/close): retried for 5xx and secondary rate limits (#4114). */
-  const ghw = (args) => retrying(() => io.gh(args), { transient: GH_TRANSIENT_RE, attempts: 4, sleep: sleepFn, random });
+  const ghw = (args) => retrying(() => ghc(args), { transient: GH_TRANSIENT_RE, attempts: 4, sleep: sleepFn, random });
   const git = (args) => io.git(args, { cwd: wt });
 
   const builderTriggers = []; // #4362: implement-attempt triggers in order, for the lane's first-pass flag
@@ -232,6 +235,7 @@ export async function runCore(o) {
       ...(num(r?.baselineTokens) != null ? { baseline_tokens: num(r.baselineTokens) } : {}), ...(r?.tools ? { tools: r.tools } : {}), lane_profile: laneProfile.name }; // #4410
     if (phase === "implement") { builderTriggers.push({ trigger, restart_of: restartOf }); impl.cost += c.delta ?? 0; if (r?.model && r.model !== "default") impl.models.add(r.model); tb.note(num(r?.turns), stage === "implement"); }
     ev(rec); await emit(rec);
+    modelMs += rec.duration_ms; // #4451: model time next to the lane's wall time
     const u = r?.usage ?? {};
     usage.cost_usd += c.delta ?? 0;
     usage.input += u.input_tokens ?? 0; usage.output += u.output_tokens ?? 0;
@@ -273,7 +277,11 @@ export async function runCore(o) {
   // Pipeline trajectory (posted once at the end): phase rows, decisions, anomalies.
   const T = { issue, validate: null, plan: null, implement: null, review: null, pr: null, merge: null, close: null, decisions: [], anomalies: [] };
   const failureClasses = new Set(); // forge#4275: conformance failure codes seen this run (gate failures, shadow would-fail)
-  const ctxCfg = parseContextPackConfig(o.contextPack ?? {});
+  const ctxBase = parseContextPackConfig(o.contextPack ?? {});
+  const ctxArm = contextArm({ mode: ctxBase.mode, repo, issue }); // #4444: ab picks a stable on|shadow arm per issue
+  const ctxCfg = { ...ctxBase, mode: ctxArm.mode };
+  const ctxAb = ctxArm.ab ? { context_ab: true } : {};
+  if (ctxArm.ab) T.decisions.push(`Context pack A/B (#4444): arm ${ctxArm.mode}`);
   const exploreCfg = parseExploreConfig(o.explore ?? {}); // #4391
   if (exploreCfg.mode === "on") T.decisions.push(`Explorer subagent (on): model ${exploreCfg.model}`);
   let ctxLane = null; // forge#4275: rerun | child | first, set once the issue is read
@@ -282,6 +290,8 @@ export async function runCore(o) {
   let shadowWould = null; // forge#4165: the shadow gate's verdict, carried on RUN_TERMINAL (no telemetry write of its own)
   let riskEnforced = null, gateRan = false; // #4398: declared risk paths that made a shadow lane enforce (sticky); the gate ran
   let done = null, finishing = null, wtCreated = false, salvagedRef = null;
+  let light = false, modelMs = 0; // #4451: the light lane finished without an upgrade (skips structure/hotspot gates); summed session time
+  let lightVerdict = null, lightUpgrade = null; // #4453: the eligibility verdict and the upgrade reason codes, on the run result for the bench
   let recoverUnlabelled = false; // #4297: the recovery lane removed needs-human; a final ci-pending (or needsHuman()) puts it back
   const runId = `${issue}-${t0}`;
   let runTmp = null;
@@ -318,6 +328,7 @@ export async function runCore(o) {
     }
     // Never discard work silently: an unmerged lane commits and pushes what is left before its worktree goes.
     const saved = !wtCreated || reason === "merged" || (await checkpoint(`exit (${reason})`));
+    try { ghCache?.dispose?.(); } catch { /* best effort */ }
     if (runTmp) {
       try { if ((await io.runTmp.remove(runTmp)) !== false) ledgerDo((l) => l.release("tmp", runTmp)); } catch { /* best effort */ }
       runTmp = null;
@@ -399,7 +410,7 @@ export async function runCore(o) {
     // forge#4165: pr, milestone and the conformance verdict ride on the existing RUN_TERMINAL write (verdict-mix queries).
     const term = { event: "RUN_TERMINAL", reason, code, ...(extra.pr ? { pr: extra.pr } : {}), ...(milestone ? { milestone } : {}),
       conformance_mode: conformance === "enforce" || riskEnforced ? "enforce" : "shadow", ...(shadowWould ? { shadow_would: shadowWould } : {}),
-      context_pack: ctxCfg.mode, explore: exploreCfg.mode, ...(ctxLane ? { lane_type: ctxLane } : {}), ...(pitMatched != null ? { pitfalls_matched: pitMatched } : {}), ...(tb.record() ? { turns: tb.record() } : {}),
+      context_pack: ctxCfg.mode, ...ctxAb, explore: exploreCfg.mode, wall_ms: now() - t0, model_ms: modelMs, light, ...(ctxLane ? { lane_type: ctxLane } : {}), ...(pitMatched != null ? { pitfalls_matched: pitMatched } : {}), ...(tb.record() ? { turns: tb.record() } : {}),
       ...(route ? { builder_tier: route.tier, builder_class: route.class, builder_escalated: escalated, builder_model: route.model ?? "default" } : {}) }; // forge#4275: the on/off A/B groups runs by these; #4394: per-tier stats
     ev(term);
     await emit(term);
@@ -424,7 +435,8 @@ export async function runCore(o) {
       try { await post(["FORGE:TRAJECTORY", REGISTER_MARKER], renderTrajectory({ ...T, usage: usageLine() })); } catch { /* best effort */ }
     }
     await releaseLease(reason, code);
-    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,
+    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, model_ms: modelMs,
+      light, ...(lightVerdict ? { light_eligibility: lightVerdict } : {}), ...(lightUpgrade ? { light_upgrade: lightUpgrade } : {}), // #4453
       ...(Object.keys(waits).length ? { waits: { ...waits } } : {}), ...(heavyQueueMax ? { heavyQueueMax } : {}), ...(precheckRan ? { precheckMs, precheckDeferred } : {}),
       ...(firstPassOf(builderTriggers) != null ? { firstPass: firstPassOf(builderTriggers) } : {}), ...(tb.record() ? { turns: tb.record() } : {}), // #4392
       ...(route ? { builderRoute: { tier: route.tier, class: route.class, escalated, model: route.model ?? "default" } } : {}),
@@ -672,7 +684,7 @@ export async function runCore(o) {
     const governor = startGovernor(control);
     let spawned = null;
     const onSpawn = (child) => { if (Number.isSafeInteger(child?.pid) && !finishing) { spawned = child.pid; ledgerDo((l) => l.register("pid", child.pid, { marker: basename(String(child.spawnfile ?? "")) || null })); } };
-    const call = Promise.resolve(callRunner({ role: "builder", issue, cwd: wt, model: model ?? laneModel(), resume, system: "", prompt, control, onSpawn, agents: explorerAgents(exploreCfg),
+    const call = Promise.resolve(callRunner({ role: "builder", issue, cwd: wt, model: model ?? laneModel(), resume, system: "", prompt, control, onSpawn, agents: explorerAgents(exploreCfg), rereadNudge: true,
       idleMs: Math.round(cliIdleMinutes * 60000), maxMs: Math.round(cliMaxMinutes * 60000), laneLimits, ...(contextMax > 0 ? { contextMax } : {}), ...(turnMax > 0 ? { turnMax } : {}),
       busy: sessionBusy, busyMs: Math.round(cliBusyMinutes * 60000),
       onIdleExtend: (info) => ev({ event: "CLI_IDLE_EXTENDED", children: info.children, heavyQueue: info.heavyQueue }) }));
@@ -880,6 +892,7 @@ export async function runCore(o) {
     try { runTmp = await io.runTmp.make(issue, runId); } catch { runTmp = null; }
     if (runTmp && runTmp !== planned) ledgerDo((l) => l.register("tmp", runTmp));
   }
+  ghCache = io.ghCache?.(runTmp) ?? null;
   ev({ event: "RUN_START", run: `core_${issue}_${t0}`, issue, lane, path: "core", version: ENGINE_VERSION, forge_version: ENGINE_VERSION, repo });
   try {
     iss = JSON.parse(await ghc(["issue", "view", String(issue), "-R", repo, "--json", "number,title,body,state,comments,labels,updatedAt"]));
@@ -1117,7 +1130,7 @@ export async function runCore(o) {
         const inPack = Array.isArray(p.pitfalls) ? p.pitfalls : [];
         pitMatched = inPack.filter((x) => x.match === "files").length;
         // #4375: which pitfalls were in the pack (signatures only, run log only: never telemetry or a comment)
-        const rec = { event: "CONTEXT_PACK", mode: ctxCfg.mode, lane_type: ctxLane, sources: p.sources, found: p.found, bytes: p.bytes, items: p.items, truncated: p.truncated,
+        const rec = { event: "CONTEXT_PACK", mode: ctxCfg.mode, ...ctxAb, lane_type: ctxLane, sources: p.sources, found: p.found, bytes: p.bytes, items: p.items, truncated: p.truncated,
           hash: p.hash, cached: r.cached, ...(r.errors?.length ? { errors: r.errors } : {}) };
         ev({ ...rec, pitfalls: inPack }); await emit(rec);
         const seen = trustedComments.some((c) => String(c?.body ?? "").startsWith("<!-- FORGE:CONTEXT -->") && String(c.body).includes(`hash ${p.hash})`));
@@ -1356,13 +1369,55 @@ export async function runCore(o) {
         }
       }
       await label("building");
-      hotFacts = await hotspotsOf({ paths: namedPaths(iss.body ?? "") });
+      // #4450: the light lane (lean.light mode on, eligible, fresh lane): one builder session, derived contract, or an upgrade
+      const elig = lightEligibility({ title: iss.title, body: iss.body ?? "", labels: iss.labels ?? [], predictedFiles: namedPaths(iss.body ?? ""), riskPaths, cfg: o.light ?? {} });
+      ev({ event: "LIGHT_ELIGIBILITY", mode: elig.mode, verdict: elig.verdict, light: elig.light, reasons: elig.reasons });
+      lightVerdict = elig.verdict;
+      if (elig.mode !== "off") T.decisions.push(`Light lane ${elig.mode}: ${elig.verdict}${elig.reasons.length ? ` (${elig.reasons.map((x) => x.code).join(", ")})` : ""}`);
+      // #4451: a light try skips the hotspots and the context pack; an upgrade computes them before the plan call
+      const lightTry = elig.light && !frozen && !resumed && !salvagedRef && !recover;
+      if (!lightTry) hotFacts = await hotspotsOf({ paths: namedPaths(iss.body ?? "") });
       enumList = io.enumeratingTests ? ((await io.enumeratingTests({ cwd: wt, paths: namedPaths(iss.body ?? "") }).catch(() => null)) ?? []) : [];
       facts = await factsPath([wt, cwd], io.fs?.exists);
-      const ctxPack = frozen ? null : await contextPackStep();
+      let ctxPack = frozen || lightTry ? null : await contextPackStep();
       const planPrompt = () => builderPlanPrompt(issue, tcOpts()) + hotspotPlanNote(hotFacts) + enumeratingPlanNote(enumList) + reproPlanNote(reproOn()) + explorePlanRule(exploreCfg) + (ctxCfg.mode === "on" ? contextPackNote(ctxPack) : "");
+      let lightDone = false, lightCommits = false;
+      if (lightTry) {
+        liveKeys = ["implementation"]; stage = "implement";
+        tb.setSize(laneSize({ labels: (iss?.labels ?? []).map((l) => l?.name ?? l) }));
+        const lr = await runLightStep({ title: iss.title, issueText, riskPaths, cfg: o.light ?? {}, validate: (c) => validateContract(c, issueText, { repro: reproOn() }),
+          build: () => builder(++attemptN, lightBuildPrompt(issue, tcOpts()) + hotspotBuildRule(hotFacts) + enumeratingBuildRule(enumList), null, true, undefined, { trigger: "build" }),
+          readResult, checkpoint: () => checkpoint("light build"), changedFiles, reproOf, numstat: () => git(["diff", "--numstat", `${base}...HEAD`]),
+          runTests: async (cmds) => (io.runCommand ? runLightTests({ commands: cmds, parallelism: Number(verifyParallelism()) || 1, now, acquire: () => heavyAcquire("precheck"), // #4451: host-capped
+            run: ({ command, workers }) => { const env = laneEnv(); return io.runCommand({ command, cwd: wt, env: env.FORGE_HOST_PARALLELISM ? { ...env, FORGE_HOST_PARALLELISM: String(workers) } : env }); } }) : null),
+          fixTests: (failed) => builder(++attemptN, precheckFailurePrompt(capLogs(failed.map((f) => ({ ...f, log: f.output }))).map((f) => ({ command: f.command, rc: f.rc, output: f.log })), vcfg.mode), sessionId, false, undefined, { mode: "resume", trigger: "precheck" }),
+          apiShape: () => (io.apiShape ? io.apiShape({ cwd: wt, base }).catch(() => null) : null) });
+        stage = "plan"; liveKeys = ["investigation"]; result = (await readResult()) ?? result;
+        if (!lr.upgrade) {
+          lightDone = true; light = true; frozen = lr.contract; hash = contractHash(contractJson(frozen));
+          let body = renderContract(frozen, hash, { scope: scopeHash });
+          if (body.length > MAX_COMMENT_CHARS - 500) body = renderContract(frozen, hash, { compact: true, scope: scopeHash });
+          await post(["FORGE:CONTRACT", "FORGE:PLAN"], body);
+          ev({ event: "CONTRACT_FROZEN", hash, requirements: frozen.requirements.length, deferred: 0, derived: "light" });
+          ev({ event: "LIGHT_DONE", files: lr.files.length, test_failures: lr.testFailures, repro: lr.repro, cost_usd: usage.cost_usd });
+          T.decisions.push(`Light lane: one builder session, contract ${hash} derived from the diff and the test`);
+          try { await post("FORGE:LITE", renderLiteReceipt({ lr, eligibility: elig, costUsd: usage.cost_usd, contractHash: hash })); } catch { /* #4452: the receipt is best effort */ }
+        } else {
+          lightCommits = lr.files.length > 0;
+          ev({ event: "LIGHT_UPGRADE", reasons: lr.reasons, cost_usd: usage.cost_usd });
+          lightUpgrade = lr.reasons.map((x) => x.code);
+          T.decisions.push(`Light lane upgraded to the full lane: ${lr.reasons.map((x) => x.code).join(", ")}`);
+          try { await post("FORGE:LITE", renderLiteReceipt({ lr, eligibility: elig, costUsd: usage.cost_usd })); } catch { /* #4452: the receipt is best effort */ }
+          const d = buildResumeDigest({ state: null, comments: trustedComments, contract: null, files: lr.files, lane });
+          resumeNote = d.text + upgradeNote(lr.reasons);
+          result = null; // the light result.json must not read as the plan's verdict
+          if (io.fs.write) { try { await io.fs.write(`${wt}/${RESULT_FILE}`, "{}\n"); } catch { /* the plan overwrites it */ } }
+          hotFacts = await hotspotsOf({ paths: namedPaths(iss.body ?? "") }); // #4451: the full lane keeps its plan facts
+          ctxPack = await contextPackStep();
+        }
+      }
       if (!frozen) {
-        await builder(++attemptN, planPrompt() + (hasCommits ? PLAN_RERUN_NOTE.replace("BASE", lane) : "") + recoverNote() + resumeNote, null, true, planPrompt, { trigger: "plan" });
+        await builder(++attemptN, planPrompt() + (hasCommits || lightCommits ? PLAN_RERUN_NOTE.replace("BASE", lane) : "") + recoverNote() + resumeNote, null, true, planPrompt, { trigger: "plan" });
         planned = true;
         result = await readResult();
         const evidence = (Array.isArray(result?.evidence) ? result.evidence : []).filter((x) => typeof x === "string" && x.trim());
@@ -1427,9 +1482,9 @@ export async function runCore(o) {
         ev({ event: "CONTRACT_FROZEN", hash, requirements: frozen.requirements.length, deferred: deferredN });
         T.decisions.push(`Contract frozen (${hash}): ${frozen.requirements.length} requirement(s), ${deferredN} deferred pending review`);
       } else {
-        T.validate = "resumed (existing branch)";
+        T.validate = lightDone ? "light lane (no plan session)" : "resumed (existing branch)";
       }
-      T.plan = [`contract ${hash}`, `${frozen.requirements.length} requirement(s)`];
+      T.plan = [`contract ${hash}${lightDone ? " (derived, light lane)" : ""}`, `${frozen.requirements.length} requirement(s)`];
       tb.setSize(laneSize({ contract: frozen, labels: (iss?.labels ?? []).map((l) => l?.name ?? l) })); // #4392
       if (io.fs.write) { try { await io.fs.write(`${wt}/${CONTRACT_FILE}`, `${contractJson(frozen)}\n`); } catch { /* the prompt still names it */ } }
       // #4364: what `forgedock check` needs from the operator's forge.yaml (gitignored, so not in the worktree)
@@ -1443,7 +1498,7 @@ export async function runCore(o) {
       const implementPrompt = builderImplementPrompt(vcfg.mode, tcOpts()) + hotspotBuildRule(hotFacts) + enumeratingBuildRule(enumList) + exploreBuildRule(exploreCfg) + (planned ? "" : (fromCheckpoint ? CONTINUE_NOTE : RERUN_NOTE).replace("BASE", lane)) + (salvagedRef ? SALVAGE_NOTE.replaceAll("REF", salvagedRef) : "") + recoverNote() + (planned ? "" : resumeNote);
       liveKeys = ["implementation"];
       stage = "implement";
-      await builder(++attemptN, implementPrompt, planned ? sessionId : null, true, undefined, { trigger: "build" });
+      if (!lightDone) await builder(++attemptN, implementPrompt, planned ? sessionId : null, true, undefined, { trigger: "build" });
       stage = "fix"; // later builder rounds fix precheck, CI, structure, docs or conformance findings
       result = await readResult();
       { // #4374: the builder's self-review against the shared rubric, log only
@@ -1530,7 +1585,7 @@ export async function runCore(o) {
       const d = await io.structureDelta({ cwd: wt, base }).catch(() => null);
       return d && typeof d === "object" && Array.isArray(d.package_edges_added) ? d : null; // `{}`: no workspace packages
     };
-    let structure = await structureOf();
+    let structure = light ? null : await structureOf(); // #4451: no structure delta on a light lane
     if (structure) {
       const pairs = structure.import_pairs ?? [], sum = (k) => pairs.reduce((n, p) => n + (Number(p?.[k]) || 0), 0);
       const rec = { event: "STRUCTURE_DELTA", edges_added: structure.package_edges_added.length, edges_removed: (structure.package_edges_removed ?? []).length,
@@ -1872,7 +1927,7 @@ export async function runCore(o) {
       }
       const amendProblems = await amend();
       const ciVerified = remoteVerify && ciVerifiedHead !== null && ciVerifiedHead === String(await git(["rev-parse", "HEAD"])).trim();
-      const hotspots = await hotspotsOf({ base, paths: files });
+      const hotspots = light ? null : await hotspotsOf({ base, paths: files }); // #4451
       const validateRuns = await rerunFailedValidates(effective);
       const repoHas = validateRuns && Object.keys(validateRuns).length ? repoTracks(String(await git(["ls-files"]).catch(() => "")).split("\n").map((x) => x.trim()).filter(Boolean)) : undefined;
       const pc = precheck({ contract: effective, result, changedFiles: files, ignore: IGNORE, ciVerified, hotspots, repro: await reproOf(effective), validateRuns, repoHas, frozen });
@@ -2081,6 +2136,10 @@ export async function runCore(o) {
       }
       return "unknown";
     };
+    /** #4507: true only when the PR reads MERGED; unreadable counts as not merged. */
+    const prMerged = async () => {
+      try { return String(JSON.parse(String(await ghc(["pr", "view", String(pr), "-R", repo, "--json", "state"])) || "{}").state ?? "").toUpperCase() === "MERGED"; } catch { return false; }
+    };
     /** #4158: MERGEABLE but BLOCKED is a base branch policy block (ruleset / required checks pending), not a conflict. */
     const policyBlocked = async () => {
       let j;
@@ -2234,7 +2293,7 @@ export async function runCore(o) {
      * only: the single telemetry write is the run's one extra API call. Also feeds the trajectory's Structure table.
      */
     async function recordStructure(pr) {
-      const d = (await structureOf()) ?? {};
+      const d = (light ? null : await structureOf()) ?? {}; // #4451
       const numstat = String(await git(["diff", "--numstat", "--no-renames", `${base}...HEAD`]).catch(() => ""));
       const top_growth = numstat.split("\n").map((l) => l.split("\t")).filter((x) => x.length >= 3 && /^\d+$/.test(x[0]) && Number(x[0]) > 0 && !x[2].startsWith(`${LEAN_DIR}/`))
         .map(([a, , file]) => ({ file, lines: Number(a) })).sort((a, b) => b.lines - a.lines || a.file.localeCompare(b.file)).slice(0, 5);
@@ -2372,6 +2431,12 @@ export async function runCore(o) {
         break;
       } catch (e) {
         const msg = `${e?.stderr ?? ""}${e?.message ?? ""}`;
+        if (await prMerged()) { // #4507: the merge went through despite the error
+          T.decisions.push(`gh pr merge errored but PR #${pr} is MERGED: recorded merged (${msg.split("\n")[0].slice(0, 120)})`);
+          try { seqLease?.release(); } catch { /* fail-open */ }
+          seqLease = null;
+          break;
+        }
         if (MERGE_TRANSIENT_RE.test(msg) && !/not mergeable|merge conflict/i.test(msg)) {
           // "Base branch was modified", GraphQL and 5xx are transient: back off, then the loop top re-reads mergeable and the head.
           if (++mergeRetries > maxMergeRetries) return await finish("deferred", `gh pr merge kept failing transiently (${mergeRetries - 1} retries): ${msg.slice(0, 300)}`, { pr, code: OUTCOME_CODES.MERGE_TRANSIENT }, OUTCOME_CODES.MERGE_TRANSIENT);

package/bin/lean/lean.test.mjs

@@ -19,8 +19,8 @@ import { mapRecord } from "../engine/telemetry-seam.mjs";
 import { readLog as readRepoLog } from "../engine/runlog.mjs";
 // #4432: the run log is keyed by repo + issue; every lane in this file runs in repo o/r.
 const readLog = (dir, issue, repo = "o/r") => readRepoLog(dir, issue, { repo });
-import { makeRunTmp, wrapLaneLimits, systemdRunAvailable, makeLeanRunner, requiredChecksFor, procsInDir, makeLeanIo } from "./effects.mjs";
-import { retrying, PUSH_TRANSIENT_RE } from "./retry.mjs";
+import { makeRunTmp, wrapLaneLimits, systemdRunAvailable, makeLeanRunner, requiredChecksFor, procsInDir, makeLeanIo, makeGhCache } from "./effects.mjs";
+import { retrying, ghCacheRetry, PUSH_TRANSIENT_RE } from "./retry.mjs";
 import { checkAdmission, hostParallelism } from "./admission.mjs";
 import { OUTCOME_CODES, classifyNeedsHuman } from "../engine/outcome-codes.mjs";
 import * as refactorMod from "./refactor.mjs";
@@ -73,15 +73,17 @@ function world(o = {}) {
   w.writeStages = writeStages;
   w.io = {
     now: () => w.clock, sleep: async (ms) => { w.clock += ms; },
-    gh: async (a) => {
+    gh: async (a, opts) => {
       const k = a.slice(0, 2).join(" ");
+      if (opts?.env) (w.ghEnvs ??= []).push(opts.env);
+      if (k === "pr view" && a.at(-1) === "state" && a.at(-2) === "--json") return JSON.stringify({ state: o.prState ?? "OPEN" });
       if (a[0] === "api" && a.includes("PATCH")) { w.patches.push(a); return "{}"; }
       if (a[0] === "api") return a.some((x) => /\/comments$/.test(x)) ? (w.issueComments ?? []).map((c) => JSON.stringify(c)).join("\n") : "";
       if (k === "pr list") return JSON.stringify(w.prList);
       if (k === "repo view") return `${o.defaultBranch ?? "main"}\n`;
       if (k === "issue view" && a.includes("milestone")) { w.seq.push("lane"); return JSON.stringify({ milestone: o.milestone ? { title: o.milestone } : null }); }
       if (k === "issue view" && o.issueBodies && a[2] === "7" && a.some((x) => String(x).startsWith("number,title,body,state,comments"))) { const b = o.issueBodies.length > 1 ? o.issueBodies.shift() : o.issueBodies[0]; return JSON.stringify({ number: 7, title: o.title ?? "foo breaks", body: b, state: "OPEN", comments: o.viewComments ?? [] }); }
-      if (k === "issue view") return JSON.stringify({ number: Number(a[2]), title: a[2] === "7" && o.title ? o.title : "foo breaks", body: ISSUE_BODY, state: w.issueStates?.[a[2]] ?? "OPEN", comments: [], ...(o.labels && a[2] === "7" ? { labels: o.labels } : {}) });
+      if (k === "issue view") return JSON.stringify({ number: Number(a[2]), title: a[2] === "7" && o.title ? o.title : "foo breaks", body: a[2] === "7" && o.body ? o.body : ISSUE_BODY, state: w.issueStates?.[a[2]] ?? "OPEN", comments: [], ...(o.labels && a[2] === "7" ? { labels: o.labels } : {}) });
       if (k === "pr edit") { w.prEdits.push(a); return ""; }
       if (k === "label create") { w.labelCreates = [...(w.labelCreates ?? []), a]; return ""; }
       if (k === "issue comment" && w.commentErrors.length) throw new Error(w.commentErrors.shift());
@@ -2146,6 +2148,17 @@ describe("orchestrate", () => {
     assert.deepEqual(parseDeps("This is blocked by #2 and depends on #4\nsee **Depends on**: #5", 1), []);
   });
 
+  it("#4506 parseDeps reads every #N to the end of a declaration line", () => {
+    assert.deepEqual(parseDeps("Depends on #36648 (action results must reach …) and #36649 (the included action budget …)", 1), [36648, 36649]);
+    assert.deepEqual(parseDeps("Depends on #36651 (executor test harness) and #36648.", 1), [36651, 36648]);
+    assert.deepEqual(parseDeps("**Depends on** #2, #3 and #4", 1), [2, 3, 4]);
+    assert.deepEqual(parseDeps("__Depends on__: #5 (x) and #6", 1), [5, 6]);
+    assert.deepEqual(parseDeps("**Blocked by:** #7 (why) & #8", 1), [7, 8]);
+    assert.deepEqual(parseDeps("- depends on: #9 (a), #10", 1), [9, 10]);
+    assert.deepEqual(parseDeps("Depends on #11 and other/repo#12", 1), [11]);
+    assert.deepEqual(parseDeps("This is blocked by #2 and depends on #4", 1), []);
+  });
+
   it("runs at most K at once", async () => {
     const h = harness({});
     const rows = await orchestrate({ issues: [1, 2, 3, 4, 5, 6], parallel: 2, ...h });
@@ -3222,6 +3235,78 @@ describe("batch robustness (#4112-#4115)", () => {
     assert.ok(w.comments.some((c) => c.includes("FORGE:BASE_SYNC")));
   });
 
+  // ---- #4507 ----
+  const CORRUPT = "invalid character '{' looking for beginning of object key string";
+  it("#4507 a gh JSON parse error at merge (corrupt gh cache) is retried and ends merged", async () => {
+    const w = world({ mergeErrors: [CORRUPT] });
+    const r = await run(w);
+    assert.equal(r.terminalReason, "merged");
+    assert.equal(w.mergeAttempts, 2);
+    assert.equal(w.merges.length, 1);
+  });
+
+  it("#4507 a merge error on a PR that is already MERGED records merged, not engine-error", async () => {
+    const w = world({ mergeErrors: ["GraphQL: validation failed (422)"], prState: "MERGED" });
+    const r = await run(w);
+    assert.equal(r.terminalReason, "merged");
+    assert.equal(w.mergeAttempts, 1);
+    assert.equal(w.closed.length, 1);
+    assert.ok(traj(w)[0].includes("is MERGED: recorded merged"));
+  });
+
+  it("#4507 a persistent gh parse error at merge ends deferred merge.transient, never engine-error", async () => {
+    const w = world({ mergeErrors: Array(40).fill(CORRUPT) });
+    const r = await run(w, { maxMergeRetries: 2 });
+    assert.equal(r.terminalReason, "deferred"); assert.equal(r.code, "merge.transient");
+    assert.equal(w.mergeAttempts, 6, "each merge attempt is retried once with a fresh cache");
+  });
+
+  it("#4507 with io.ghCache every engine gh call carries the run's own XDG_CACHE_HOME", async () => {
+    const w = world();
+    w.io.runTmp = { prune: async () => {}, make: async (_i, id) => `/rt/${id}`, remove: async () => true };
+    let made = null, disposed = 0;
+    w.io.ghCache = (root) => { made = root; return { env: () => ({ XDG_CACHE_HOME: `${root}/gh-cache` }), reset() {}, dispose() { disposed++; } }; };
+    assert.equal((await run(w)).terminalReason, "merged");
+    assert.match(made, /^\/rt\//);
+    assert.ok(w.ghEnvs.length > 0 && w.ghEnvs.every((e) => e.XDG_CACHE_HOME === `${made}/gh-cache`));
+    assert.equal(disposed, 1);
+  });
+
+  it("#4507 ghCacheRetry retries exactly once on a parse error and rethrows other errors untouched", async () => {
+    let n = 0, resets = 0;
+    const cache = { env: () => ({ XDG_CACHE_HOME: `/c${resets}` }), reset: () => { resets++; } };
+    const seen = [];
+    assert.equal(await ghCacheRetry(async (env) => { seen.push(env.XDG_CACHE_HOME); if (n++ === 0) throw new Error(CORRUPT); return "ok"; }, cache), "ok");
+    assert.deepEqual(seen, ["/c0", "/c1"]); assert.equal(resets, 1);
+    n = 0;
+    await assert.rejects(ghCacheRetry(async () => { n++; throw new Error(CORRUPT); }, null), /invalid character/);
+    assert.equal(n, 2);
+    n = 0;
+    const other = new Error("HTTP 404: Not Found");
+    await assert.rejects(ghCacheRetry(async () => { n++; throw other; }, cache), (e) => e === other);
+    assert.equal(n, 1);
+  });
+
+  it("#4507 makeGhCache: a per-root cache dir, reset swaps in a fresh dir, the no-root fallback is disposed", () => {
+    const root = tmpDir("ghcache-");
+    const c = makeGhCache({ root });
+    const first = c.env().XDG_CACHE_HOME;
+    assert.equal(first, join(root, "gh-cache")); assert.ok(existsSync(first));
+    c.reset();
+    const second = c.env().XDG_CACHE_HOME;
+    assert.notEqual(second, first); assert.ok(existsSync(second)); assert.ok(!existsSync(first));
+    const tmp = tmpDir("ghcache-tmp-");
+    const f = makeGhCache({ tmp });
+    assert.equal(f.env(), undefined);
+    f.reset();
+    const fb = f.env().XDG_CACHE_HOME;
+    assert.ok(fb.startsWith(join(tmp, "forge-gh-cache-")) && existsSync(fb));
+    f.dispose();
+    assert.ok(!existsSync(fb));
+    c.dispose();
+    assert.ok(!existsSync(second)); assert.equal(c.env(), undefined, "no dir is re-created after the run tears down");
+  });
+
   // ---- #4114 ----
   it("#4114 a push failing once with 'remote unpack failed' then succeeding completes the run", async () => {
     const w = world({ pushErrors: ["error: remote unpack failed: unable to create temporary object directory"] });
@@ -4819,6 +4904,22 @@ describe("context pack modes (forge#4275)", () => {
     assert.deepEqual([m.leaseWrites.at(-1).terminalCode, m.leaseWrites.at(-1).failureClasses], [OUTCOME_CODES.COMPLETED, []]);
   });
 
+  it("#4444 ab: the lane runs its issue's arm, logs it as context_pack and tags context_ab", async () => {
+    const { contextArm } = await import("./context.mjs");
+    const arm = contextArm({ mode: "ab", repo: "o/r", issue: 7 }).mode;
+    const w = withPack(), dir = tmpDir("core-");
+    const r = await run(w, { dir, contextPack: { mode: "ab" } });
+    assert.equal(r.terminalReason, "merged");
+    const plan = builders(w)[0][4];
+    assert.equal(/Context pack \(hints, not proof/.test(plan), arm === "on");
+    const log = readLog(dir, 7);
+    const cp = log.find((e) => e.event === "CONTEXT_PACK"), term = log.find((e) => e.event === "RUN_TERMINAL");
+    assert.deepEqual([cp.mode, cp.context_ab, term.context_pack, term.context_ab], [arm, true, arm, true]);
+    const plain = withPack(), d2 = tmpDir("core-");
+    await run(plain, { dir: d2, contextPack: { mode: "shadow" } });
+    assert.equal("context_ab" in readLog(d2, 7).find((e) => e.event === "RUN_TERMINAL"), false);
+  });
+
   it("forge.yaml engine.context_pack* is read flat; invalid mode is ignored", () => {
     const d = tmpDir("ctxcfg-");
     writeFileSync(join(d, "forge.yaml"), "engine:\n  context_pack: on\n  context_pack_sources: graph,attempts\n  context_pack_bytes: 4096\n");
@@ -5835,3 +5936,163 @@ describe("#4395 lane profile", () => {
     assert.equal(resumed.baselineTokens, null);
   });
 });
+
+describe("#4450 light lane: one builder session, derived contract, upgrade to the full lane", () => {
+  const RT = { path: "test/foo.test.js", id: "foo handles null", command: "node --test test/foo.test.js" };
+  const BODY = "foo crashes on null input in src/foo.js.\n\nExpected behaviour: foo returns null.\n\n- foo must handle a null argument without throwing.\n- Existing callers of foo keep working.";
+  const RESULT = { status: "fixed", summary: "fixed foo", requirement: "foo must handle a null argument without throwing.", repro_test: RT, tests: [{ command: RT.command, result: "pass", fails_without_fix: true }] };
+  const lworld = (o = {}) => {
+    const w = world({ labels: [{ name: "bug" }], body: BODY, result: RESULT, contract: { ...CONTRACT, repro_test: RT }, ...o });
+    w.numstat = o.numstat ?? "5\t1\tsrc/foo.js\n20\t0\ttest/foo.test.js\n";
+    w.rgCalls = []; w.ran = [];
+    w.io.redGreen = async (x) => { w.rgCalls.push(x.command); return o.repro ?? { base: "FAILED", head: "RAN" }; };
+    w.io.runCommand = async (a) => { w.ran.push(a.command); return { rc: 0, output: "" }; };
+    w.io.apiShape = async () => o.api ?? { status: "none", changes: [], unknown: [] };
+    return w;
+  };
+  const events = (dir, name) => readLog(dir, 7).filter((e) => e.event === name);
+  const ON = { light: { mode: "on" } };
+
+  it("nothing triggers: exactly one builder session (no plan) plus the review; the derived contract is frozen and posted", async () => {
+    const w = lworld(), dir = tmpDir("light-");
+    const r = await run(w, { dir, ...ON });
+    assert.equal(r.terminalReason, "merged");
+    assert.equal(builders(w).length, 1, "one builder session");
+    assert.ok(!/PLANNING ONLY/.test(builders(w)[0][4]));
+    assert.match(builders(w)[0][4], /failing regression test first/);
+    assert.equal(reviewers(w).length, 1, "plus the review call");
+    const contract = w.comments.find((c) => c.includes("<!-- FORGE:CONTRACT -->"));
+    assert.match(contract, /\| R1 \| foo must handle a null argument without throwing\. \| deliver \|/);
+    assert.match(contract, /"repro_test"/);
+    assert.equal(events(dir, "LIGHT_ELIGIBILITY")[0].verdict, "eligible");
+    assert.equal(events(dir, "LIGHT_DONE").length, 1);
+    assert.equal(events(dir, "LIGHT_UPGRADE").length, 0);
+    assert.deepEqual(events(dir, "CONTRACT_FROZEN").map((e) => e.derived), ["light"]);
+    assert.ok(w.ran.includes(RT.command), "the engine ran the targeted tests");
+    assert.ok(w.rgCalls.length >= 1, "red/green repro gate ran");
+    const lite = w.comments.filter((c) => c.includes("<!-- FORGE:LITE -->"));
+    assert.equal(lite.length, 1, "#4452: one FORGE:LITE receipt");
+    assert.match(lite[0], /\*\*Outcome:\*\* light/);
+    assert.match(lite[0], /\*\*Diff:\*\* 2 file\(s\), \+25\/-1/);
+    assert.match(lite[0], /\*\*Red\/green:\*\* base FAILED → head RAN/);
+    assert.match(lite[0], /targeted tests: 1 command\(s\), passed/);
+    assert.match(lite[0], /\*\*Cost:\*\* \$\d+\.\d{4} \(true per-session cost/);
+    assert.match(lite[0], /\*\*Eligibility:\*\* eligible \(mode on\)/);
+    assert.equal(typeof events(dir, "LIGHT_DONE")[0].cost_usd, "number");
+  });
+
+  for (const [name, code, o] of [
+    ["oversized diff", "diff_lines", { numstat: "80\t3\tsrc/foo.js\n20\t0\ttest/foo.test.js\n" }],
+    ["non-red repro", "repro_not_red", { repro: { base: "PASSED", head: "RAN" } }],
+    ["API change", "api_shape", { api: { status: "changed", changes: [{ file: "src/foo.js", symbol: "foo", change: "sync-async", before: "def", after: "async def" }], unknown: [] } }],
+    ["risk path", "risk_path", { changed: ["src/auth/session.js", "test/foo.test.js"], numstat: "4\t0\tsrc/auth/session.js\n" }],
+  ]) {
+    it(`${name}: upgrades to the full lane with the digest, keeping the light commits`, async () => {
+      const w = lworld(o), dir = tmpDir("light-up-");
+      await run(w, { dir, ...ON });
+      const up = events(dir, "LIGHT_UPGRADE");
+      assert.equal(up.length, 1);
+      assert.ok(up[0].reasons.some((x) => x.code === code), JSON.stringify(up[0].reasons));
+      const b = builders(w);
+      assert.ok(b.length >= 3, "light session, then the full lane's plan and implement");
+      assert.ok(!/PLANNING ONLY/.test(b[0][4]));
+      assert.match(b[1][4], /PLANNING ONLY/);
+      assert.match(b[1][4], /This is a rerun: the branch already holds commits/);
+      assert.match(b[1][4], /Resume digest of the last run on this branch/);
+      assert.match(b[1][4], new RegExp(`Light-lane upgrade[\\s\\S]*- ${code}:`));
+      const later = w.calls.slice(w.calls.indexOf(b[0]), w.calls.indexOf(b[2])).filter((c) => c[0] === "git"); // light session -> full implement
+      assert.ok(!later.some((c) => ["reset", "rebase", "clean"].includes(c[1]) || (c[1] === "checkout" && c.includes("-B")) || (c[1] === "branch" && c.includes("-D")) || (c[1] === "push" && c.some((x) => /^--force|^-f$/.test(String(x))))), "the light work is never discarded");
+      assert.equal(events(dir, "LIGHT_DONE").length, 0);
+      const lite = w.comments.filter((c) => c.includes("<!-- FORGE:LITE -->"));
+      assert.equal(lite.length, 1, "#4452: the upgraded light lane still posts its receipt");
+      assert.match(lite[0], new RegExp(`\\*\\*Upgrade reasons:\\*\\*[\\s\\S]*- ${code}:`));
+    });
+  }
+
+  it("#4453 the run result carries light, the eligibility verdict and the upgrade reason codes (for the three-way bench)", async () => {
+    const lit = await run(lworld(), { dir: tmpDir("light-res-"), ...ON });
+    assert.equal(lit.light, true); assert.equal(lit.light_eligibility, "eligible"); assert.ok(!("light_upgrade" in lit));
+    const up = await run(lworld({ repro: { base: "PASSED", head: "RAN" } }), { dir: tmpDir("light-res-up-"), ...ON });
+    assert.equal(up.light, false); assert.equal(up.light_eligibility, "eligible"); assert.ok(up.light_upgrade.includes("repro_not_red"), JSON.stringify(up.light_upgrade));
+    const off = await run(lworld(), { dir: tmpDir("light-res-off-"), light: { mode: "off" } });
+    assert.equal(off.light, false); assert.equal(off.light_eligibility, "off"); assert.ok(!("light_upgrade" in off));
+    assert.equal(typeof off.cost_usd, "number"); assert.ok(Number.isFinite(off.wall_ms) && Number.isFinite(off.model_ms), "#4451 fields unchanged");
+  });
+
+  it("shadow (the default) only reports the verdict: the lane keeps plan -> implement", async () => {
+    const w = lworld(), dir = tmpDir("light-sh-");
+    assert.equal((await run(w, { dir })).terminalReason, "merged");
+    const e = events(dir, "LIGHT_ELIGIBILITY")[0];
+    assert.equal(e.mode, "shadow"); assert.equal(e.verdict, "eligible"); assert.equal(e.light, false);
+    assert.equal(builders(w).length, 2);
+    assert.match(builders(w)[0][4], /PLANNING ONLY/);
+    assert.ok(!/Light-lane upgrade/.test(builders(w)[0][4]));
+    assert.ok(!w.comments.some((c) => c.includes("<!-- FORGE:LITE -->")), "#4452: no receipt outside a light lane");
+  });
+
+  /** #4451: lworld plus counting fakes for the overhead the light lane skips; each call notes its position in w.calls */
+  const overhead = (o = {}) => {
+    const w = lworld(o);
+    w.over = { pack: [], hot: [], structure: [] };
+    w.io.contextFacts = async () => { w.over.pack.push(w.calls.length); return { sources: {}, items: [] }; };
+    w.io.hotspots = async (x) => { w.over.hot.push(w.calls.length); return { enabled: true, files: [], base: x.base ?? null }; };
+    w.io.structureDelta = async () => { w.over.structure.push(w.calls.length); return { package_edges_added: [], package_edges_removed: [], import_pairs: [] }; };
+    return w;
+  };
+  it("#4451 a light lane that is not upgraded makes no context-pack, structure or hotspot calls", async () => {
+    const w = overhead(), dir = tmpDir("light-over-");
+    const r = await run(w, { dir, ...ON, contextPack: { mode: "on" } });
+    assert.equal(r.terminalReason, "merged");
+    assert.equal(events(dir, "LIGHT_DONE").length, 1);
+    assert.deepEqual(w.over, { pack: [], hot: [], structure: [] });
+    assert.equal(events(dir, "CONTEXT_PACK").length, 0);
+    // only the merge-time record (local numstat, no structure-delta call) remains; no implement-time delta
+    assert.deepEqual(events(dir, "STRUCTURE_DELTA").map((e) => e.phase), ["merge"]);
+    assert.equal(events(dir, "RUN_TERMINAL")[0].light, true);
+  });
+  it("#4451 an upgraded light lane computes the hotspots and the context pack before the plan call and runs the structure delta", async () => {
+    const w = overhead({ numstat: "80\t3\tsrc/foo.js\n20\t0\ttest/foo.test.js\n" }), dir = tmpDir("light-over-up-");
+    await run(w, { dir, ...ON, contextPack: { mode: "on" } });
+    assert.equal(events(dir, "LIGHT_UPGRADE").length, 1);
+    const plan = w.calls.indexOf(builders(w)[1]);
+    // each fake notes w.calls.length when called, i.e. the index the next call takes: <= plan means before the plan call
+    assert.ok(w.over.hot.some((i) => i <= plan) && w.over.pack.some((i) => i <= plan), JSON.stringify({ plan, ...w.over }));
+    assert.ok(w.over.hot.every((i) => i > w.calls.indexOf(builders(w)[0])), "not before the light session");
+    assert.ok(w.over.structure.length >= 1);
+    assert.equal(events(dir, "RUN_TERMINAL")[0].light, false);
+  });
+  it("#4451 a full lane (light off) keeps its context-pack, structure and hotspot calls", async () => {
+    const w = overhead(), dir = tmpDir("light-over-off-");
+    await run(w, { dir, light: { mode: "off" }, contextPack: { mode: "on" } });
+    assert.ok(w.over.pack.length >= 1 && w.over.hot.length >= 1 && w.over.structure.length >= 1, JSON.stringify(w.over));
+  });
+  it("#4451 the light targeted tests run concurrently, never more than FORGE_HOST_PARALLELISM in flight", async () => {
+    const cmds = ["node --test t1.js", "node --test t2.js", "node --test t3.js", "node --test t4.js"];
+    const w = lworld({ result: { ...RESULT, tests: cmds.map((command) => ({ command, result: "pass" })) } }), dir = tmpDir("light-par-");
+    let live = 0, max = 0;
+    const seen = [];
+    w.io.runCommand = async (a) => { live++; max = Math.max(max, live); seen.push(a.env?.FORGE_HOST_PARALLELISM); await new Promise((r) => setTimeout(r, 5)); live--; return { rc: 0, output: "" }; };
+    const prev = process.env.FORGE_HOST_PARALLELISM;
+    process.env.FORGE_HOST_PARALLELISM = "2";
+    try { await run(w, { dir, ...ON }); } finally { if (prev === undefined) delete process.env.FORGE_HOST_PARALLELISM; else process.env.FORGE_HOST_PARALLELISM = prev; }
+    assert.equal(events(dir, "LIGHT_DONE").length, 1);
+    assert.equal(max, 2, "two in flight at once, capped at the host parallelism");
+    assert.ok(seen.every((x) => x === undefined || x === "1"), `each command gets its worker share: ${seen}`);
+  });
+  it("#4451 lane telemetry records wall time and model time separately", async () => {
+    const w = lworld(), dir = tmpDir("light-time-");
+    const r = await run(w, { dir, ...ON });
+    const model = events(dir, "PHASE_ATTEMPT_USAGE").reduce((n, e) => n + e.duration_ms, 0);
+    assert.ok(model > 0);
+    assert.equal(r.model_ms, model);
+    assert.ok(Number.isFinite(r.wall_ms));
+    const term = w.telemetry.find((t) => t.event === "RUN_TERMINAL");
+    assert.equal(term.model_ms, model); assert.ok(Number.isFinite(term.wall_ms));
+  });
+
+  it("a resumed lane never goes light, even in mode on", async () => {
+    const w = lworld({ remote: "abc\trefs/heads/feat/issue-7-lean\n" }), dir = tmpDir("light-res-");
+    await run(w, { dir, ...ON });
+    assert.equal(events(dir, "LIGHT_DONE").length + events(dir, "LIGHT_UPGRADE").length, 0);
+  });
+});