@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-QWMQ74KD.js

@@ -0,0 +1,508 @@
+import {
+  getIntEnv
+} from "./chunk-T7E5JS6N.js";
+import {
+  formatBytes
+} from "./chunk-JLS65NUQ.js";
+import {
+  readCanonicalBuildConfig,
+  selectedBuildConfigCandidate
+} from "./chunk-FKCG7K6H.js";
+import {
+  getConfigPaths
+} from "./chunk-35J4NE6S.js";
+import {
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+
+// src/telemetry/db-size-manager.ts
+import { stat } from "fs/promises";
+
+// src/telemetry/retention-config.ts
+import { existsSync } from "fs";
+var DEFAULTS = {
+  telemetryDays: 90,
+  dbSoftDays: 180,
+  dbWarningDays: 90,
+  backupsDays: 30,
+  backupsMonthlyCount: 3,
+  backupsMaxBytes: 1024 * 1024 * 1024,
+  logsDays: 7,
+  vacuumOnCleanup: true,
+  signalFilesRetentionDays: 90
+};
+function parseClampedEnvInt(envVar, defaultValue, min, max) {
+  const raw = process.env[envVar];
+  if (!raw) return defaultValue;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return defaultValue;
+  if (parsed < min || parsed > max) return defaultValue;
+  return parsed;
+}
+function resolveRetentionConfig(opts) {
+  const config = { ...DEFAULTS };
+  const configFilePath = opts?.configFilePath === null ? null : opts?.configFilePath ?? selectedBuildConfigCandidate(getConfigPaths().projectConfigFile);
+  if (configFilePath !== null && existsSync(configFilePath)) {
+    const read = readCanonicalBuildConfig(configFilePath);
+    if (read.status === "invalid") throw read.error;
+    if (read.status === "valid") {
+      const telemetry = read.config.telemetry;
+      const retention = telemetry && typeof telemetry === "object" && !Array.isArray(telemetry) ? telemetry.retention : void 0;
+      if (retention && typeof retention === "object") {
+        const r = retention;
+        if (typeof r.backups_days === "number" && r.backups_days > 0) {
+          config.backupsDays = r.backups_days;
+        }
+        if (typeof r.backups_monthly_count === "number" && r.backups_monthly_count >= 0) {
+          config.backupsMonthlyCount = r.backups_monthly_count;
+        }
+        if (typeof r.backups_max_bytes === "number" && r.backups_max_bytes >= 0) {
+          config.backupsMaxBytes = r.backups_max_bytes;
+        }
+        if (typeof r.logs_days === "number" && r.logs_days > 0) {
+          config.logsDays = r.logs_days;
+        }
+        if (typeof r.vacuum_on_cleanup === "boolean") {
+          config.vacuumOnCleanup = r.vacuum_on_cleanup;
+        }
+      }
+    }
+  }
+  config.telemetryDays = getIntEnv("BUILD_TELEMETRY_RETENTION_DAYS", config.telemetryDays);
+  config.signalFilesRetentionDays = getIntEnv(
+    "BUILD_TELEMETRY_SIGNALS_RETENTION_DAYS",
+    config.signalFilesRetentionDays
+  );
+  const softDays = parseClampedEnvInt("BUILD_DB_SOFT_RETENTION_DAYS", config.dbSoftDays, 30, 3650);
+  config.dbSoftDays = softDays;
+  config.dbWarningDays = parseClampedEnvInt(
+    "BUILD_DB_WARNING_RETENTION_DAYS",
+    config.dbWarningDays,
+    7,
+    Math.min(softDays, 3650)
+  );
+  return config;
+}
+
+// src/telemetry/db-size-manager.ts
+function parseEnvInt(envVar, defaultValue, min, max) {
+  const value = process.env[envVar];
+  if (!value) return defaultValue;
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed)) {
+    emitWarning(
+      "CFG-002",
+      {
+        taskId: "system",
+        subsystem: "telemetry",
+        executionPhase: "setup"
+      },
+      {
+        severity: "INFO" /* INFO */,
+        metadata: {
+          envVar,
+          invalidValue: value,
+          defaultValue,
+          reason: "Invalid environment variable value"
+        }
+      }
+    );
+    return defaultValue;
+  }
+  if (parsed < min || parsed > max) {
+    emitWarning(
+      "CFG-002",
+      {
+        taskId: "system",
+        subsystem: "telemetry",
+        executionPhase: "setup"
+      },
+      {
+        severity: "INFO" /* INFO */,
+        metadata: {
+          envVar,
+          value: parsed,
+          min,
+          max,
+          defaultValue,
+          reason: "Environment variable out of range"
+        }
+      }
+    );
+    return defaultValue;
+  }
+  return parsed;
+}
+var SOFT_LIMIT = parseEnvInt(
+  "BUILD_DB_SOFT_LIMIT",
+  1610612736,
+  // 1.5GB default - Silent cleanup
+  104857600,
+  // 100MB minimum
+  10737418240
+  // 10GB maximum
+);
+var WARNING_LIMIT = parseEnvInt(
+  "BUILD_DB_WARNING_LIMIT",
+  2147483648,
+  // 2GB default - Warn and aggressive cleanup
+  Math.max(SOFT_LIMIT, 104857600),
+  // Must be >= SOFT_LIMIT
+  10737418240
+  // 10GB maximum
+);
+var HARD_LIMIT = parseEnvInt(
+  "BUILD_DB_HARD_LIMIT",
+  5368709120,
+  // 5GB default - Block writes, require manual intervention
+  Math.max(WARNING_LIMIT, 104857600),
+  // Must be >= WARNING_LIMIT
+  53687091200
+  // 50GB maximum
+);
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var _dbRetention = resolveRetentionConfig({ configFilePath: null });
+var SOFT_RETENTION_DAYS = _dbRetention.dbSoftDays;
+var WARNING_RETENTION_DAYS = _dbRetention.dbWarningDays;
+var VARIANT_EXECUTIONS_RETENTION_WHERE = "completed_at IS NOT NULL AND ((typeof(completed_at) IN ('integer', 'real') AND completed_at < ?) OR (typeof(completed_at) = 'text' AND julianday(completed_at) < julianday(?)))";
+var DbSizeManager = class _DbSizeManager {
+  constructor(dbPath, db) {
+    this.dbPath = dbPath;
+    this.db = db;
+  }
+  dbPath;
+  db;
+  /**
+   * Get current database file size in bytes
+   */
+  async getDbSize() {
+    try {
+      const stats = await stat(this.dbPath);
+      return stats.size;
+    } catch (_error) {
+      return 0;
+    }
+  }
+  /**
+   * Format bytes for human-readable output
+   */
+  /**
+   * Check database size and perform automatic cleanup if needed
+   *
+   * This is the main entry point, designed to run on startup (async, non-blocking).
+   *
+   * Cleanup strategy:
+   * - < 1.5GB: No action
+   * - 1.5-2GB: Silent cleanup (delete >180 day old records)
+   * - 2-5GB: Warn and aggressive cleanup (delete >90 day old records)
+   * - > 5GB: Error, require manual intervention
+   */
+  async checkAndCleanup() {
+    const size = await this.getDbSize();
+    if (size >= HARD_LIMIT) {
+      throw new Error(
+        `Telemetry DB at hard limit (${formatBytes(size)}). Run build telemetry health, then preview build cleanup stale --only telemetry; use --execute to remove eligible stale telemetry or build telemetry checkpoint --vacuum to compact the database`
+      );
+    }
+    if (size >= WARNING_LIMIT) {
+      console.warn(`Telemetry DB >2GB (${formatBytes(size)}). Cleaning aggressively...`);
+      const report = await this.cleanup({
+        olderThan: WARNING_RETENTION_DAYS,
+        vacuum: true
+      });
+      console.warn(`Freed ${formatBytes(report.freedBytes || 0)} from telemetry DB`);
+      return { ...report, level: "warning" };
+    }
+    if (size >= SOFT_LIMIT) {
+      const report = await this.cleanup({
+        olderThan: SOFT_RETENTION_DAYS,
+        vacuum: true
+      });
+      return { ...report, level: "soft" };
+    }
+    return {
+      cleaned: false,
+      size,
+      level: "ok"
+    };
+  }
+  /**
+   * Perform cleanup of old telemetry data
+   *
+   * @param options Cleanup configuration
+   * @returns Cleanup report with statistics
+   */
+  async cleanup(options) {
+    const oldSize = await this.getDbSize();
+    const cutoff = Date.now() - options.olderThan * DAY_MS;
+    if (options.dryRun) {
+      const isoCutoff2 = new Date(cutoff).toISOString();
+      const countMatch = (sql, ...params) => {
+        try {
+          const row = this.db.prepare(sql).get(...params);
+          return row?.count ?? 0;
+        } catch {
+          return 0;
+        }
+      };
+      const deletedRecords2 = countMatch(
+        `SELECT COUNT(*) AS count FROM variant_executions WHERE ${VARIANT_EXECUTIONS_RETENTION_WHERE}`,
+        cutoff,
+        isoCutoff2
+      ) + countMatch(
+        "SELECT COUNT(*) AS count FROM variant_executions_v2 WHERE created_at < ?",
+        isoCutoff2
+      ) + countMatch(
+        "SELECT COUNT(*) AS count FROM variant_results WHERE julianday(completed_at) < julianday(?) AND completed_at IS NOT NULL",
+        isoCutoff2
+      );
+      return {
+        cleaned: false,
+        deletedRecords: deletedRecords2,
+        oldSize,
+        newSize: oldSize,
+        freedBytes: 0,
+        size: oldSize,
+        level: "ok"
+      };
+    }
+    const isoCutoff = new Date(cutoff).toISOString();
+    let deletedRecords = 0;
+    try {
+      this.runInTransaction(() => {
+        const deleteVerificationCommandsResult = this.tolerantRun(
+          `DELETE FROM verification_commands_v2
+            WHERE verification_run_id IN (
+              SELECT vr.verification_run_id
+              FROM verification_runs_v2 vr
+              JOIN variant_executions_v2 ve
+                ON ve.variant_execution_id = vr.variant_execution_id
+              WHERE ve.created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteVerificationRunsResult = this.tolerantRun(
+          `DELETE FROM verification_runs_v2
+            WHERE variant_execution_id IN (
+              SELECT variant_execution_id
+              FROM variant_executions_v2
+              WHERE created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteEvidenceResult = this.tolerantRun(
+          `DELETE FROM deduction_evidence_v2
+            WHERE judge_deduction_id IN (
+              SELECT jd.judge_deduction_id
+              FROM judge_deductions_v2 jd
+              JOIN judge_variant_scores_v2 jvs
+                ON jvs.judge_variant_score_id = jd.judge_variant_score_id
+              JOIN variant_executions_v2 ve
+                ON ve.variant_execution_id = jvs.variant_execution_id
+              WHERE ve.created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteDeductionsResult = this.tolerantRun(
+          `DELETE FROM judge_deductions_v2
+            WHERE judge_variant_score_id IN (
+              SELECT jvs.judge_variant_score_id
+              FROM judge_variant_scores_v2 jvs
+              JOIN variant_executions_v2 ve
+                ON ve.variant_execution_id = jvs.variant_execution_id
+              WHERE ve.created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteScoresResult = this.tolerantRun(
+          `DELETE FROM judge_variant_scores_v2
+            WHERE variant_execution_id IN (
+              SELECT variant_execution_id
+              FROM variant_executions_v2
+              WHERE created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteJudgeRunsResult = this.tolerantRun(
+          `DELETE FROM judge_runs_v2
+            WHERE winner_variant_execution_id IN (
+              SELECT variant_execution_id
+              FROM variant_executions_v2
+              WHERE created_at < ?
+            )
+              AND NOT EXISTS (
+                SELECT 1
+                FROM judge_variant_scores_v2 jvs
+                WHERE jvs.judge_run_id = judge_runs_v2.judge_run_id
+              )`,
+          isoCutoff
+        );
+        this.tolerantRun(
+          `UPDATE judge_runs_v2
+            SET winner_variant_execution_id = NULL
+            WHERE winner_variant_execution_id IN (
+              SELECT variant_execution_id
+              FROM variant_executions_v2
+              WHERE created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteTouchesResult = this.tolerantRun(
+          `DELETE FROM file_touches_v2
+            WHERE variant_execution_id IN (
+              SELECT variant_execution_id
+              FROM variant_executions_v2
+              WHERE created_at < ?
+            )`,
+          isoCutoff
+        );
+        const deleteVariantExecutionsV2Result = this.tolerantRun(
+          "DELETE FROM variant_executions_v2 WHERE created_at < ?",
+          isoCutoff
+        );
+        const variantsResult = this.tolerantRun(
+          `DELETE FROM variant_executions WHERE ${VARIANT_EXECUTIONS_RETENTION_WHERE}`,
+          cutoff,
+          isoCutoff
+        );
+        const deleteVariantResultsResult = this.tolerantRun(
+          "DELETE FROM variant_results WHERE julianday(completed_at) < julianday(?) AND completed_at IS NOT NULL",
+          isoCutoff
+        );
+        deletedRecords = (variantsResult.changes || 0) + (deleteVariantExecutionsV2Result.changes || 0) + (deleteTouchesResult.changes || 0) + (deleteScoresResult.changes || 0) + (deleteDeductionsResult.changes || 0) + (deleteEvidenceResult.changes || 0) + (deleteVerificationCommandsResult.changes || 0) + (deleteVerificationRunsResult.changes || 0) + (deleteJudgeRunsResult.changes || 0) + (deleteVariantResultsResult.changes || 0);
+      });
+    } catch (error) {
+      console.error("Telemetry cleanup failed:", error);
+      throw error;
+    }
+    if (options.vacuum && !options.dryRun) {
+      const VACUUM_FREELIST_THRESHOLD_PAGES = 256;
+      let shouldVacuum = deletedRecords > 0;
+      if (!shouldVacuum) {
+        shouldVacuum = this.getFreelistPageCount() >= VACUUM_FREELIST_THRESHOLD_PAGES;
+      }
+      if (shouldVacuum) {
+        const vacuumStmt = this.db.prepare("VACUUM");
+        vacuumStmt.run();
+      }
+    }
+    const newSize = await this.getDbSize();
+    const freedBytes = oldSize - newSize;
+    return {
+      cleaned: true,
+      deletedRecords,
+      oldSize,
+      newSize,
+      freedBytes,
+      size: newSize,
+      level: "ok"
+    };
+  }
+  /**
+   * Run a unit of work inside a transaction so the delete batch is atomic
+   * (all-or-nothing). Uses better-sqlite3's transaction() (which nests safely
+   * via savepoints) when available; otherwise falls back to explicit
+   * BEGIN/COMMIT/ROLLBACK via exec() so the all-or-nothing contract still holds
+   * on any DatabaseLike (a mid-batch failure rolls back earlier deletes instead
+   * of committing orphans). Only a driver that throws on BEGIN (e.g. a
+   * non-persistent in-memory shim) degrades to a direct call.
+   */
+  runInTransaction(work) {
+    if (this.db.transaction) {
+      this.db.transaction(work)();
+      return;
+    }
+    try {
+      this.db.exec("BEGIN");
+    } catch {
+      work();
+      return;
+    }
+    try {
+      work();
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    }
+  }
+  /**
+   * Read the SQLite freelist page count. Returns 0 when the pragma is
+   * unavailable (e.g. the in-memory shim) so VACUUM gating fails closed toward
+   * "skip" on a no-delete run.
+   */
+  getFreelistPageCount() {
+    try {
+      const result = this.db.pragma("freelist_count");
+      if (Array.isArray(result)) {
+        const row = result[0];
+        return row?.freelist_count ?? 0;
+      }
+      return typeof result === "number" ? result : 0;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Run a cleanup mutation, tolerating only the expected "no such table" error that
+   * historical DBs missing an optional table will raise. Every other error
+   * propagates so the surrounding transaction rolls the whole cleanup back
+   * (all-or-nothing) instead of committing orphaned rows.
+   */
+  tolerantRun(sql, ...params) {
+    try {
+      return this.db.prepare(sql).run(...params);
+    } catch (error) {
+      if (_DbSizeManager.isMissingTableError(error)) {
+        return { changes: 0 };
+      }
+      throw error;
+    }
+  }
+  static isMissingTableError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /no such table/i.test(message);
+  }
+  /**
+   * Get database statistics
+   */
+  async getStats() {
+    const size = await this.getDbSize();
+    let level = "ok";
+    let limitForPercent = SOFT_LIMIT;
+    if (size >= HARD_LIMIT) {
+      level = "critical";
+      limitForPercent = HARD_LIMIT;
+    } else if (size >= WARNING_LIMIT) {
+      level = "warning";
+      limitForPercent = WARNING_LIMIT;
+    } else if (size >= SOFT_LIMIT) {
+      level = "soft";
+      limitForPercent = SOFT_LIMIT;
+    }
+    const percentOfLimit = size / limitForPercent * 100;
+    let recordCount;
+    try {
+      const countStmt = this.db.prepare("SELECT COUNT(*) as count FROM variant_executions");
+      const result = countStmt.get();
+      recordCount = result?.count;
+    } catch {
+    }
+    return {
+      size,
+      sizeFormatted: formatBytes(size),
+      level,
+      percentOfLimit,
+      recordCount
+    };
+  }
+};
+
+export {
+  resolveRetentionConfig,
+  DbSizeManager
+};
+//# sourceMappingURL=chunk-QWMQ74KD.js.map

package/dist/chunk-QX6LOMMH.js

@@ -0,0 +1,158 @@
+// src/core/providers/routing/provider-capabilities.ts
+var PROVIDER_CAPABILITY_MATRIX = {
+  claude: {
+    provider: "claude",
+    // overfit-allow[B]: central registry entry, not a default or fallback
+    costTier: "high",
+    setup: "cloud",
+    speedRating: 3,
+    reasoningRating: 5,
+    reliabilityRating: 4,
+    executionModel: "code-executor",
+    webSearch: { mode: "default" }
+  },
+  cursor: {
+    provider: "cursor",
+    costTier: "low",
+    setup: "hybrid",
+    speedRating: 4,
+    reasoningRating: 3,
+    reliabilityRating: 4,
+    executionModel: "code-executor",
+    webSearch: {
+      mode: "default",
+      // Validated live 2026-08-12: `cursor-agent -p --force` invoked its native
+      // `web_search` tool and returned a correctly grounded current answer with a
+      // source URL. Build imposes no web-tool restriction on cursor, so clearance
+      // needs no argv change — only an accurate capability mode.
+      note: "Native web_search validated live 2026-08-12; Build imposes no web-tool restriction, so no enable flag is required."
+    }
+  },
+  codex: {
+    provider: "codex",
+    costTier: "medium",
+    setup: "local",
+    speedRating: 4,
+    reasoningRating: 4,
+    reliabilityRating: 4,
+    executionModel: "code-executor",
+    webSearch: { mode: "default", enableArgs: ["--enable", "web_search_request"] }
+  },
+  gemini: {
+    provider: "gemini",
+    costTier: "low",
+    setup: "cloud",
+    speedRating: 5,
+    reasoningRating: 3,
+    reliabilityRating: 3,
+    executionModel: "code-executor",
+    webSearch: {
+      mode: "probe",
+      note: "Web-search-capable in model-update; gate native research on a runtime probe."
+    }
+  },
+  opencode: {
+    provider: "opencode",
+    costTier: "medium",
+    setup: "local",
+    speedRating: 4,
+    reasoningRating: 4,
+    reliabilityRating: 4,
+    executionModel: "code-executor",
+    webSearch: {
+      mode: "default",
+      // Validated live 2026-08-12: `opencode run` invoked its native `websearch`
+      // tool and returned a correctly grounded current answer with a source URL.
+      // Build imposes no web-tool restriction on opencode, so clearance needs no
+      // argv change — only an accurate capability mode.
+      note: "Native websearch validated live 2026-08-12; Build imposes no web-tool restriction, so no enable flag is required."
+    }
+  },
+  copilot: {
+    provider: "copilot",
+    costTier: "medium",
+    setup: "local",
+    speedRating: 4,
+    reasoningRating: 3,
+    reliabilityRating: 4,
+    executionModel: "code-executor",
+    webSearch: {
+      mode: "default",
+      note: "Build denies the fetch tool by default; the denial is lifted on a cleared native-research run."
+    }
+  },
+  grok: {
+    provider: "grok",
+    costTier: "medium",
+    setup: "local",
+    speedRating: 3,
+    reasoningRating: 3,
+    reliabilityRating: 3,
+    executionModel: "code-executor",
+    webSearch: {
+      mode: "off",
+      // Not a deferral: analysis-intent runs (every Fusion run) lock Grok's
+      // positive tool list to Read,Grep and add --deny MCPTool(*). Grok's search
+      // surface is MCP-dispatched, so it is unreachable without relaxing that
+      // fail-closed read-only posture — a security decision, not a labelling one.
+      note: "Unreachable on analysis runs: the locked read-only posture allows only Read,Grep and denies MCPTool(*), which is Grok search surface."
+    }
+  },
+  kiro: {
+    provider: "kiro",
+    costTier: "medium",
+    setup: "local",
+    speedRating: 3,
+    reasoningRating: 3,
+    reliabilityRating: 2,
+    executionModel: "code-executor",
+    webSearch: {
+      mode: "probe",
+      note: "Build imposes no web-tool restriction on kiro; native search capability is unvalidated, so clearance requires a live probe."
+    }
+  },
+  pi: {
+    provider: "pi",
+    costTier: "medium",
+    setup: "local",
+    speedRating: 3,
+    reasoningRating: 3,
+    reliabilityRating: 2,
+    executionModel: "code-executor",
+    webSearch: {
+      mode: "off",
+      note: "No native web search tool in Pi built-ins (read, bash, edit, write, grep, find, ls)."
+    }
+  },
+  antigravity: {
+    provider: "antigravity",
+    costTier: "medium",
+    setup: "local",
+    speedRating: 3,
+    reasoningRating: 3,
+    reliabilityRating: 2,
+    executionModel: "code-executor",
+    webSearch: {
+      mode: "probe",
+      note: "Build imposes no web-tool restriction on antigravity; native search capability is unvalidated, so clearance requires a live probe."
+    }
+  }
+};
+function getProviderCapability(provider) {
+  const capability = PROVIDER_CAPABILITY_MATRIX[provider];
+  if (!capability) {
+    throw new Error(`Unknown provider capability: ${provider}`);
+  }
+  return capability;
+}
+function resolveWebSearchMode(provider) {
+  const capability = PROVIDER_CAPABILITY_MATRIX[provider];
+  return capability?.webSearch?.mode ?? "off";
+}
+
+export {
+  PROVIDER_CAPABILITY_MATRIX,
+  getProviderCapability,
+  resolveWebSearchMode
+};
+//# sourceMappingURL=chunk-QX6LOMMH.js.map