@gluecharm-lab/easyspecs-cli 0.3.3 → 0.3.5

package/commands.md

@@ -178,7 +178,7 @@ Each row lists **command-specific CLI tokens**, then **what configuration applie
 | `auth status`                                                    | —                                                                                                                                                          | Reads session file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | `run synthesis`                                                  | —                                                                                                                                                          | Single SRS-9 context pass (same as extension **Run Analysis**). `**requireOpenCode`** → executable + credentials unless skip flag. Uses `**merged.pipelineOpenCode**` from `**config.json**`. `**--promote` / `--no-promote**` controls promotion after success.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `run synthesis resume-missing`, `run synthesis resume-synthesis` | Optional `**--worktree <path>**`                                                                                                                           | Same implementation: resolves checkout via `--worktree` or stored snapshot (`[resolveAdHocCheckoutRoot](../../src/cli/main.ts)`). OpenCode + `**merged.pipelineOpenCode**`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `analysis`                                                       | Optional tail: `**--force-new-context-analysis**`, `**--no-worktree**` / `**--noworktree**` (**SRS-71**: use **`<repoRoot>`** as the analysis checkout; no detached temp worktree). **`--upload`** → usage exit. **`--synthesis-only`**: accepted as a **hidden** Commander option (legacy scripts); **ignored** with one stderr **`[deprecated]`** line (**SRS-60**). | **SRS-32** full **Factory** loop: synthesis convergence (until no missing artefacts), coverage, zero-ref, report, **link mapping**, index assembly; **Phase 7** backend sync is skipped in CLI (**`skipBackendSync`**). **On success:** always promotes **`.gluecharm/context`** from the analysis worktree into **`<repoRoot>`** unless **`--no-promote`** or the checkout is already the repo root (stderr **`[pipeline:analysis]`**); **`easyspecs.analysis.promoteContextToWorkspace`** does **not** apply to this step. Push context with **`upload context`** / **`upload republish`** after analysis if you need cloud sync. Factory timing from `**merged.factory`** + `**--ci**` defaults. Debug: `**easyspecs.factory.debug**`. OpenCode options from `**merged.pipelineOpenCode**`. **SRS-46:** if `**easyspecs.factory.cloudContextAnalyzed`** is `**true**` and `**--force-new-context-analysis**` is absent, exits **0** without running the Factory (`**analysisSkipped**`, …). **SRS-59:** stale worktree registration recovery — see **§ Analysis git checkout** below. |
+| `analysis`                                                       | Optional tail: `**--force-new-context-analysis**`, `**--no-worktree**` / `**--noworktree**` (**SRS-71**: use **`<repoRoot>`** as the analysis checkout; no detached temp worktree). **`--zero-reference-convergence=strict|best_effort`** (**SRS-73** — overrides `**easyspecs.factory.zeroReferenceRemediation.convergence**` for this run). **`--upload`** → usage exit. **`--synthesis-only`**: accepted as a **hidden** Commander option (legacy scripts); **ignored** with one stderr **`[deprecated]`** line (**SRS-60**). | **SRS-32** full **Factory** loop: synthesis convergence (until no missing artefacts), coverage, zero-ref, report, **link mapping**, index assembly; **Phase 7** backend sync is skipped in CLI (**`skipBackendSync`**). **On success:** always promotes **`.gluecharm/context`** from the analysis worktree into **`<repoRoot>`** unless **`--no-promote`** or the checkout is already the repo root (stderr **`[pipeline:analysis]`**); **`easyspecs.analysis.promoteContextToWorkspace`** does **not** apply to this step. Push context with **`upload context`** / **`upload republish`** after analysis if you need cloud sync. Factory timing from `**merged.factory`** + `**--ci**` defaults. Debug: `**easyspecs.factory.debug**`. OpenCode options from `**merged.pipelineOpenCode**`. **SRS-46:** if `**easyspecs.factory.cloudContextAnalyzed`** is `**true**` and `**--force-new-context-analysis**` is absent, exits **0** without running the Factory (`**analysisSkipped**`, …). **SRS-59:** stale worktree registration recovery — see **§ Analysis git checkout** below. |
 | `update context`                                                 | Optional `**--no-worktree**` / `**--noworktree**` (**SRS-71**). **SRS-60** removed `**--upload**`.                                                                                                  | **SRS-55:** incremental context refresh — baseline → git delta → analysis checkout → `**changes-since-date.md`** → optional remediation → **`--promote` / `--no-promote**` (global) → persist `**lastRunAt**`. With **`--no-worktree`**, the checkout is **`<repoRoot>`** (no temp worktree; seed/promote steps that would copy repo → same repo are skipped). Run **`upload context`** separately if you need cloud sync.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `diagnose reference-coverage`                                    | `**--root workspace**` | `**--root worktree**`, optional `**--worktree <path>**`                                                                           | Gate when `**easyspecs.diagnose.zeroReference.maxPercentNonReferenced**` is a finite number (not `**null**`): failure when metric exceeds it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `diagnose coordination-duplicates`                               | Same `**--root**` / `**--worktree**`                                                                                                                       | `**easyspecs.diagnose.coordinationDuplicates.strict**`: when `**true**` (default), duplicate/orphan issues fail the exit code.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |

package/dist/main.cjs

@@ -11226,11 +11226,13 @@ function mergeEasyspecsFactoryBlock(base, over) {
   const b = base ?? {};
   const o = over ?? {};
   const updateContext = b.updateContext || o.updateContext ? { ...b.updateContext ?? {}, ...o.updateContext ?? {} } : void 0;
+  const zeroReferenceRemediation = b.zeroReferenceRemediation || o.zeroReferenceRemediation ? { ...b.zeroReferenceRemediation ?? {}, ...o.zeroReferenceRemediation ?? {} } : void 0;
   const out = {
     ...b,
     ...o,
     backoff: { ...b.backoff ?? {}, ...o.backoff ?? {} },
-    ...updateContext ? { updateContext } : {}
+    ...updateContext ? { updateContext } : {},
+    ...zeroReferenceRemediation ? { zeroReferenceRemediation } : {}
   };
   const backoffKeys = Object.keys(out.backoff ?? {});
   const topKeys = Object.keys(out).filter((k) => k !== "backoff");
@@ -11652,6 +11654,8 @@ function getEasyspecsMergedConfigValue(es, fullKey) {
       return es.factory?.cloudContextAnalyzedAt;
     case "easyspecs.analysis.cloudContextAnalyzedAt":
       return es.analysis?.cloudContextAnalyzedAt;
+    case "easyspecs.factory.zeroReferenceRemediation.convergence":
+      return es.factory?.zeroReferenceRemediation?.convergence;
     default:
       return void 0;
   }
@@ -11706,6 +11710,8 @@ function mergeEasyspecsCliSettings(cfg, overrides = {}) {
   if (ci && maxOuter === 0) {
     maxOuter = CI_DEFAULT_MAX_OUTER;
   }
+  const zrCfg = readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.factory.zeroReferenceRemediation.convergence") === "best_effort" ? "best_effort" : "strict";
+  const zeroReferenceRemediationConvergence = overrides.zeroReferenceRemediationConvergence ?? zrCfg;
   const factory = {
     initialDelayMs: readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.factory.backoff.initialDelayMs") ?? 3e4,
     backoffMultiplier: readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.factory.backoff.multiplier") ?? 2,
@@ -11713,7 +11719,8 @@ function mergeEasyspecsCliSettings(cfg, overrides = {}) {
     maxOuterIterationsPerPhase: maxOuter,
     maxMacroPingPongCycles: readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.factory.maxPingPongCycles") ?? 5,
     synthesisRemediationShareBackoff: readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.factory.synthesisRemediationShareBackoff") !== false,
-    debugPhases: readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.factory.debug") === true
+    debugPhases: readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.factory.debug") === true,
+    zeroReferenceRemediationConvergence
   };
   const openCodeChildEnv = buildOpenCodeProviderEnvFromConfig(cfg, overrides.repoRoot);
   const projectConfigOverlay = cfg.easyspecs?.openCodeRuntime?.projectConfigOverlay;
@@ -14602,7 +14609,8 @@ function runOpenCodeAgent(cwd, args, options) {
     const child = (0, import_child_process2.spawn)(cmd, args, {
       cwd,
       shell: USE_SHELL,
-      env: spawnEnv
+      env: spawnEnv,
+      stdio: ["ignore", "pipe", "pipe"]
     });
     let childResourceLogged = false;
     let cpuBaseline;
@@ -22445,6 +22453,25 @@ async function runGenerateContextFactory(deps) {
     contextDir: ""
   };
   let pingPong = 0;
+  let zrDegradedSummary;
+  function syncRemediationAuditDegraded(paths, outerAttemptsUsed) {
+    zrDegradedSummary = { converged: false, remainingPaths: paths, outerAttemptsUsed };
+    const a = deps.remediationConvergenceAudit;
+    if (a) {
+      a.converged = false;
+      a.remainingPaths = paths;
+      a.outerAttemptsUsed = outerAttemptsUsed;
+    }
+  }
+  function clearRemediationAuditConverged() {
+    zrDegradedSummary = void 0;
+    const a = deps.remediationConvergenceAudit;
+    if (a) {
+      a.converged = true;
+      delete a.remainingPaths;
+      delete a.outerAttemptsUsed;
+    }
+  }
   try {
     if (!deps.readiness) {
       setRowTimed("diagnose_readiness", "succeeded", "Readiness context omitted (narrow unit test).");
@@ -22500,6 +22527,15 @@ async function runGenerateContextFactory(deps) {
       await post();
     }
     outer: while (true) {
+      if (pingPong > 0) {
+        zrDegradedSummary = void 0;
+      }
+      if (deps.remediationConvergenceAudit) {
+        const a = deps.remediationConvergenceAudit;
+        delete a.converged;
+        delete a.remainingPaths;
+        delete a.outerAttemptsUsed;
+      }
       if (isAborted(signal)) {
         setRowTimed("synthesis_convergence", "cancelled", "Stopped.");
         await post();
@@ -22682,15 +22718,27 @@ async function runGenerateContextFactory(deps) {
         }
         const remFailures = typeof rem.signals?.failures === "number" && Number.isFinite(rem.signals.failures) ? rem.signals.failures : 0;
         if (remFailures === 0) {
+          clearRemediationAuditConverged();
           break;
         }
         remIter += 1;
         if (config.maxOuterIterationsPerPhase > 0 && remIter >= config.maxOuterIterationsPerPhase) {
-          setRowTimed(
-            "zero_reference_remediation_convergence",
-            "failed",
-            `${String(remFailures)} path(s) still failing after ${String(config.maxOuterIterationsPerPhase)} attempt(s).`
-          );
+          const capDetail = `${String(remFailures)} path(s) still failing after ${String(config.maxOuterIterationsPerPhase)} attempt(s).`;
+          const zrMode = config.zeroReferenceRemediationConvergence ?? "strict";
+          if (zrMode === "best_effort") {
+            const sig = rem.signals;
+            const fpRaw = sig?.failedPaths;
+            const failedPathsRem = Array.isArray(fpRaw) && fpRaw.every((p) => typeof p === "string") ? fpRaw : [];
+            setRowTimed(
+              "zero_reference_remediation_convergence",
+              "succeeded",
+              `Degraded (best-effort): ${capDetail}`
+            );
+            syncRemediationAuditDegraded(failedPathsRem, config.maxOuterIterationsPerPhase);
+            await post();
+            break;
+          }
+          setRowTimed("zero_reference_remediation_convergence", "failed", capDetail);
           await post();
           return fail("Zero-reference remediation did not converge.");
         }
@@ -22711,8 +22759,10 @@ async function runGenerateContextFactory(deps) {
         }
         remDelay = computeNextBackoffDelay(remDelay, config.backoffMultiplier, config.maxDelayMs);
       }
-      setRowTimed("zero_reference_remediation_convergence", "succeeded");
-      await post();
+      if (row(phases, "zero_reference_remediation_convergence")?.status !== "succeeded") {
+        setRowTimed("zero_reference_remediation_convergence", "succeeded");
+        await post();
+      }
       if (isAborted(signal)) {
         setRowTimed("link_mapping_pipeline", "cancelled");
         await post();
@@ -22837,7 +22887,13 @@ async function runGenerateContextFactory(deps) {
     }
     setRowTimed("backend_context_sync", "succeeded", up.message);
     await post();
-    return fin({ ok: true, message: "Analysis complete.", totalElapsedMs: macroEnd() });
+    const zrPayload = zrDegradedSummary;
+    return fin({
+      ok: true,
+      message: "Analysis complete.",
+      totalElapsedMs: macroEnd(),
+      ...zrPayload ? { zeroReferenceRemediation: zrPayload } : {}
+    });
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     return fail(msg);
@@ -25275,6 +25331,7 @@ async function runRemediationPipelineZeroRefPass(p) {
   let cancelled = false;
   let completed = 0;
   let failures = 0;
+  const failedPathSet = /* @__PURE__ */ new Set();
   const limit = Math.max(1, Math.min(64, p.maxConcurrent));
   let nextIndex = 0;
   async function worker() {
@@ -25307,10 +25364,12 @@ async function runRemediationPipelineZeroRefPass(p) {
           completed += 1;
         } else if (!r.cancelled) {
           failures += 1;
+          failedPathSet.add(fp);
         }
         await p.onFileDone?.(fp, r);
       } catch (e) {
         failures += 1;
+        failedPathSet.add(fp);
         const msg = e instanceof Error ? e.message : String(e);
         await p.onFileDone?.(fp, { ok: false, message: msg });
       }
@@ -25321,7 +25380,8 @@ async function runRemediationPipelineZeroRefPass(p) {
   if (p.abortSignal?.aborted) {
     cancelled = true;
   }
-  return { cancelled, completed, failures };
+  const failedPaths = [...failedPathSet].sort((a, b) => a.localeCompare(b));
+  return { cancelled, completed, failures, failedPaths };
 }
 
 // src/pipelines/coverage/coverageExecutionReport.ts
@@ -25338,7 +25398,7 @@ function formatMetric(value) {
   }
   return "\u2014";
 }
-function formatReferenceCoverageExecutionReportMarkdown(coverageData, noActions) {
+function formatReferenceCoverageExecutionReportMarkdown(coverageData, noActions, remainingRemediationFailures) {
   const o = coverageData;
   const m = o.metrics ?? {};
   const generatedAt = typeof o.generatedAt === "string" ? o.generatedAt : formatMetric(o.generatedAt);
@@ -25375,6 +25435,18 @@ function formatReferenceCoverageExecutionReportMarkdown(coverageData, noActions)
     }
     lines.push("");
   }
+  const backlog = remainingRemediationFailures && remainingRemediationFailures.length > 0 ? [...remainingRemediationFailures].sort((a, b) => a.localeCompare(b)) : [];
+  if (backlog.length > 0) {
+    lines.push("## Remediation backlog (non-converged)", "");
+    lines.push(
+      "Factory **best-effort** remediation ended with these paths still failing the zero-reference pool:",
+      ""
+    );
+    for (const fp of backlog) {
+      lines.push(`- ${fp}`);
+    }
+    lines.push("");
+  }
   const iso = (/* @__PURE__ */ new Date()).toISOString();
   lines.push(
     "## Revision",
@@ -25384,7 +25456,7 @@ function formatReferenceCoverageExecutionReportMarkdown(coverageData, noActions)
   );
   return lines.join("\n");
 }
-function validateReferenceCoverageExecutionReportMarkdown(body) {
+function validateReferenceCoverageExecutionReportMarkdown(body, options) {
   const errors = [];
   const checks = [
     { re: /^#\s+Reference coverage execution report\s*$/m, label: "`# Reference coverage execution report`" },
@@ -25396,6 +25468,11 @@ function validateReferenceCoverageExecutionReportMarkdown(body) {
       errors.push(`Missing required heading ${c.label}`);
     }
   }
+  if (options?.requireRemediationBacklogSection === true) {
+    if (!/^##\s+Remediation backlog \(non-converged\)\s*$/m.test(body)) {
+      errors.push("Missing required heading `## Remediation backlog (non-converged)`");
+    }
+  }
   return errors.length === 0 ? { ok: true } : { ok: false, errors };
 }
 function collectNoActionRowsFromRoutingDoc(doc) {
@@ -25463,8 +25540,11 @@ async function runCoverageExecutionReport(p) {
     return { ok: false, error: routingRead.error };
   }
   const noActions = collectNoActionRowsFromRoutingDoc(routingRead.doc);
-  const md = formatReferenceCoverageExecutionReportMarkdown(cov.data, noActions);
-  const val = validateReferenceCoverageExecutionReportMarkdown(md);
+  const backlog = p.remainingRemediationFailures?.length ? p.remainingRemediationFailures : void 0;
+  const md = formatReferenceCoverageExecutionReportMarkdown(cov.data, noActions, backlog);
+  const val = validateReferenceCoverageExecutionReportMarkdown(md, {
+    requireRemediationBacklogSection: backlog !== void 0 && backlog.length > 0
+  });
   if (!val.ok) {
     return { ok: false, error: `Report markdown invalid: ${val.errors.join("; ")}` };
   }
@@ -25568,13 +25648,15 @@ function buildFactoryPipelineRegistry(cb) {
     exitCondition: FACTORY_PIPELINE_EXIT_CONDITIONS.zero_reference_remediation_convergence ?? "",
     async run(_input, _ctx) {
       const rem = await cb.runRemediationPass();
+      const failedPaths = Array.isArray(rem.failedPaths) ? rem.failedPaths : [];
+      const signals = { failures: rem.failures, failedPaths };
       if (rem.cancelled) {
-        return { ok: false, cancelled: true, message: rem.message ?? "Remediation cancelled.", signals: { failures: rem.failures } };
+        return { ok: false, cancelled: true, message: rem.message ?? "Remediation cancelled.", signals };
       }
       if (!rem.ok) {
-        return { ok: false, message: rem.message ?? "Remediation failed.", signals: { failures: rem.failures } };
+        return { ok: false, message: rem.message ?? "Remediation failed.", signals };
       }
-      return { ok: true, signals: { failures: rem.failures }, message: rem.message };
+      return { ok: true, signals, message: rem.message };
     }
   };
   const linkMapping = {
@@ -25623,6 +25705,7 @@ function buildFactoryPipelineRegistry(cb) {
 function buildFactoryDepsHeadless(input) {
   const { storageContext, repoRoot, agentsDirFs, buildOpenCodeOptions, log, signal, macroConfig } = input;
   const inPlace = input.inPlace === true;
+  const remediationConvergenceAudit = {};
   let adHocWorktree;
   let macroFinalize;
   let macroSourceBranch;
@@ -25789,9 +25872,9 @@ function buildFactoryDepsHeadless(input) {
       onAgentLaunched: () => noteOpenCodeAgentLaunched()
     });
     if (poolRes.cancelled) {
-      return { ok: false, cancelled: true, failures: poolRes.failures, message: "Remediation stopped." };
+      return { ok: false, cancelled: true, failures: poolRes.failures, failedPaths: poolRes.failedPaths, message: "Remediation stopped." };
     }
-    return { ok: true, failures: poolRes.failures };
+    return { ok: true, failures: poolRes.failures, failedPaths: poolRes.failedPaths };
   };
   const runExecutionReport = async () => {
     const ar = analysisRoot();
@@ -25803,10 +25886,13 @@ function buildFactoryDepsHeadless(input) {
       return { ok: false, message: execLayout.error };
     }
     log(`[factory] reference coverage execution report \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    const audit = remediationConvergenceAudit;
+    const remaining = audit.converged === false && Array.isArray(audit.remainingPaths) && audit.remainingPaths.length > 0 ? audit.remainingPaths : void 0;
     const res = await runCoverageExecutionReport({
       repositoryRootAbs: ar,
       abortSignal: signal,
-      diagnosticLog: log
+      diagnosticLog: log,
+      ...remaining ? { remainingRemediationFailures: remaining } : {}
     });
     if (res.ok) {
       return { ok: true, message: `Report: ${path45.basename(res.outputAbsolutePath)}` };
@@ -25887,6 +25973,7 @@ function buildFactoryDepsHeadless(input) {
     },
     ...inPlace ? { analysisInPlace: true } : {},
     readiness: input.readiness,
+    remediationConvergenceAudit,
     config: { ...macroConfig, ...input.synthesisOnly ? { synthesisOnly: true } : {} },
     sleep: (ms) => sleepUntilAborted(ms, signal),
     post: (payload) => {
@@ -29084,7 +29171,27 @@ function formatCliStderrLine(line, useAnsi) {
 }
 
 // src/cli/main.ts
-var PKG_VERSION = "0.3.2";
+function resolveCliPackageVersion() {
+  if (true) {
+    return "0.3.5";
+  }
+  const candidates = [
+    path61.join(__dirname, "..", "package.json"),
+    path61.join(__dirname, "..", "..", "packages", "cli", "package.json")
+  ];
+  for (const pkgPath of candidates) {
+    try {
+      const raw = fs63.readFileSync(pkgPath, "utf8");
+      const j = JSON.parse(raw);
+      if (typeof j.version === "string") {
+        return j.version;
+      }
+    } catch {
+    }
+  }
+  return "0.0.0-dev";
+}
+var PKG_VERSION = resolveCliPackageVersion();
 function isNonEmptyFactoryFailureArray(x) {
   if (!Array.isArray(x) || x.length === 0) {
     return false;
@@ -30040,7 +30147,19 @@ async function main() {
       finish(ExitCode.internal, { ok: false, error: "Unexpected context drift result shape." });
     }
     if (pos[0] === "analysis") {
+      let zrConvCli;
       for (const a of pos.slice(1)) {
+        if (a.startsWith("--zero-reference-convergence=")) {
+          const v = a.slice("--zero-reference-convergence=".length).trim();
+          if (v !== "strict" && v !== "best_effort") {
+            finish(ExitCode.usage, {
+              ok: false,
+              error: `invalid --zero-reference-convergence (use strict or best_effort): ${v}`
+            });
+          }
+          zrConvCli = v;
+          continue;
+        }
         if (a === "--force-new-context-analysis") {
           continue;
         }
@@ -30061,9 +30180,16 @@ async function main() {
         }
         finish(ExitCode.usage, {
           ok: false,
-          error: `unknown analysis flag: ${a} (allowed: --force-new-context-analysis, --in-place, --no-worktree, --noworktree)`
+          error: `unknown analysis flag: ${a} (allowed: --force-new-context-analysis, --in-place, --no-worktree, --noworktree, --zero-reference-convergence=strict|best_effort)`
         });
       }
+      const mergedForAnalysis = mergeEasyspecsCliSettings(repoConfig, {
+        ci: flags.ci,
+        apiBaseUrl: flags.apiBaseUrl,
+        promote: flags.promote,
+        repoRoot,
+        ...zrConvCli ? { zeroReferenceRemediationConvergence: zrConvCli } : {}
+      });
       const forceNewContextAnalysis = positionals.includes("--force-new-context-analysis");
       const analysisInPlace = positionals.includes("--no-worktree") || positionals.includes("--noworktree") || positionals.includes("--in-place");
       const cloudCached = readEasyspecsMergedSetting(
@@ -30095,19 +30221,19 @@ async function main() {
         cliVersion: PKG_VERSION,
         repoRootAbs: repoRoot,
         analysisRootAbs: repoRoot,
-        apiBaseUrl: merged.apiBaseUrl,
-        openCodeExecutable: merged.openCodeExecutable,
-        openCodeSkipCredentialsCheck: merged.openCodeSkipCredentialsCheck,
-        providerEnvFromConfig: merged.openCodeChildEnv,
+        apiBaseUrl: mergedForAnalysis.apiBaseUrl,
+        openCodeExecutable: mergedForAnalysis.openCodeExecutable,
+        openCodeSkipCredentialsCheck: mergedForAnalysis.openCodeSkipCredentialsCheck,
+        providerEnvFromConfig: mergedForAnalysis.openCodeChildEnv,
         repoConfig
       };
       const deps = buildFactoryDepsHeadless({
         storageContext: storage,
         repoRoot,
         agentsDirFs: agentsDir,
-        macroConfig: merged.factory,
+        macroConfig: mergedForAnalysis.factory,
         buildOpenCodeOptions: (checkout) => ({
-          ...merged.pipelineOpenCode
+          ...mergedForAnalysis.pipelineOpenCode
         }),
         log: (line) => logErr(flags, line),
         signal: ctrl.signal,
@@ -30147,7 +30273,8 @@ async function main() {
         cancelled: res.cancelled,
         totalElapsedMs: res.totalElapsedMs,
         error: res.message,
-        ...analysisInPlace ? { analysisInPlace: true } : {}
+        ...analysisInPlace ? { analysisInPlace: true } : {},
+        ...res.zeroReferenceRemediation ? { zeroReferenceRemediation: res.zeroReferenceRemediation } : {}
       };
       if (!res.ok && !res.cancelled && res.factoryFailures && res.factoryFailures.length > 0) {
         analysisEnvelope.factoryFailures = res.factoryFailures;