@runcofactor/cli 0.23.0 → 0.25.0

package/dist/{src-OLQ7ZFHS.js → src-F4UX4PMP.js}

@@ -1387,6 +1387,11 @@ var capScreencastFrames = (frames, cap) => {
 import * as fs10 from "fs/promises";
 var MAX_NOTABLE_EVENTS = 5;
 var MAX_HISTORY_LOOKBACK = 10;
+var MAX_DIVERGENCE_CANDIDATES = 5;
+var MAX_INTENDED_INPUTS = 4;
+var CHURN_MIN_THOUGHTS = 8;
+var CHURN_MEDIAN_MULTIPLE = 1.5;
+var CHURN_MIN_DOM_PROBES = 2;
 var isCleanPassStatus = (s) => s === "passed" || s === "success";
 var isFlakyPassStatus = (s) => s === "flaky_success";
 var isPassStatus = (s) => isCleanPassStatus(s) || isFlakyPassStatus(s);
@@ -1435,6 +1440,7 @@ var writeSummary = async (input) => {
     lines.push("**Hypothesis. Verify before trusting \u2014 root cause may be upstream.**");
     lines.push("");
   }
+  for (const l of buildDivergenceSection(input)) lines.push(l);
   const seedRuns = input.seedRuns ?? [];
   if (seedRuns.length > 0) {
     lines.push("## Seed flows");
@@ -1623,6 +1629,70 @@ var buildHistoryHint = (runs, currentRunId, lastGreenComparison, greenRunAccess)
   return out;
 };
 var formatRelativePrefix = (timestampMs, baselineMs) => baselineMs !== null ? `[${formatRelative(timestampMs - baselineMs)}]` : "[T+?]";
+var computeCandidateUpstreamDivergences = (input) => {
+  if (isCleanPassStatus(input.runStatus)) return [];
+  const steps = input.steps;
+  if (steps.length === 0) return [];
+  const anchor = input.reportedFailure.failedStepOrderIndex;
+  const referencedVars = new Set(input.failedStepReferencedVars ?? []);
+  const allCounts = steps.map((s) => s.thoughtCount ?? 0).sort((a, b) => a - b);
+  const median = allCounts.length === 0 ? 0 : allCounts[Math.floor((allCounts.length - 1) / 2)];
+  const churnThreshold = Math.max(CHURN_MIN_THOUGHTS, median * CHURN_MEDIAN_MULTIPLE);
+  const maxThoughts = allCounts.length > 0 ? allCounts[allCounts.length - 1] : 0;
+  const candidates = [];
+  for (const s of steps) {
+    if (s.status === "failed") continue;
+    if (anchor !== null && s.orderIndex >= anchor) continue;
+    const reasons = [];
+    let highSignal = false;
+    if (s.cacheOutcome === "fallback") {
+      const why = s.cacheFailureCategory ?? s.cacheOutcomeReason;
+      reasons.push(`ejected cache\u2192live${why ? ` (${why})` : ""}; post-state never cache-verified`);
+    }
+    const thoughts = s.thoughtCount ?? 0;
+    const probes = s.domProbeCount ?? 0;
+    if (thoughts >= churnThreshold && probes >= CHURN_MIN_DOM_PROBES) {
+      const lead = thoughts === maxThoughts ? "highest churn in run" : "high agent churn";
+      reasons.push(`${lead} (${thoughts} thoughts, ${probes} DOM probes) yet marked ${s.status}`);
+      highSignal = true;
+    }
+    for (const v of s.variablesSet ?? []) {
+      if (v.extracted && referencedVars.has(v.key)) {
+        reasons.push(
+          `produced $var.${v.key} (extracted), which the failing step depends on \u2014 confirm that value is valid before treating the current page state as external behavior`
+        );
+        highSignal = true;
+      }
+    }
+    if (reasons.length === 0) continue;
+    const intendedInputs = (s.variablesSet ?? []).filter((v) => v.source === "inputValue" && v.value !== null).slice(0, MAX_INTENDED_INPUTS);
+    candidates.push({ step: s, reasons, intendedInputs, highSignal });
+  }
+  candidates.sort(
+    (a, b) => a.highSignal !== b.highSignal ? a.highSignal ? -1 : 1 : a.step.orderIndex - b.step.orderIndex
+  );
+  const selected = candidates.slice(0, MAX_DIVERGENCE_CANDIDATES);
+  selected.sort((a, b) => a.step.orderIndex - b.step.orderIndex);
+  return selected;
+};
+var buildDivergenceSection = (input) => {
+  const candidates = computeCandidateUpstreamDivergences(input);
+  if (candidates.length === 0) return [];
+  const out = [];
+  out.push("## \u26A0 Candidate upstream divergences");
+  out.push(
+    "Heuristic candidates only \u2014 each is a place to START, not a root cause. Confirm or rule out every one by walking backwards and verifying the step's EFFECT (the value selected, the field populated, the record created) from its screenshot/DOM \u2014 not its success flag. This list is NOT exhaustive; an upstream cause can exist with no hint here."
+  );
+  for (const c of candidates) {
+    const name = c.step.name ?? "(unnamed)";
+    const reasons = c.reasons.join("; ");
+    const inputs = c.intendedInputs.length > 0 ? `  [configured inputs: ${c.intendedInputs.map((v) => `${v.key}=${truncate(oneLine(String(v.value)), 40)}`).join(", ")}]` : "";
+    const ref = `  \`${stepRollupRelativePath(c.step.orderIndex, c.step.id)}\``;
+    out.push(`- Step ${c.step.orderIndex} "${name}": ${reasons}.${inputs}${ref}`);
+  }
+  out.push("");
+  return out;
+};
 
 // ../diagnostic-workspace/src/assemble-workspace.ts
 var assembleWorkspace = async (input) => {
@@ -1736,8 +1806,18 @@ var assembleWorkspace = async (input) => {
       durationMs: s.durationMs,
       cacheOutcome: s.cacheOutcome,
       cacheHitSource: s.cacheHitSource,
+      cacheOutcomeReason: s.cacheOutcomeReason,
+      cacheFailureCategory: s.cacheFailureCategory,
+      variablesSet: s.variablesSet,
+      thoughtCount: s.thoughtCount,
+      domProbeCount: s.domProbeCount,
       errorMessage: s.errorMessage
     })),
+    // Variable keys the failing step's node config references (`$var.X`) — drives the
+    // upstream-divergence lineage heuristic. Empty when no failed node / no references.
+    failedStepReferencedVars: runData.failedNodeId ? extractReferencedVarKeys(
+      runData.nodes.find((n) => n.id === runData.failedNodeId)?.configJson
+    ) : [],
     network: eventProjection.network,
     consoleLogs: eventProjection.consoleLogs,
     navigation: eventProjection.navigation,
@@ -1778,6 +1858,26 @@ var assembleWorkspace = async (input) => {
   };
 };
 var isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var VAR_REFERENCE_RE = /\$var\.(\w+(?:\.\w+)*)/g;
+var extractReferencedVarKeys = (configJson) => {
+  if (configJson === null || configJson === void 0) return [];
+  let serialized;
+  try {
+    serialized = typeof configJson === "string" ? configJson : JSON.stringify(configJson);
+  } catch {
+    return [];
+  }
+  if (!serialized) return [];
+  const keys = /* @__PURE__ */ new Set();
+  for (const m of serialized.matchAll(VAR_REFERENCE_RE)) {
+    const path2 = m[1];
+    if (!path2) continue;
+    for (const segment of path2.split(".")) {
+      if (segment) keys.add(segment);
+    }
+  }
+  return [...keys];
+};
 var stringField = (v) => typeof v === "string" && v.length > 0 ? v : null;
 var normalizeTs = (ts) => {
   if (ts === null || ts === void 0) return null;
@@ -1785,12 +1885,45 @@ var normalizeTs = (ts) => {
   const parsed = Date.parse(ts);
   return Number.isFinite(parsed) ? parsed : null;
 };
+var DOM_PROBE_TOOL_NAMES = /* @__PURE__ */ new Set(["browser_run_code", "browser_evaluate"]);
+var projectVariablesSet = (meta) => {
+  const raw = Array.isArray(meta.variablesSet) ? meta.variablesSet : [];
+  const out = [];
+  for (const c of raw) {
+    if (!isPlainObject(c)) continue;
+    const key = stringField(c.key) ?? stringField(c.name);
+    if (!key) continue;
+    const source = stringField(c.source);
+    out.push({
+      key,
+      value: typeof c.value === "string" ? c.value : null,
+      source,
+      extracted: source === "extracted" || typeof c.extractorExpression === "string"
+    });
+  }
+  return out;
+};
 var projectEvents = (runData) => {
   const baselineMs = runData.timeline.startTimestamp ? Date.parse(runData.timeline.startTimestamp) : null;
+  const thoughts = runData.thoughts.map((t) => ({
+    stepId: t.stepId,
+    timestampMs: Date.parse(t.createdAt),
+    toolName: t.toolName,
+    content: t.content
+  }));
+  const thoughtStatsByStep = /* @__PURE__ */ new Map();
+  for (const t of thoughts) {
+    if (!t.stepId) continue;
+    const cur = thoughtStatsByStep.get(t.stepId) ?? { thoughtCount: 0, domProbeCount: 0 };
+    cur.thoughtCount += 1;
+    if (t.toolName && DOM_PROBE_TOOL_NAMES.has(t.toolName)) cur.domProbeCount += 1;
+    thoughtStatsByStep.set(t.stepId, cur);
+  }
   const steps = runData.steps.map((s) => {
     const meta = isPlainObject(s.metadataJson) ? s.metadataJson : {};
     const startedAtMs = s.startedAt ? Date.parse(s.startedAt) : null;
     const finishedAtMs = s.finishedAt ? Date.parse(s.finishedAt) : null;
+    const churn = thoughtStatsByStep.get(s.id) ?? { thoughtCount: 0, domProbeCount: 0 };
     return {
       id: s.id,
       nodeId: s.nodeId,
@@ -1803,15 +1936,14 @@ var projectEvents = (runData) => {
       durationMs: startedAtMs !== null && finishedAtMs !== null ? finishedAtMs - startedAtMs : null,
       errorMessage: s.errorMessage,
       cacheOutcome: stringField(meta.cacheOutcome),
-      cacheHitSource: stringField(meta.cacheHitSource)
+      cacheHitSource: stringField(meta.cacheHitSource),
+      cacheOutcomeReason: stringField(meta.cacheOutcomeReason),
+      cacheFailureCategory: stringField(meta.cacheFailureCategory),
+      variablesSet: projectVariablesSet(meta),
+      thoughtCount: churn.thoughtCount,
+      domProbeCount: churn.domProbeCount
     };
   });
-  const thoughts = runData.thoughts.map((t) => ({
-    stepId: t.stepId,
-    timestampMs: Date.parse(t.createdAt),
-    toolName: t.toolName,
-    content: t.content
-  }));
   const actions = runData.timeline.entries.map((e) => ({
     action: e.action,
     target: e.target ?? null,
@@ -1887,4 +2019,4 @@ export {
   writeStepRollups,
   writeSummary
 };
-//# sourceMappingURL=src-OLQ7ZFHS.js.map
+//# sourceMappingURL=src-F4UX4PMP.js.map