@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-ZJB6SQPA.js

@@ -0,0 +1,257 @@
+import {
+  getRuntimeEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/config/feature-flags.ts
+function readTriStateMode(name, fallback) {
+  const raw = getRuntimeEnv(name);
+  if (raw === "off" || raw === "shadow" || raw === "on") {
+    return raw;
+  }
+  return fallback;
+}
+function readDefaultOnBoolean(name) {
+  const raw = getRuntimeEnv(name);
+  if (raw === void 0) return true;
+  const normalized = raw.toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  throw new Error(
+    `Invalid boolean value for ${name}: "${raw}". Expected one of: 1, true, yes, on, 0, false, no, off`
+  );
+}
+var JUDGE_FEATURE_FLAGS = {
+  get JUDGE_V2() {
+    return readDefaultOnBoolean("BUILD_JUDGE_V2");
+  },
+  // Judge Refinement flags (Phase 1-4)
+  get TEST_GATE_FOR_TEST_INTENT() {
+    return getRuntimeEnv("BUILD_TEST_GATE_FOR_TEST_INTENT") !== "0";
+  },
+  // Judge refactoring canary — controls all Phase 1-4 behavior changes
+  // 'off': Legacy behavior (pre-refactor)
+  // 'shadow': Old behavior enforced (same as off); new behavior may be computed for comparison logging
+  // 'on': New behavior active (default after validation)
+  // Gate pattern: `!== 'on'` = legacy path (off + shadow), `=== 'on'` = new path
+  get JUDGE_REFACTOR_V4() {
+    return readTriStateMode("BUILD_JUDGE_REFACTOR_V4", "on");
+  },
+  // Evidence reliability prompt mode (input-first, no post-LLM adjudication)
+  // Controls whether the Signal Reliability appendix is included and marked experimental.
+  // 'off': No reliability appendix
+  // 'shadow': Reliability appendix included with [EXPERIMENTAL] marker
+  // 'on': Reliability appendix included without [EXPERIMENTAL] marker
+  get EVIDENCE_PROPORTIONALITY_GATE() {
+    return readTriStateMode("BUILD_EVIDENCE_PROPORTIONALITY_GATE", "on");
+  },
+  // Scope adequacy signal — detects output disproportionate to task magnitude
+  // 'off': Not computed
+  // 'shadow': Computed + attached (wouldBePenalty), not enforced (appliedPenalty=0)
+  // 'on': Computed + enforced (appliedPenalty = wouldBePenalty)
+  //
+  // Default 'off' (decided 2026-07-09, expired shadow review): six months of
+  // shadow mode produced zero persisted evidence — the signal is not written to
+  // telemetry, not injected into judge prompts, and contributes 0 to scores, so
+  // shadow was pure wasted compute. Promotion requires wiring persistence first;
+  // opt in explicitly via BUILD_SCOPE_ADEQUACY to collect evidence.
+  get SCOPE_ADEQUACY() {
+    return readTriStateMode("BUILD_SCOPE_ADEQUACY", "off");
+  },
+  // Test signal rebalance rollout
+  // 'off'/'shadow': legacy behavior
+  // 'on': intent-gated test weighting behavior
+  get TEST_SIGNAL_REBALANCE() {
+    return readTriStateMode("BUILD_TEST_SIGNAL_REBALANCE", "off");
+  },
+  // Variant differentiation signals — controls M2 prompt instructions,
+  // A2 coherence signal, and A3 scope violation signal
+  // 'off': No differentiation signals added
+  // 'shadow': Signals computed + logged but not injected into prompts
+  // 'on': Signals active in prompts (default)
+  get VARIANT_DIFFERENTIATION_SIGNALS() {
+    return readTriStateMode("BUILD_VARIANT_DIFF_SIGNALS", "on");
+  },
+  // LLM final score authority — use LLM's fs (final score) as winner's qualityScore
+  // 'off': Current behavior (host-aggregated score from ns values)
+  // 'shadow': Log delta between LLM fs and host aggregate, use host aggregate
+  // 'on': Use LLM's fs as winner's qualityScore when present and valid; fall back to host aggregate
+  get LLM_FINAL_SCORE_AUTHORITY() {
+    return readTriStateMode("BUILD_LLM_FINAL_SCORE_AUTHORITY", "on");
+  },
+  // Cross-judge adjudication telemetry — majority comparison when judges disagree
+  // 'off': No adjudication metadata (default)
+  // 'shadow': Compute adjudication and attach metadata, preserving primary winner
+  // 'on': Same as shadow; kept for compatibility, never overrides the primary winner
+  //
+  // Disabled by default: adjudication depends on winnerSelectionMetadata.margin from
+  // the primary judge, but current primary paths do not consistently populate that field.
+  // Cross-judge adjudication is telemetry-only. Overriding a trusted primary with
+  // lower-reliability judges contradicts the purpose of selecting a primary.
+  get CROSS_JUDGE_ADJUDICATION() {
+    return readTriStateMode("BUILD_CROSS_JUDGE_ADJUDICATION", "off");
+  },
+  // Correctness evidence gates — classify evidence signals as verified/neutral for prompt injection
+  // 'off': No evidence classification
+  // 'shadow': Classify and log, use legacy correctness-dominance text
+  // 'on': Replace static correctness-dominance text with evidence-class-aware versions
+  get CORRECTNESS_EVIDENCE_GATES() {
+    return readTriStateMode("BUILD_CORRECTNESS_EVIDENCE_GATES", "on");
+  },
+  // fs_check divergence rationale — validate LLM self-reported score coherence
+  // 'off': Skip all fs_check validation and the prompt rationale request
+  // 'shadow': Request rationale in the prompt + record coherence audit, never invalidate
+  // 'on': Incoherent or missing rationale -> judge-invalid with fallback
+  //
+  // PERMANENT shadow default (decided 2026-07-09, expired shadow review): shadow
+  // keeps the useful behavior (rationale requested from the LLM, coherence recorded
+  // in the audit) while 'on' converts formatting noncompliance into judge
+  // invalidation — pure availability loss, same reasoning as
+  // MX_VALIDATION_ENFORCEMENT below. 'on' remains available for strict/CI use.
+  get FS_DIVERGENCE_RATIONALE() {
+    return readTriStateMode("BUILD_FS_DIVERGENCE_RATIONALE", "shadow");
+  },
+  // Multi-Lens overlay — inject scanner signals and CoreLens anchors into arbiter prompt
+  // 'off': Skip computation entirely
+  // 'shadow': Compute scanner patterns and log to telemetry only; no prompt injection
+  // 'on': Inject scanner/CoreLens signals into arbiter prompt
+  //
+  // Default 'off' (decided 2026-07-09, expired shadow review): six months of
+  // shadow produced a single multi_lens_overlay_shadow telemetry event — far too
+  // little to evaluate the scanner/judge-outcome correlation shadow existed to
+  // measure, while paying a per-run diff scan on every multi-lens evaluation.
+  // Opt in via BUILD_MULTI_LENS_OVERLAY to resume collection or enable injection.
+  get MULTI_LENS_OVERLAY() {
+    return readTriStateMode("BUILD_MULTI_LENS_OVERLAY", "off");
+  },
+  // Judge independence tracking — multi-pair Spearman/agreement rate with CI and alerts
+  // 'off': No independence computation
+  // 'shadow': Compute and log, no alerts
+  // 'on': Compute, log, and emit alerts when convergence thresholds exceeded
+  get JUDGE_INDEPENDENCE_TRACKING() {
+    return readTriStateMode("BUILD_JUDGE_INDEPENDENCE_TRACKING", "on");
+  },
+  // Multi-lens extension (mx) validation enforcement
+  // mx is an explainability payload (lens reasoning + evidence citations) attached to
+  // audit/metadata only — it does NOT affect winner selection. Throwing on malformed mx
+  // is pure availability loss with no correctness upside, so the default is 'shadow'.
+  // 'on':     Throw on invalid/missing mx (strict/CI mode)
+  // 'shadow': Log warning + record in audit, continue without mx (default)
+  // 'off':    Skip mx validation entirely
+  get MX_VALIDATION_ENFORCEMENT() {
+    return readTriStateMode("BUILD_MX_VALIDATION_ENFORCEMENT", "shadow");
+  },
+  // Judge profile — selects the active configuration set for judge prompt construction.
+  // 'stable':       Production default. Deliverable-first ordering validated by AP7.
+  // 'legacy':       Pre-V1 ordering. Escape hatch only; use to revert if regressions found.
+  // 'shadow':       Stable prompt behavior + background shadow evaluation hooks (for canarying new judge logic).
+  // 'experimental': Reserved slot for next-iteration research. No stability guarantee.
+  //
+  // Env var: BUILD_JUDGE_PROFILE
+  get JUDGE_PROFILE() {
+    const raw = getRuntimeEnv("BUILD_JUDGE_PROFILE");
+    if (raw === "stable" || raw === "legacy" || raw === "shadow" || raw === "experimental")
+      return raw;
+    if (raw === "on") return "stable";
+    if (raw === "off") return "legacy";
+    return "stable";
+  },
+  // Test production guidance — controls Changes 2-4 of Multi-Lens judge improvement
+  // Enables test production signal computation, testsExpected heuristic, and tiered scoring rules.
+  // Change 1 (provider workspace filtering) is ungated — always beneficial.
+  //
+  // 'off': No test-production prompt injection.
+  // 'shadow': Test production signal computed and attached to empirical signals.
+  //           No test-production prompt lines or scoring guidance injected.
+  // 'on': Full prompt injection including testsExpected heuristic and tiered scoring rules.
+  //
+  // Default 'off' (decided 2026-07-09, expired shadow review): in shadow the
+  // signal is computed and attached but never injected into prompts (both
+  // consumers gate on === 'on') and never persisted to telemetry, so six months
+  // of shadow produced zero reviewable evidence. Opt in explicitly via
+  // BUILD_TEST_PRODUCTION_GUIDANCE; promotion requires wiring persistence first.
+  get TEST_PRODUCTION_GUIDANCE() {
+    return readTriStateMode("BUILD_TEST_PRODUCTION_GUIDANCE", "off");
+  },
+  // Phase 1 Judge Quality Optimization flags
+  // All default to 'off' — no behavior change at deploy.
+  // 'off': Baseline behavior (control arm)
+  // 'shadow': Compute + log deltas without applying (instrumentation only)
+  // 'on': Active treatment arm behavior
+  // Fix 1: Override FILE: marker suppression when explicit review/analysis task detected
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (negative + positive case canaries)
+  get ANALYSIS_REVIEW_DETECTION() {
+    return readTriStateMode("BUILD_ANALYSIS_REVIEW_DETECTION", "on");
+  },
+  // Fix 2: Inject duplication ratio as pre-LLM factual signal into judge prompt
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (negative live path + unit tests)
+  // Highest residual risk — monitor for boilerplate false positives
+  get DUPLICATE_CONTENT_SIGNAL() {
+    return readTriStateMode("BUILD_DUPLICATE_CONTENT_SIGNAL", "on");
+  },
+  // R1: Add evidence anchor citation instructions to Multi-Lens prompts
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (38/38 valid EIDs, 0% invalid)
+  get EVIDENCE_ANCHOR_CITATIONS() {
+    return readTriStateMode("BUILD_EVIDENCE_ANCHOR_CITATIONS", "on");
+  },
+  // R2: Allow empty strengths/weaknesses arrays when no genuine items exist
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (no lazy arrays with R6/R7 counterbalance)
+  get RATIONALE_EMPTY_ARRAYS() {
+    return readTriStateMode("BUILD_RATIONALE_EMPTY_ARRAYS", "on");
+  },
+  // R3: Per-dimension weight differentiation in criteria-ledger instead of uniform
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (~1-2pt os drift, within tolerance)
+  get CRITERIA_DIMENSION_WEIGHTS() {
+    return readTriStateMode("BUILD_CRITERIA_DIMENSION_WEIGHTS", "on");
+  },
+  // R5: Observe no-output materialization (variant-health); never pre-exclude from judge prompt.
+  // Default shadow: record would-exclude impact without hiding variants from the judge.
+  get NO_OUTPUT_PREEVAL_GATE() {
+    return readTriStateMode("BUILD_NO_OUTPUT_PREEVAL_GATE", "shadow");
+  },
+  // R6+R7: Prompt instructions for unique observations and real weaknesses (dedup/contamination)
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (distinct strengths, no fabrication)
+  get RATIONALE_DEDUP() {
+    return readTriStateMode("BUILD_RATIONALE_DEDUP", "on");
+  }
+};
+var ORCHESTRATOR_FEATURE_FLAGS = {
+  get CROSS_PROVIDER_PIVOT() {
+    return readTriStateMode("BUILD_CROSS_PROVIDER_PIVOT", "off");
+  },
+  /**
+   * Intent pipeline rollout gate (planning/decomposition front-door integration).
+   * - 'off': Keep legacy/manual front-door behavior
+   * - 'shadow': Run new path for comparison/telemetry, keep legacy output
+   * - 'on': Use intent pipeline output in production
+   */
+  get INTENT_PIPELINE() {
+    return readTriStateMode("BUILD_INTENT_PIPELINE", "on");
+  },
+  /**
+   * Task split strategy selector for planning task split commands.
+   * - 'auto' (default): Derive from INTENT_PIPELINE (off->rule, shadow->shadow, on->llm)
+   * - 'rule': Always use legacy rule-based splitter
+   * - 'shadow': Run both splitters and keep rule-based output
+   * - 'llm': Use LLM decomposition path with rule fallback on failures
+   */
+  get INTENT_TASK_SPLITTER_MODE() {
+    const raw = getRuntimeEnv("BUILD_INTENT_TASK_SPLITTER_MODE");
+    if (raw === "rule" || raw === "shadow" || raw === "llm" || raw === "auto") {
+      return raw;
+    }
+    return "auto";
+  },
+  /**
+   * Zero-flag compete: discover variants via the config resolver without explicit --variant flags.
+   * Opt-in via BUILD_FEATURE_COMPETE_ZERO_FLAG=1.
+   */
+  get COMPETE_ZERO_FLAG() {
+    return getRuntimeEnv("BUILD_FEATURE_COMPETE_ZERO_FLAG") === "1";
+  }
+};
+
+export {
+  JUDGE_FEATURE_FLAGS,
+  ORCHESTRATOR_FEATURE_FLAGS
+};
+//# sourceMappingURL=chunk-ZJB6SQPA.js.map

package/dist/chunk-ZL6E4HMY.js

@@ -0,0 +1,42 @@
+// src/core/providers/readiness-display.ts
+import chalk from "chalk";
+function getProviderReadinessDisplay(status) {
+  switch (status) {
+    case "contained-ready":
+    case "normal-auth-ready":
+      return { normalized: "ready", label: "Ready" };
+    case "contained-auth-needed":
+    case "normal-auth-needed":
+      return { normalized: "needs_auth", label: "Needs authentication" };
+    case "installed-but-unverified":
+      return { normalized: "installed_unverified", label: "Installed; auth checked on first run" };
+    case "unavailable":
+      return { normalized: "missing", label: "Not installed" };
+    case "broken":
+      return { normalized: "broken", label: "Broken" };
+  }
+}
+function colorProviderReadinessText(status, text) {
+  const display = getProviderReadinessDisplay(status);
+  switch (display.normalized) {
+    case "ready":
+      return chalk.green(text);
+    case "needs_auth":
+    case "broken":
+      return chalk.red(text);
+    case "missing":
+      return chalk.dim(text);
+    case "installed_unverified":
+      return chalk.yellow(text);
+  }
+}
+function colorProviderReadinessLabel(status) {
+  return colorProviderReadinessText(status, getProviderReadinessDisplay(status).label);
+}
+
+export {
+  getProviderReadinessDisplay,
+  colorProviderReadinessText,
+  colorProviderReadinessLabel
+};
+//# sourceMappingURL=chunk-ZL6E4HMY.js.map

package/dist/chunk-ZMLOC3DW.js

@@ -0,0 +1,62 @@
+import {
+  overlayPathsIntoIndex,
+  readRequestedRootMarkdown
+} from "./chunk-YO5BAJ55.js";
+import {
+  isCommitEligibleStatusEntry,
+  isNewDisallowedRootMarkdown,
+  readTrackedToolOutputRootsFor
+} from "./chunk-5EQN56OZ.js";
+import {
+  parseGitStatus
+} from "./chunk-5KQETTNS.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+
+// src/orchestrator/executors/fast-commit-paths.ts
+async function selectFastCommitPaths(worktreePath, statusEntries, onExcludedRootMarkdown) {
+  const trackedRoots = await readTrackedToolOutputRootsFor(
+    worktreePath,
+    statusEntries.flatMap(
+      (entry) => entry.originalPath ? [entry.path, entry.originalPath] : [entry.path]
+    )
+  );
+  const requestedRootMarkdown = await readRequestedRootMarkdown(worktreePath);
+  const filesToAdd = /* @__PURE__ */ new Set();
+  const deletionPaths = /* @__PURE__ */ new Set();
+  for (const entry of statusEntries) {
+    if (!isCommitEligibleStatusEntry(entry, trackedRoots, requestedRootMarkdown)) {
+      if (isNewDisallowedRootMarkdown(entry, requestedRootMarkdown)) {
+        onExcludedRootMarkdown?.(entry);
+      }
+      continue;
+    }
+    filesToAdd.add(entry.path);
+    if (entry.originalPath) {
+      filesToAdd.add(entry.originalPath);
+      deletionPaths.add(entry.originalPath);
+    }
+    if (entry.indexStatus === "D" || entry.worktreeStatus === "D") deletionPaths.add(entry.path);
+  }
+  return { filesToAdd, deletionPaths };
+}
+async function stageCommitEligibleChanges(worktreePath) {
+  const status = await execGit(["status", "--porcelain", "--untracked-files=all"], {
+    cwd: worktreePath
+  });
+  if (status.exitCode !== 0) {
+    throw new Error(status.stderr.trim() || "could not read worktree status");
+  }
+  const { filesToAdd } = await selectFastCommitPaths(worktreePath, parseGitStatus(status.stdout));
+  await execGit(["reset"], { cwd: worktreePath });
+  await overlayPathsIntoIndex(worktreePath, [...filesToAdd]);
+  const staged = await execGit(["diff", "--cached", "--quiet"], { cwd: worktreePath });
+  return staged.exitCode === 1;
+}
+
+export {
+  selectFastCommitPaths,
+  stageCommitEligibleChanges
+};
+//# sourceMappingURL=chunk-ZMLOC3DW.js.map

package/dist/chunk-ZORW64QH.js

@@ -0,0 +1,101 @@
+import {
+  NATIVE_TELEMETRY_UNAVAILABLE_MARKER,
+  NODE_VERSION_MISMATCH_MARKER
+} from "./chunk-TAJPCXSB.js";
+import {
+  BUILD_SQLITE_REQUIRE_NATIVE,
+  coerceEnvValue
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/runtime/node-runtime.ts
+import { createRequire } from "module";
+var SUPPORTED_NODE_MAJORS = [24, 26];
+function isSupportedNodeMajor(major) {
+  return SUPPORTED_NODE_MAJORS.includes(major);
+}
+function formatSupportedNodeMajors() {
+  return SUPPORTED_NODE_MAJORS.map((major) => `v${major}.x`).join(" or ");
+}
+function parseNodeMajor(version) {
+  const major = version.replace(/^v/, "").split(".")[0];
+  return Number.parseInt(major ?? "", 10);
+}
+function isEnabled(value) {
+  return /^(1|true|yes|on)$/i.test(value?.trim() ?? "");
+}
+function isTestRuntime(env = process.env) {
+  return env.NODE_ENV === "test" || isEnabled(env.VITEST);
+}
+function shouldRequireNativeSqlite(env = process.env) {
+  const configured = env[BUILD_SQLITE_REQUIRE_NATIVE.name];
+  if (configured !== void 0 && configured !== "") {
+    return coerceEnvValue(BUILD_SQLITE_REQUIRE_NATIVE, configured);
+  }
+  return isTestRuntime(env) ? false : BUILD_SQLITE_REQUIRE_NATIVE.default === true;
+}
+function prepareDiagnosticRuntime(_version = process.version, env = process.env) {
+  env.BUILD_SQLITE_REQUIRE_NATIVE = "0";
+}
+function isDiagnosticInvocation({ command, args, bareMode }) {
+  if (command === void 0) {
+    return bareMode !== "tui";
+  }
+  if (command === "--help" || command === "-h" || command === "help" || command === "--version" || command === "-V") {
+    return true;
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    return true;
+  }
+  return (command === "doctor" || command === "d") && !args.includes("--fix");
+}
+function loadBetterSqlite3() {
+  const nodeRequire = createRequire(import.meta.url);
+  return nodeRequire("better-sqlite3");
+}
+function assertBuildRuntimeReady(options = {}) {
+  const version = options.version ?? process.version;
+  const env = options.env ?? process.env;
+  const currentMajor = parseNodeMajor(version);
+  const allowUnsupportedNode = isEnabled(env.BUILD_ALLOW_UNSUPPORTED_NODE);
+  if (!isSupportedNodeMajor(currentMajor) && !allowUnsupportedNode) {
+    const command = options.command ? ` for \`build ${options.command}\`` : "";
+    throw new Error(
+      [
+        `Error: ${NODE_VERSION_MISMATCH_MARKER}${command}.`,
+        `Required: ${formatSupportedNodeMajors()}`,
+        `Current: ${version}`,
+        "Select a supported Node major and rebuild native dependencies before retrying.",
+        "See docs/TROUBLESHOOTING.md#node-version-mismatch."
+      ].join("\n")
+    );
+  }
+  if (options.requiresNativeTelemetry === false || !shouldRequireNativeSqlite(env)) {
+    return;
+  }
+  try {
+    const Database = (options.loadNativeDatabase ?? loadBetterSqlite3)();
+    const database = new Database(":memory:");
+    database.close();
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      [
+        `Error: ${NATIVE_TELEMETRY_UNAVAILABLE_MARKER} under Node ${version}.`,
+        `better-sqlite3 readiness check failed: ${detail}`,
+        `Reinstall Build under Node ${version}: npm install -g @ebrindley/build (source checkout: rm -rf node_modules && npm ci)`,
+        "Set BUILD_SQLITE_REQUIRE_NATIVE=0 only for an explicit lossy fallback."
+      ].join("\n")
+    );
+  }
+}
+
+export {
+  isSupportedNodeMajor,
+  formatSupportedNodeMajors,
+  parseNodeMajor,
+  shouldRequireNativeSqlite,
+  prepareDiagnosticRuntime,
+  isDiagnosticInvocation,
+  assertBuildRuntimeReady
+};
+//# sourceMappingURL=chunk-ZORW64QH.js.map