@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-MQ4TFJAG.js

@@ -0,0 +1,3365 @@
+import {
+  recordReadinessDiagnostic
+} from "./chunk-2OUAEH67.js";
+import {
+  GUARD_KIT_VERSION,
+  classifyGuardState,
+  knowledgeDoctorChecks
+} from "./chunk-DNIOIISW.js";
+import {
+  inspectCiIntegration,
+  renderCiIntegration
+} from "./chunk-S2XIMQJQ.js";
+import {
+  formatPreflightDetails,
+  runExecutionRolesPreflight
+} from "./chunk-DOA5G7IA.js";
+import {
+  getAvailableMemoryGB
+} from "./chunk-WPKLYOAM.js";
+import {
+  detectHostConcurrencyBudget
+} from "./chunk-BZRLSZNV.js";
+import {
+  formatDurationMs
+} from "./chunk-2L36U25O.js";
+import {
+  listPendingNudges,
+  readPendingOfferNotice,
+  renderPendingNudges
+} from "./chunk-KZWGBUIO.js";
+import {
+  DECLARE_STACK_COMMAND,
+  describeDimension,
+  detectStack,
+  isStackDriftKind,
+  isStackUndetectedAndUndeclared,
+  readIntentContract,
+  resolveIntent
+} from "./chunk-VYI4DSZP.js";
+import {
+  readProviderDryRunFreshness
+} from "./chunk-GT6HFKJB.js";
+import {
+  RuntimeRequirements,
+  ensureBuildInitialized,
+  resolveRepoRootForBuildDir
+} from "./chunk-UB7LQITD.js";
+import {
+  hasStrictMcpConfigBeenProbed,
+  isStrictMcpConfigSupported,
+  probeStrictMcpConfig
+} from "./chunk-7HYBSRPZ.js";
+import {
+  planningStorageUnavailableReason
+} from "./chunk-T5XLUYV3.js";
+import {
+  listYamlFiles
+} from "./chunk-6T6NHXK4.js";
+import {
+  loadAllItems
+} from "./chunk-NXH3RX7O.js";
+import {
+  getPlanningRoot
+} from "./chunk-CSXLLEGB.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketPathByKind
+} from "./chunk-V3KLVK7B.js";
+import {
+  ConfigManager
+} from "./chunk-W4BAIQ6L.js";
+import {
+  discoverOpencode
+} from "./chunk-KQYQOXMS.js";
+import {
+  probeProviderCliVersion
+} from "./chunk-S47ISY27.js";
+import {
+  SCHEMA_VERSION,
+  checkSchemaVersion
+} from "./chunk-XIBVFMLQ.js";
+import {
+  SETUP_CHECK_READINESS_OPTIONS,
+  getProviderReadiness,
+  isGateReadyProvider,
+  probeProviderCli,
+  readinessProbeContextForOptions,
+  resolveNamedReadiness,
+  resolveProviderParityLabel,
+  resolveReadinessScope
+} from "./chunk-XTXYIISX.js";
+import {
+  resolvePlanningContextForRoot
+} from "./chunk-BBPIILO2.js";
+import {
+  BooleanFlagSchema,
+  validateCommandOptions
+} from "./chunk-I7SCBHJN.js";
+import {
+  formatSandboxDegradedSummary
+} from "./chunk-3H4MWYIC.js";
+import {
+  detectUnbornBranch,
+  parseCurrentBranchRef
+} from "./chunk-XGU6PBO5.js";
+import {
+  invalidateAuthOutcome,
+  lookupAuthOutcome,
+  recordAuthOutcome
+} from "./chunk-PPZESPJT.js";
+import {
+  TelemetryPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  normalizeEngineId,
+  resolveProviderCliCommand
+} from "./chunk-KKQKWAMF.js";
+import {
+  ProviderRegistry,
+  getProviderConfig,
+  isConfigValidityError
+} from "./chunk-QJ6OEH4K.js";
+import {
+  resolveProvidersConfigPath
+} from "./chunk-35J4NE6S.js";
+import {
+  formatSupportedNodeMajors,
+  isSupportedNodeMajor,
+  parseNodeMajor
+} from "./chunk-ZORW64QH.js";
+import {
+  getDataDir,
+  getUserConfigFile
+} from "./chunk-56WPYDJH.js";
+import {
+  getBuiltInTaskTypesDir,
+  getRejectedPathEnvWarnings,
+  getRepoTaskTypesDir
+} from "./chunk-STW7OFOA.js";
+import {
+  BUILD_CODEX_BACKEND,
+  getRuntimeEnv,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/cli/commands/doctor-ci.ts
+async function checkCiIntegrationHealth(root) {
+  try {
+    const snapshot = await inspectCiIntegration(root);
+    return {
+      name: "CI integration",
+      category: "git",
+      status: "info",
+      fixable: false,
+      message: snapshot.intentError ?? (snapshot.primary === "local" ? "Local CI is configured; host enforcement is not checked by doctor." : snapshot.workflows.length ? "Workflow definitions found; hosted activity and enforcement are not checked by doctor." : "No CI workflow or Local CI hook detected."),
+      details: `${renderCiIntegration(snapshot).join("\n")}
+build ci status can inspect GitHub; build init can review setup.`
+    };
+  } catch {
+    return {
+      name: "CI integration",
+      category: "git",
+      status: "info",
+      fixable: false,
+      message: "CI inspection is unavailable; no configuration was changed."
+    };
+  }
+}
+
+// src/cli/commands/doctor-init-notices.ts
+function checkPendingInitNotices(cwd) {
+  let count = 0;
+  try {
+    count = listPendingNudges(cwd).filter((record) => isStackDriftKind(record.kind)).length;
+  } catch {
+  }
+  if (count === 0) {
+    return {
+      name: "Pending Init Notices",
+      category: "knowledge",
+      status: "pass",
+      message: "No pending init notices",
+      notices_pending: 0
+    };
+  }
+  return {
+    name: "Pending Init Notices",
+    category: "knowledge",
+    status: "info",
+    message: `${count} init notice(s) pending review`,
+    details: "Notices are shown below (human output) or after the summary.",
+    notices_pending: count
+  };
+}
+function checkPendingOfferNotice(cwd) {
+  let notice;
+  try {
+    notice = readPendingOfferNotice(cwd);
+  } catch {
+    notice = void 0;
+  }
+  if (!notice) {
+    return {
+      name: "Knowledge Offer",
+      category: "knowledge",
+      status: "pass",
+      message: "No pending knowledge-kit offer"
+    };
+  }
+  return {
+    name: "Knowledge Offer",
+    category: "knowledge",
+    // Both skip causes (non-interactive, suppressed) are normal headless states.
+    status: "info",
+    message: notice.message,
+    details: `Offer skipped ${notice.skippedAt.slice(0, 10)} (${notice.cause}); it clears when an offer runs.`
+  };
+}
+function renderDoctorPendingNudges(cwd, options, renderOptions = {}) {
+  const policy = {
+    json: options.json === true,
+    quiet: false,
+    verbose: options.verbose === true,
+    debug: false,
+    noColor: false,
+    level: "normal"
+  };
+  try {
+    return renderPendingNudges(cwd, policy, {
+      ...renderOptions,
+      includeAge: true,
+      readOnly: true,
+      includeRecord: (record) => isStackDriftKind(record.kind)
+    });
+  } catch {
+    return { rendered: false, deliveredKeys: [], pendingCount: 0 };
+  }
+}
+
+// src/cli/commands/doctor.ts
+import * as fs3 from "fs/promises";
+import * as os from "os";
+import * as path3 from "path";
+import { fileURLToPath } from "url";
+import chalk2 from "chalk";
+import { Command as Command2 } from "commander";
+import { execa } from "execa";
+import { z as z2 } from "zod";
+
+// src/planning/archive-reconciliation.ts
+function hasArchivedMarker(item) {
+  const fm = item.frontMatter;
+  return typeof fm.archivedAt === "string" && fm.archivedAt.length > 0;
+}
+function indexById(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (!map.has(item.id)) {
+      map.set(item.id, item);
+    }
+  }
+  return map;
+}
+function detectDuplicates(kind, active, archived) {
+  const archivedById = indexById(archived);
+  const issues = [];
+  for (const activeItem of active) {
+    const archivedMatch = archivedById.get(activeItem.id);
+    if (!archivedMatch) continue;
+    const preferred = hasArchivedMarker(archivedMatch) ? "archive" : hasArchivedMarker(activeItem) ? "active" : "archive";
+    issues.push({
+      kind,
+      id: activeItem.id,
+      activePath: activeItem.filePath,
+      archivePath: archivedMatch.filePath,
+      preferred
+    });
+  }
+  return issues;
+}
+function detectDanglingSprintMembership(sprints, activeTaskIds, archivedTaskIds) {
+  const issues = [];
+  for (const sprint of sprints) {
+    const taskIdsRaw = sprint.frontMatter.taskIds;
+    if (!Array.isArray(taskIdsRaw)) continue;
+    for (const taskId of taskIdsRaw) {
+      if (typeof taskId !== "string") continue;
+      if (activeTaskIds.has(taskId)) continue;
+      if (archivedTaskIds.has(taskId)) {
+        issues.push({ sprintId: sprint.id, taskId, reason: "archived-but-listed" });
+      } else {
+        issues.push({ sprintId: sprint.id, taskId, reason: "missing" });
+      }
+    }
+  }
+  return issues;
+}
+function detectOrphanedFollowups(backlogActive, backlogArchived) {
+  const knownBacklogIds = /* @__PURE__ */ new Set();
+  for (const item of [...backlogActive, ...backlogArchived]) {
+    knownBacklogIds.add(item.id);
+  }
+  const issues = [];
+  for (const item of backlogActive) {
+    const spawnedFrom = item.frontMatter.spawnedFrom;
+    if (typeof spawnedFrom !== "string" || spawnedFrom.length === 0) continue;
+    if (!knownBacklogIds.has(spawnedFrom)) {
+      issues.push({ followupId: item.id, parentId: spawnedFrom, followupPath: item.filePath });
+    }
+  }
+  return issues;
+}
+async function detectArchiveReconciliationIssues(planningRoot = getPlanningRoot()) {
+  const taskActiveDir = getBucketPathByKind("task", planningRoot);
+  const taskArchiveDir = getBucketArchivePathByKind("task", planningRoot);
+  const backlogActiveDir = getBucketPathByKind("backlog", planningRoot);
+  const backlogArchiveDir = getBucketArchivePathByKind("backlog", planningRoot);
+  const sprintActiveDir = getBucketPathByKind("sprint", planningRoot);
+  const [activeTasks, archivedTasks, activeBacklog, archivedBacklog, sprints] = await Promise.all([
+    loadAllItems(planningRoot, [taskActiveDir]),
+    loadAllItems(planningRoot, [taskArchiveDir]),
+    loadAllItems(planningRoot, [backlogActiveDir]),
+    loadAllItems(planningRoot, [backlogArchiveDir]),
+    loadAllItems(planningRoot, [sprintActiveDir])
+  ]);
+  const duplicateRecords = [
+    ...detectDuplicates("task", activeTasks, archivedTasks),
+    ...detectDuplicates("backlog", activeBacklog, archivedBacklog)
+  ];
+  const activeTaskIds = new Set(activeTasks.map((t) => t.id));
+  const archivedTaskIds = new Set(archivedTasks.map((t) => t.id));
+  const danglingSprintMembership = detectDanglingSprintMembership(
+    sprints,
+    activeTaskIds,
+    archivedTaskIds
+  );
+  const orphanedFollowups = detectOrphanedFollowups(activeBacklog, archivedBacklog);
+  return {
+    duplicateRecords,
+    danglingSprintMembership,
+    orphanedFollowups,
+    totalIssues: duplicateRecords.length + danglingSprintMembership.length + orphanedFollowups.length
+  };
+}
+function formatArchiveReconciliationReport(report) {
+  if (report.totalIssues === 0) return "";
+  const lines = [];
+  if (report.duplicateRecords.length > 0) {
+    lines.push(`Duplicate active+archive records: ${report.duplicateRecords.length}`);
+    for (const dup of report.duplicateRecords) {
+      lines.push(`  ${dup.kind} ${dup.id} (keep: ${dup.preferred})`);
+    }
+  }
+  if (report.danglingSprintMembership.length > 0) {
+    lines.push(`Dangling sprint membership: ${report.danglingSprintMembership.length}`);
+    for (const ref of report.danglingSprintMembership) {
+      lines.push(`  sprint ${ref.sprintId} -> ${ref.taskId} (${ref.reason})`);
+    }
+  }
+  if (report.orphanedFollowups.length > 0) {
+    lines.push(`Orphaned followups: ${report.orphanedFollowups.length}`);
+    for (const orphan of report.orphanedFollowups) {
+      lines.push(`  ${orphan.followupId} -> missing parent ${orphan.parentId}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/doctor-claude-alias-advisory.ts
+var CLAUDE_ALIAS_FLAGSHIP_MIN_VERSION = "2.1.219";
+var CLAUDE_BEDROCK_REGION_PREFIX_MIN_VERSION = "2.1.224";
+var CHECK_NAME = "Claude family aliases";
+function parseClaudeCliRelease(version) {
+  const match = /(\d+(?:\.\d+)*)/.exec(version?.trim() ?? "");
+  return match?.[1] ? match[1].split(".").map(Number) : void 0;
+}
+function isOlderThan(version, minimum) {
+  const observed = parseClaudeCliRelease(version);
+  if (!observed) return false;
+  const required = parseClaudeCliRelease(minimum) ?? [];
+  for (let index = 0; index < Math.max(observed.length, required.length); index++) {
+    const left = observed[index] ?? 0;
+    const right = required[index] ?? 0;
+    if (left !== right) return left < right;
+  }
+  return false;
+}
+function claudeAliasAdvisories(input) {
+  const version = input.version?.trim();
+  const advisories = [];
+  if (isOlderThan(version, CLAUDE_ALIAS_FLAGSHIP_MIN_VERSION)) {
+    advisories.push(
+      `Claude CLI ${version} predates ${CLAUDE_ALIAS_FLAGSHIP_MIN_VERSION}: a family alias resolves to an older flagship on this CLI, so registry roles that use one run that older model.`
+    );
+  }
+  if (input.backend === "bedrock" && isOlderThan(version, CLAUDE_BEDROCK_REGION_PREFIX_MIN_VERSION)) {
+    advisories.push(
+      `Claude CLI ${version} predates ${CLAUDE_BEDROCK_REGION_PREFIX_MIN_VERSION}: ANTHROPIC_BEDROCK_REGION_PREFIX is unavailable, so a family alias on Bedrock uses the CLI's own default region prefix.`
+    );
+  }
+  return advisories;
+}
+async function checkClaudeAliasAdvisory() {
+  let command;
+  let prefixArgs;
+  try {
+    const resolved = resolveProviderCliCommand("claude");
+    command = resolved.command;
+    prefixArgs = resolved.prefixArgs ?? [];
+  } catch {
+    return {
+      name: CHECK_NAME,
+      category: "providers",
+      status: "info",
+      message: "Claude CLI not configured; skipping family-alias version advisory"
+    };
+  }
+  const version = await probeProviderCliVersion({ command, prefixArgs });
+  if (!version) {
+    return {
+      name: CHECK_NAME,
+      category: "providers",
+      status: "info",
+      message: "Claude CLI version not reported; family-alias resolution not assessed"
+    };
+  }
+  if (!parseClaudeCliRelease(version)) {
+    return {
+      name: CHECK_NAME,
+      category: "providers",
+      status: "info",
+      message: `Claude CLI version "${version}" carries no release number; family-alias resolution not assessed`
+    };
+  }
+  const { resolveClaudeBackend } = await import("./model-resolver-JFZ2MHOJ.js");
+  const backend = resolveClaudeBackend(process.env, process.cwd());
+  const advisories = claudeAliasAdvisories({ version, backend });
+  if (advisories.length === 0) {
+    return {
+      name: CHECK_NAME,
+      category: "providers",
+      status: "pass",
+      message: `Claude CLI ${version} resolves family aliases to the current flagship`
+    };
+  }
+  return {
+    name: CHECK_NAME,
+    category: "providers",
+    status: "info",
+    message: advisories.join(" "),
+    details: `Upgrade the Claude CLI to ${CLAUDE_BEDROCK_REGION_PREFIX_MIN_VERSION} or newer, or redirect the alias with ANTHROPIC_DEFAULT_{OPUS,SONNET,HAIKU}_MODEL. Build passes the alias through by design; the CLI owns what the family means. See docs/PROVIDER_SETUP.md.`
+  };
+}
+
+// src/cli/commands/doctor-configured-providers.ts
+function explicitDefaultsProviderIds(sources) {
+  const ids = [];
+  for (const source of sources) {
+    if (source.type !== "project" && source.type !== "user" || !source.exists) continue;
+    const providers = source.data?.defaults?.providers;
+    if (providers && typeof providers === "object") ids.push(...Object.keys(providers));
+  }
+  return ids;
+}
+function configuredProviderIds(config, sources) {
+  const enabled = Object.entries(config?.providers ?? {}).filter(([, providerConfig]) => providerConfig?.enabled).map(([providerId]) => providerId);
+  return [...enabled, ...explicitDefaultsProviderIds(sources)];
+}
+
+// src/cli/commands/doctor-fix-summary.ts
+function describeUnrepairedChecks(checks) {
+  const manual = checks.filter((c) => !c.fixable && (c.status === "warn" || c.status === "fail"));
+  if (manual.length === 0) return void 0;
+  return `--fix does not repair ${manual.length} remaining issue(s): ${manual.map((c) => c.name).join(", ")}. Follow the instructions in their messages above.`;
+}
+
+// src/cli/commands/doctor-guard.ts
+import { promises as fs } from "fs";
+import * as path from "path";
+var GUARD_DIR_REL = path.join(".build-project", "guard");
+var GUARD_LOCK_REL = path.join(GUARD_DIR_REL, "checks.lock");
+var INIT_INSTALL_CMD = "build init --guardrails";
+var INIT_REINSTALL_CMD = "build init --guardrails --reinstall-guard";
+async function readGuardLock(repoRoot) {
+  try {
+    const raw = await fs.readFile(path.join(repoRoot, GUARD_LOCK_REL), "utf8");
+    const parsed = JSON.parse(raw);
+    const version = typeof parsed.version === "string" ? parsed.version : typeof parsed.kitVersion === "string" ? parsed.kitVersion : typeof parsed.kit_version === "string" ? parsed.kit_version : void 0;
+    const container = parsed.files ?? parsed.hashes;
+    let files = [];
+    if (Array.isArray(container)) {
+      files = container.filter((f) => typeof f === "string");
+    } else if (container && typeof container === "object") {
+      files = Object.keys(container);
+    }
+    return { version, files };
+  } catch {
+    return null;
+  }
+}
+var defaultGuardInspector = async (repoRoot) => {
+  const state = classifyGuardState(repoRoot).state;
+  const lock = await readGuardLock(repoRoot);
+  return {
+    state,
+    bundledVersion: GUARD_KIT_VERSION,
+    installedVersion: lock?.version,
+    generatedFiles: lock?.files
+  };
+};
+async function checkGuardrails(repoRoot, options = {}) {
+  const inspect = options.inspect ?? defaultGuardInspector;
+  let inspection;
+  try {
+    inspection = await inspect(repoRoot);
+  } catch (error) {
+    return [
+      {
+        name: "Guardrails",
+        category: "guardrails",
+        status: "info",
+        message: "guardrail kit status unavailable",
+        details: error instanceof Error ? error.message : String(error)
+      }
+    ];
+  }
+  if (!inspection) {
+    return [
+      {
+        name: "Guardrails",
+        category: "guardrails",
+        status: "info",
+        message: "guardrail kit module unavailable",
+        details: "Guard kit could not be loaded in this install; guardrails status is unknown."
+      }
+    ];
+  }
+  return [checkForState(inspection)];
+}
+function checkForState(inspection) {
+  const { state, bundledVersion, installedVersion, generatedFiles } = inspection;
+  switch (state) {
+    case "absent":
+      return {
+        name: "Guardrails",
+        category: "guardrails",
+        status: "info",
+        message: "guardrail kit not installed",
+        details: `Optional: install the read-only guardrail kit with "${INIT_INSTALL_CMD}".`
+      };
+    case "current":
+      return {
+        name: "Guardrails",
+        category: "guardrails",
+        status: "pass",
+        message: `guardrail kit current (version ${installedVersion ?? bundledVersion}); run build guard verify`
+      };
+    case "upgradable":
+      return {
+        name: "Guardrails",
+        category: "guardrails",
+        status: "info",
+        message: `guardrail kit upgradable (installed ${installedVersion ?? "unknown"}, bundled ${bundledVersion}); run build guard verify after upgrade`,
+        details: `Run "${INIT_INSTALL_CMD}" to upgrade, then "build guard verify" (config.json is preserved).`
+      };
+    case "tampered":
+      return {
+        name: "Guardrails",
+        category: "guardrails",
+        status: "warn",
+        message: "guardrail kit modified (hash mismatch)",
+        details: formatMismatchDetails(generatedFiles)
+      };
+    case "partial":
+      return {
+        name: "Guardrails",
+        category: "guardrails",
+        status: "warn",
+        message: "guardrail kit incomplete (missing lock or generated files)",
+        details: formatMismatchDetails(generatedFiles)
+      };
+  }
+}
+function formatMismatchDetails(generatedFiles) {
+  const suffix = `Run "${INIT_REINSTALL_CMD}" to restore the generated guard files.`;
+  if (generatedFiles && generatedFiles.length > 0) {
+    return `Generated guard files: ${generatedFiles.join(", ")}. ${suffix}`;
+  }
+  return suffix;
+}
+
+// src/cli/commands/doctor-metrics.ts
+import chalk from "chalk";
+import { Command } from "commander";
+import { z } from "zod";
+async function loadTelemetryHealthTracker() {
+  const mod = await import("./telemetry-health-tracker-4GFW2EMP.js");
+  return mod.TelemetryHealthTracker;
+}
+var DoctorMetricsOptionsSchema = z.object({
+  json: BooleanFlagSchema.optional(),
+  prometheus: BooleanFlagSchema.optional(),
+  verbose: BooleanFlagSchema.optional()
+}).strict();
+var DoctorMetricsMonitorOptionsSchema = z.object({
+  interval: z.number().optional(),
+  json: BooleanFlagSchema.optional(),
+  prometheus: BooleanFlagSchema.optional()
+}).strict();
+function buildUnavailableHealthMetrics() {
+  return {
+    queueDepth: 0,
+    fallbackMode: false,
+    errorRate: 0,
+    databaseHealthy: false,
+    lastErrorTimestamp: null,
+    errorsLastHour: 0,
+    unresolvedErrors: 0
+  };
+}
+function isHealthSchemaPresent(db) {
+  const row = db.prepare(
+    "SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = 'telemetry_errors' LIMIT 1"
+  ).get();
+  return row !== void 0;
+}
+async function openTelemetryDb() {
+  const { openConfiguredTelemetryDb } = await import("./storage-access-I3V5LER7.js");
+  const TelemetryHealthTracker = await loadTelemetryHealthTracker();
+  const readonlyResult = openConfiguredTelemetryDb();
+  if (!readonlyResult.db) {
+    return readonlyResult;
+  }
+  const { dbPath } = readonlyResult;
+  if (isHealthSchemaPresent(readonlyResult.db)) {
+    return readonlyResult;
+  }
+  readonlyResult.db.close();
+  const writableResult = openConfiguredTelemetryDb({ writable: true });
+  if (!writableResult.db) {
+    return writableResult;
+  }
+  try {
+    new TelemetryHealthTracker(writableResult.db);
+  } catch (error) {
+    writableResult.db.close();
+    return {
+      db: null,
+      dbPath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  writableResult.db.close();
+  return openConfiguredTelemetryDb();
+}
+function readDoctorMetricsOptions(command) {
+  const globals = command.optsWithGlobals();
+  return validateCommandOptions(DoctorMetricsOptionsSchema, {
+    json: globals.json,
+    prometheus: globals.prometheus,
+    verbose: globals.verbose
+  });
+}
+async function collectHealthMetrics(db) {
+  const TelemetryHealthTracker = await loadTelemetryHealthTracker();
+  const tracker = new TelemetryHealthTracker(db);
+  const queueDepth = 0;
+  const fallbackMode = false;
+  const health = tracker.getHealthMetrics(queueDepth, fallbackMode);
+  const metrics = {
+    queueDepth: health.queue_depth,
+    fallbackMode: health.fallback_mode_active,
+    errorRate: health.error_rate,
+    databaseHealthy: health.database_healthy,
+    lastErrorTimestamp: health.last_error_timestamp || null,
+    errorsLastHour: health.errors_last_hour,
+    unresolvedErrors: health.unresolved_errors
+  };
+  try {
+    const mttr = tracker.calculateMTTR(24);
+    metrics.mttr = {
+      meanTimeToResolution: Math.round(mttr.mean_time_to_resolution),
+      p50: Math.round(mttr.p50_resolution_time),
+      p95: Math.round(mttr.p95_resolution_time),
+      p99: Math.round(mttr.p99_resolution_time),
+      resolutionRate: mttr.resolution_rate,
+      errorCount24h: mttr.error_count_last_24h
+    };
+  } catch (_error) {
+  }
+  return metrics;
+}
+function formatMetricsJson(metrics, extras = {}) {
+  try {
+    getDataDir();
+  } catch {
+  }
+  const pathEnvWarnings = getRejectedPathEnvWarnings();
+  return JSON.stringify(
+    {
+      status: getHealthStatus(metrics),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uptime: Math.floor(process.uptime()),
+      metrics,
+      ...extras.telemetryDb ? { telemetryDb: extras.telemetryDb } : {},
+      ...extras.databaseError ? { databaseError: extras.databaseError } : {},
+      ...pathEnvWarnings.length > 0 ? { pathEnvWarnings } : {}
+    },
+    null,
+    2
+  );
+}
+function formatMetricsPrometheus(metrics) {
+  const lines = [];
+  lines.push("# HELP build_error_rate Error rate as decimal (0.0-1.0)");
+  lines.push("# TYPE build_error_rate gauge");
+  lines.push(`build_error_rate ${metrics.errorRate.toFixed(4)}`);
+  lines.push("# HELP build_database_healthy Database health status (1=healthy, 0=unhealthy)");
+  lines.push("# TYPE build_database_healthy gauge");
+  lines.push(`build_database_healthy ${metrics.databaseHealthy ? 1 : 0}`);
+  lines.push("# HELP build_errors_last_hour Number of errors in last hour");
+  lines.push("# TYPE build_errors_last_hour gauge");
+  lines.push(`build_errors_last_hour ${metrics.errorsLastHour}`);
+  lines.push("# HELP build_unresolved_errors Number of unresolved errors");
+  lines.push("# TYPE build_unresolved_errors gauge");
+  lines.push(`build_unresolved_errors ${metrics.unresolvedErrors}`);
+  if (metrics.mttr) {
+    lines.push("# HELP build_mttr_ms Mean time to resolution in milliseconds");
+    lines.push("# TYPE build_mttr_ms gauge");
+    lines.push(`build_mttr_ms ${metrics.mttr.meanTimeToResolution}`);
+    lines.push("# HELP build_mttr_p50_ms 50th percentile time to resolution (ms)");
+    lines.push("# TYPE build_mttr_p50_ms gauge");
+    lines.push(`build_mttr_p50_ms ${metrics.mttr.p50}`);
+    lines.push("# HELP build_mttr_p95_ms 95th percentile time to resolution (ms)");
+    lines.push("# TYPE build_mttr_p95_ms gauge");
+    lines.push(`build_mttr_p95_ms ${metrics.mttr.p95}`);
+    lines.push("# HELP build_mttr_p99_ms 99th percentile time to resolution (ms)");
+    lines.push("# TYPE build_mttr_p99_ms gauge");
+    lines.push(`build_mttr_p99_ms ${metrics.mttr.p99}`);
+    lines.push("# HELP build_resolution_rate Error resolution rate (0.0-1.0)");
+    lines.push("# TYPE build_resolution_rate gauge");
+    lines.push(`build_resolution_rate ${metrics.mttr.resolutionRate.toFixed(4)}`);
+    lines.push("# HELP build_error_count_24h Error count in last 24 hours");
+    lines.push("# TYPE build_error_count_24h gauge");
+    lines.push(`build_error_count_24h ${metrics.mttr.errorCount24h}`);
+  }
+  lines.push(`# Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  return `${lines.join("\n")}
+`;
+}
+function formatMetricsTable(metrics, verbose = false) {
+  const lines = [];
+  lines.push(chalk.bold.cyan("\nBuild Telemetry Metrics\n"));
+  const status = getHealthStatus(metrics);
+  const statusColor = status === "healthy" ? chalk.green : status === "degraded" ? chalk.yellow : chalk.red;
+  const statusIcon = status === "healthy" ? "OK" : status === "degraded" ? "Warning: " : "Error";
+  lines.push(
+    `${statusColor(statusIcon)} Status:                ${statusColor(status.toUpperCase())}`
+  );
+  lines.push(`Error Rate:           ${(metrics.errorRate * 100).toFixed(2)}%`);
+  lines.push(
+    `${metrics.databaseHealthy ? "OK" : "Error"} Database:             ${metrics.databaseHealthy ? chalk.green("Healthy") : chalk.red("Unhealthy")}`
+  );
+  if (metrics.errorsLastHour > 0) {
+    lines.push(chalk.yellow(`Warning: Errors (last hour):   ${metrics.errorsLastHour}`));
+  } else {
+    lines.push("OK Errors (last hour):    0");
+  }
+  if (metrics.unresolvedErrors > 0) {
+    lines.push(chalk.yellow(`Warning: Unresolved:           ${metrics.unresolvedErrors}`));
+  } else {
+    lines.push("OK Unresolved:            0");
+  }
+  if (verbose && metrics.lastErrorTimestamp) {
+    const lastErrorTime = new Date(metrics.lastErrorTimestamp);
+    const minutesAgo = Math.floor((Date.now() - lastErrorTime.getTime()) / 6e4);
+    lines.push(`Last Error:           ${minutesAgo} minutes ago`);
+  }
+  if (verbose && metrics.mttr) {
+    lines.push(chalk.bold.cyan("\nResolution Metrics (24h)\n"));
+    lines.push(
+      `Time: MTTR (mean):          ${formatDurationMs(metrics.mttr.meanTimeToResolution)}`
+    );
+    lines.push(`MTTR (P50):           ${formatDurationMs(metrics.mttr.p50)}`);
+    lines.push(`MTTR (P95):           ${formatDurationMs(metrics.mttr.p95)}`);
+    lines.push(`MTTR (P99):           ${formatDurationMs(metrics.mttr.p99)}`);
+    lines.push(`OK Resolution Rate:      ${(metrics.mttr.resolutionRate * 100).toFixed(1)}%`);
+    lines.push(`Error Count (24h):    ${metrics.mttr.errorCount24h}`);
+  }
+  if (verbose && metrics.lastErrorTimestamp) {
+    lines.push(chalk.bold.cyan("\nDetails\n"));
+    lines.push(`Last Error: ${metrics.lastErrorTimestamp}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function getHealthStatus(metrics) {
+  if (!metrics.databaseHealthy) {
+    return "unhealthy";
+  }
+  if (metrics.errorRate > 0.1 || metrics.unresolvedErrors > 0) {
+    return "degraded";
+  }
+  return "healthy";
+}
+async function displayDatabaseStatus(options = {}) {
+  const { db, dbPath, error } = await openTelemetryDb();
+  if (!db) {
+    const metrics = buildUnavailableHealthMetrics();
+    if (options.json) {
+      console.log(
+        formatMetricsJson(metrics, {
+          telemetryDb: dbPath,
+          databaseError: error ?? "Telemetry database unavailable"
+        })
+      );
+      process.exit(1);
+    }
+    console.log(chalk.yellow(`Warning: ${error ?? "Telemetry database not found"}`));
+    console.log(`  Path: ${dbPath}`);
+    console.log("  Run: build init");
+    process.exit(1);
+  }
+  try {
+    const metrics = await collectHealthMetrics(db);
+    if (options.json) {
+      console.log(formatMetricsJson(metrics, { telemetryDb: dbPath }));
+    } else if (options.prometheus) {
+      console.log(formatMetricsPrometheus(metrics));
+    } else {
+      console.log(formatMetricsTable(metrics, options.verbose ?? false));
+    }
+  } catch (error2) {
+    if (options.json) {
+      const metrics = buildUnavailableHealthMetrics();
+      console.log(
+        formatMetricsJson(metrics, {
+          telemetryDb: dbPath,
+          databaseError: error2 instanceof Error ? error2.message : String(error2)
+        })
+      );
+      process.exit(1);
+    }
+    console.error(
+      chalk.red("Failed to collect health metrics:"),
+      error2 instanceof Error ? error2.message : String(error2)
+    );
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+}
+async function monitorHealth(options) {
+  const { db, dbPath, error } = await openTelemetryDb();
+  if (!db) {
+    if (options.json) {
+      const metrics = buildUnavailableHealthMetrics();
+      console.log(
+        formatMetricsJson(metrics, {
+          telemetryDb: dbPath,
+          databaseError: error ?? "Telemetry database unavailable"
+        })
+      );
+      process.exit(1);
+    }
+    console.log(chalk.yellow(`Warning: ${error ?? "Telemetry database not found"}`));
+    console.log(`  Path: ${dbPath}`);
+    console.log("  Run: build init");
+    return;
+  }
+  const interval = (options.interval || 2) * 1e3;
+  const isJson = options.json || false;
+  const isPrometheus = options.prometheus || false;
+  try {
+    while (true) {
+      const metrics = await collectHealthMetrics(db);
+      if (isJson) {
+        console.log(formatMetricsJson(metrics));
+      } else if (isPrometheus) {
+        console.log(formatMetricsPrometheus(metrics));
+      } else {
+        console.clear?.();
+        console.log(formatMetricsTable(metrics, false));
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+  } catch (error2) {
+    console.error(
+      chalk.red("Error Monitoring error:"),
+      error2 instanceof Error ? error2.message : String(error2)
+    );
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+}
+function createDoctorMetricsCommand() {
+  const metricsCmd = new Command("metrics");
+  metricsCmd.description(
+    "Monitor telemetry-derived operational metrics (not the install doctor)\n\nNote: For install / provider auth diagnostics use `build doctor`.\n`build doctor metrics` reports runtime telemetry from the local SQLite store.\n\nExamples:\n  build doctor metrics                    # Show metrics status\n  build doctor metrics --json             # Output as JSON\n  build doctor metrics --prometheus       # Prometheus format\n  build doctor metrics monitor            # Real-time monitoring\n  build doctor metrics monitor --interval 5  # Update every 5 seconds"
+  );
+  const checkCmd = new Command("check");
+  checkCmd.description("Run telemetry metrics check and display results");
+  checkCmd.option("--json", "Output as JSON");
+  checkCmd.option("--prometheus", "Output in Prometheus text format");
+  checkCmd.option("-v, --verbose", "Show detailed information");
+  checkCmd.action(async function() {
+    const validatedOptions = readDoctorMetricsOptions(this);
+    const { db, dbPath, error } = await openTelemetryDb();
+    if (!db) {
+      const metrics = buildUnavailableHealthMetrics();
+      if (validatedOptions.json) {
+        console.log(
+          formatMetricsJson(metrics, {
+            telemetryDb: dbPath,
+            databaseError: error ?? "Telemetry database unavailable"
+          })
+        );
+        process.exit(1);
+      }
+      console.log(chalk.yellow(`Warning: ${error ?? "Telemetry database not found"}`));
+      console.log(`  Path: ${dbPath}`);
+      console.log("  Run: build init");
+      process.exit(1);
+    }
+    let degraded = false;
+    try {
+      const metrics = await collectHealthMetrics(db);
+      const status = getHealthStatus(metrics);
+      degraded = status !== "healthy";
+      if (validatedOptions.json) {
+        console.log(formatMetricsJson(metrics, { telemetryDb: dbPath }));
+      } else if (validatedOptions.prometheus) {
+        console.log(formatMetricsPrometheus(metrics));
+      } else {
+        console.log(formatMetricsTable(metrics, validatedOptions.verbose));
+      }
+    } finally {
+      db.close();
+    }
+    if (degraded) process.exit(1);
+  });
+  const monitorCmd = new Command("monitor");
+  monitorCmd.description("Watch telemetry metrics in real-time");
+  monitorCmd.option("--interval <seconds>", "Update interval in seconds", "2");
+  monitorCmd.option("--json", "Output as JSON");
+  monitorCmd.option("--prometheus", "Output in Prometheus text format");
+  monitorCmd.action(async (options) => {
+    const monitorOptions = {
+      interval: options.interval ? Number.parseInt(String(options.interval), 10) : 2,
+      json: Boolean(options.json),
+      prometheus: Boolean(options.prometheus)
+    };
+    const validatedOptions = validateCommandOptions(
+      DoctorMetricsMonitorOptionsSchema,
+      monitorOptions
+    );
+    await monitorHealth(validatedOptions);
+  });
+  metricsCmd.addCommand(checkCmd);
+  metricsCmd.addCommand(monitorCmd);
+  metricsCmd.option("--json", "Output as JSON");
+  metricsCmd.option("--prometheus", "Output in Prometheus text format");
+  metricsCmd.option("-v, --verbose", "Show detailed information");
+  metricsCmd.action(async function() {
+    const validatedOptions = readDoctorMetricsOptions(this);
+    await displayDatabaseStatus(validatedOptions);
+  });
+  return metricsCmd;
+}
+
+// src/cli/commands/doctor-native-sqlite.ts
+var loadBetterSqlite3 = async () => (await import("better-sqlite3")).default;
+async function checkNativeSqlite(load2 = loadBetterSqlite3) {
+  try {
+    const Database = await load2();
+    const db = new Database(":memory:");
+    try {
+      const row = db.prepare("SELECT 1 AS ok").get();
+      if (row?.ok !== 1) throw new Error("in-memory query returned an unexpected result");
+    } finally {
+      db.close();
+    }
+    return {
+      name: "Native SQLite",
+      category: "build",
+      status: "pass",
+      message: "better-sqlite3 loads"
+    };
+  } catch (error) {
+    return {
+      name: "Native SQLite",
+      category: "build",
+      status: "fail",
+      message: "better-sqlite3 cannot load; telemetry and planning databases will not work",
+      details: `${error instanceof Error ? error.message : String(error)}. Reinstall Build under a supported Node version. Linux glibc prebuilds require glibc >=2.34 and libstdc++ with GLIBCXX_3.4.29; older glibc systems have no source-build fallback.`
+    };
+  }
+}
+
+// src/cli/commands/doctor-storage.ts
+function checkPlanningStorageBackend(repoRoot) {
+  try {
+    if (resolvePlanningContextForRoot(repoRoot).backend !== "checkout") return void 0;
+  } catch {
+    return void 0;
+  }
+  return {
+    name: "Planning Storage",
+    category: "build",
+    status: "info",
+    message: "Planning buckets are tracked in the checkout; `build plan storage enable` moves them to the build/work branch"
+  };
+}
+async function checkBuildBranchNameConflict(repoRoot) {
+  let refs;
+  try {
+    const result = await execGit(
+      ["for-each-ref", "--format=%(refname)", "refs/heads/", "refs/remotes/"],
+      { cwd: repoRoot }
+    );
+    if (result.exitCode !== 0) return void 0;
+    refs = result.stdout;
+  } catch {
+    return void 0;
+  }
+  const conflicts = refs.split("\n").map((ref) => ref.trim()).filter((ref) => {
+    const parts = ref.split("/");
+    const name = parts[1] === "heads" ? parts.slice(2) : parts[1] === "remotes" ? parts.slice(3) : [];
+    return name.length === 1 && name[0]?.toLowerCase() === "build";
+  }).map((ref) => ref.replace(/^refs\/(heads|remotes)\//, ""));
+  if (conflicts.length === 0) return void 0;
+  return {
+    name: "Build Branch Names",
+    category: "git",
+    status: "warn",
+    message: `A branch named ${conflicts.join(", ")} blocks Build from creating its build/... branches`,
+    details: 'Git cannot hold a branch named "build" alongside branches under "build/" (on macOS the names clash in any letter case). Rename that branch, locally with `git branch -m <old> <new>` and on the remote by pushing the new name and deleting the old one.'
+  };
+}
+
+// src/core/task-types/packaged-copies.ts
+import { createHash } from "crypto";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import * as yaml from "js-yaml";
+
+// src/core/task-types/shipped-task-type-fingerprints.json
+var shipped_task_type_fingerprints_default = {
+  about: "sha256 of every templates/.build-project/task-types version that build init could copy into a repository before it stopped copying task types. Generated by scripts/generate-task-type-fingerprints.mjs; no maintenance needed.",
+  fingerprints: {
+    "4c9a35f0939a138008cb46679cc07889f45fc3592c1c284f8c6cae34b338f750": {
+      id: "analysis",
+      shipped: "2026-08-17"
+    },
+    "64b66ece5f41b0144fc494bd0a7ed5cadf30bbff20f54e69850904f37aaf0127": {
+      id: "analysis",
+      shipped: "2026-09-15"
+    },
+    a562c77b1744f6f2d3178bcc0bd9e171c6d1c18a7e7393375511830c210f0008: {
+      id: "analysis",
+      shipped: "2026-09-26"
+    },
+    "280a7a8f9c46de1e4c42f01efbbcef378ec728ea9e36b67a055101dd7e195075": {
+      id: "architecture",
+      shipped: "2026-08-17"
+    },
+    f76e6ef5160b568ad7d54eb8a51bfa2b12bf910bde4f9b110216104bc0b2c796: {
+      id: "architecture",
+      shipped: "2026-09-15"
+    },
+    "7ac93c055b45d7f3c3ab794e35d6f9b9768e5edd46f9fd6dfde3a5e6057ef77d": {
+      id: "architecture",
+      shipped: "2026-09-26"
+    },
+    "8c5c152f7fe44436b5edf63bd8cdab9a395cdb579dd1b111cabb86788dacb43d": {
+      id: "doc",
+      shipped: "2026-08-17"
+    },
+    bc81f4c08c4b410ec89c41828c653da20071788beee29643721a1887575226fc: {
+      id: "doc",
+      shipped: "2026-09-26"
+    },
+    "6f3e5218c85e2ca1b47b880c14101b3bbae63613bd715ccb596a3f686f3eeb6e": {
+      id: "feature",
+      shipped: "2026-08-17"
+    },
+    "01fe455c0db9e813d6c8280654b5df1407c26c72e7e2bf0aa3c1796329b67337": {
+      id: "feature",
+      shipped: "2026-09-26"
+    },
+    f0e1e4f76ef434529fa8c52a6a23f28c4262b9b2bfb93e4ad1b372488f608d22: {
+      id: "general",
+      shipped: "2026-08-17"
+    },
+    "169a3316cc15d9cfebf8af76f96a914ea68bd73452d94c7da44515ff6b60c9f8": {
+      id: "general",
+      shipped: "2026-09-26"
+    },
+    e813bb3fd1587a9e1d9a82095b43680d19c5393ba5e10536d232fa8f8fca2cb2: {
+      id: "security",
+      shipped: "2026-08-17"
+    },
+    "70e6d7e168fc96b7b5dfde0603f2025ff53af48ed717f361a0623d5bcd443365": {
+      id: "security",
+      shipped: "2026-09-26"
+    }
+  }
+};
+
+// src/core/task-types/packaged-copies.ts
+var SHIPPED_TASK_TYPE_VERSIONS = shipped_task_type_fingerprints_default.fingerprints;
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function taskTypeId(bytes, filePath) {
+  try {
+    const parsed = yaml.load(bytes.toString("utf8"), { schema: yaml.JSON_SCHEMA });
+    const id = parsed?.id;
+    if (typeof id === "string" && id.length > 0) return id;
+  } catch {
+  }
+  return path2.basename(filePath).replace(/\.ya?ml$/, "");
+}
+async function findPackagedTaskTypeCopies(options) {
+  const repoFiles = await listYamlFiles(options.repoDir);
+  if (repoFiles.length === 0) return { fileCount: 0, copies: [] };
+  const shipped = options.shipped ?? SHIPPED_TASK_TYPE_VERSIONS;
+  const currentIdByHash = /* @__PURE__ */ new Map();
+  for (const filePath of await listYamlFiles(options.builtInDir ?? getBuiltInTaskTypesDir())) {
+    const bytes = await fs2.readFile(filePath);
+    currentIdByHash.set(sha256(bytes), taskTypeId(bytes, filePath));
+  }
+  const currentIds = new Set(currentIdByHash.values());
+  const repoEntries = [];
+  const repoIdCounts = /* @__PURE__ */ new Map();
+  for (const filePath of repoFiles) {
+    const bytes = await fs2.readFile(filePath);
+    const id = taskTypeId(bytes, filePath);
+    repoEntries.push({ file: path2.basename(filePath), hash: sha256(bytes), id });
+    repoIdCounts.set(id, (repoIdCounts.get(id) ?? 0) + 1);
+  }
+  const copies = [];
+  for (const { file, hash, id } of repoEntries) {
+    const version = shipped[hash];
+    const currentId = currentIdByHash.get(hash);
+    const sharedId = (repoIdCounts.get(id) ?? 0) > 1;
+    if (currentId !== void 0) {
+      copies.push({ file, id: currentId, kind: "current", shipped: version?.shipped, sharedId });
+    } else if (version) {
+      const kind = currentIds.has(version.id) ? "older" : "retired";
+      copies.push({ file, id: version.id, kind, shipped: version.shipped, sharedId });
+    }
+  }
+  return { fileCount: repoFiles.length, copies };
+}
+
+// src/cli/commands/doctor-task-types.ts
+var CHECK_NAME2 = "Repo Task Types";
+function describeCopy(copy) {
+  const file = `.build-project/task-types/${copy.file}`;
+  const shipped = copy.shipped ? ` shipped ${copy.shipped}` : "";
+  const shared = `Another repo file also defines ${copy.id}, so packaged updates still won't apply after deleting this one.`;
+  switch (copy.kind) {
+    case "older":
+      return copy.sharedId ? `${file} matches the packaged ${copy.id} task type${shipped}. ${shared}` : `${file} matches the packaged ${copy.id} task type${shipped}; it overrides newer packaged versions. Delete it to receive updates, or keep it to stay on that version.`;
+    case "current":
+      return copy.sharedId ? `${file} matches the current packaged ${copy.id} task type. ${shared}` : `${file} matches the current packaged ${copy.id} task type; it will override future packaged versions. Delete it to receive future updates, or keep it to stay on this version.`;
+    case "retired":
+      return `${file} matches the packaged ${copy.id} task type${shipped}, which this install no longer ships; ${copy.sharedId ? `another repo file also defines ${copy.id}.` : `it is now the only definition of ${copy.id}.`}`;
+  }
+}
+async function checkRepoTaskTypes(repoRoot, options = {}) {
+  let report;
+  try {
+    report = await findPackagedTaskTypeCopies({
+      ...options,
+      repoDir: getRepoTaskTypesDir(repoRoot)
+    });
+  } catch (error) {
+    return {
+      name: CHECK_NAME2,
+      category: "build",
+      status: "info",
+      message: "Could not compare repo task types with packaged versions",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const { fileCount, copies } = report;
+  if (copies.length === 0) {
+    return {
+      name: CHECK_NAME2,
+      category: "build",
+      status: "pass",
+      message: fileCount === 0 ? "No repo task-type files; packaged task types apply" : `${fileCount} repo task-type override(s); none match a packaged version`
+    };
+  }
+  const lines = copies.map(describeCopy);
+  const overrides = fileCount - copies.length;
+  if (overrides > 0) {
+    lines.push(`${overrides} other file(s) match no packaged version and are repo overrides.`);
+  }
+  return {
+    name: CHECK_NAME2,
+    category: "build",
+    status: "info",
+    message: `${copies.length} of ${fileCount} repo task-type file(s) match a packaged version; run build doctor --verbose for details`,
+    details: lines.join("\n     ")
+  };
+}
+
+// src/cli/commands/doctor.ts
+var BetterSqlite3Ctor = null;
+async function getBetterSqlite3() {
+  if (!BetterSqlite3Ctor) {
+    const mod = await import("better-sqlite3");
+    BetterSqlite3Ctor = mod.default;
+  }
+  return BetterSqlite3Ctor;
+}
+var HOMEBREW_NODE_24_PATH = "/opt/homebrew/opt/node@24/bin/node";
+async function preferredNode24Path() {
+  try {
+    await fs3.access(HOMEBREW_NODE_24_PATH);
+    return HOMEBREW_NODE_24_PATH;
+  } catch {
+    return null;
+  }
+}
+function formatNode24Remediation(preferredPath) {
+  if (preferredPath) {
+    return `Build requires Node.js ${formatSupportedNodeMajors()}; use ${preferredPath} or put /opt/homebrew/opt/node@24/bin first in PATH.`;
+  }
+  return `Build requires Node.js ${formatSupportedNodeMajors()} first on PATH. Run: nvm install 24; export PATH="$(dirname "$(nvm which 24)"):$PATH"; hash -r; command -v node; node --version; npm config get prefix.`;
+}
+function isLikelyBetterSqlite3NativeLoadMismatch(error) {
+  const code = error?.code;
+  const message = error instanceof Error ? error.message : String(error);
+  return code === "ERR_DLOPEN_FAILED" || message.includes("NODE_MODULE_VERSION") || /compiled against a different Node\.js version/i.test(message) || /was compiled for a different Node\.js version/i.test(message) || /module did not self-register/i.test(message) || /invalid ELF header/i.test(message) || /incompatible architecture/i.test(message) || /better[-_]sqlite3/i.test(message) && /\.node\b/i.test(message);
+}
+function formatDatabaseNativeErrorDetails(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (!isLikelyBetterSqlite3NativeLoadMismatch(error)) {
+    return message;
+  }
+  return `${message}
+Remediation: reinstall Build under the active Node (npm install -g @ebrindley/build; source checkout: rm -rf node_modules && npm ci), then rerun build doctor.`;
+}
+var HealthCommandOptionsSchema = z2.object({
+  json: BooleanFlagSchema.optional(),
+  verbose: BooleanFlagSchema.optional(),
+  fix: BooleanFlagSchema.optional(),
+  all: BooleanFlagSchema.optional(),
+  provider: z2.string().optional(),
+  providersOnly: BooleanFlagSchema.optional(),
+  matrix: BooleanFlagSchema.optional(),
+  strict: BooleanFlagSchema.optional(),
+  requireReady: BooleanFlagSchema.optional(),
+  probe: BooleanFlagSchema.optional(),
+  refresh: BooleanFlagSchema.optional(),
+  checkLinks: BooleanFlagSchema.optional()
+}).strict();
+function isStrictBlockingWarning(check) {
+  if (check.name === "Linux write boundary" || check.name === "Agent Wrapper Imports") {
+    return false;
+  }
+  if (check.category === "providers" && check.name === "Provider CLIs") {
+    return false;
+  }
+  if (check.category === "providers" && (check.name === "OpenCode discovery" || /auth not observed/i.test(check.message))) {
+    return false;
+  }
+  return true;
+}
+function isRequireReadyFailure(check) {
+  return check.category === "providers" && check.name === "Provider CLIs" && (check.readinessGateLabel === "zero-ready" || check.readinessReadyCount === 0);
+}
+function exitForHealthFailures(checks, options) {
+  const failedChecks = checks.filter((c) => c.status === "fail");
+  const warnChecks = checks.filter((c) => c.status === "warn" && isStrictBlockingWarning(c));
+  if (failedChecks.length > 0) {
+    process.exit(1);
+  }
+  if (options.requireReady && checks.some((check) => isRequireReadyFailure(check))) {
+    process.exit(1);
+  }
+  if (options.strict && warnChecks.length > 0) {
+    process.exit(1);
+  }
+}
+async function checkGit() {
+  try {
+    const result = await execa("git", ["--version"]);
+    const version = result.stdout.trim();
+    let details = version;
+    try {
+      const whichCmd = process.platform === "win32" ? "where" : "which";
+      const whichResult = await execa(whichCmd, ["git"]);
+      details = `${version} \u2014 ${whichResult.stdout.trim()}`;
+    } catch (_whichError) {
+    }
+    return {
+      name: "Git",
+      category: "git",
+      status: "pass",
+      message: version,
+      details
+    };
+  } catch (error) {
+    return {
+      name: "Git",
+      category: "git",
+      status: "fail",
+      message: "Git not found or not accessible",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var PROVIDER_CLI_SPECS = [
+  { id: "claude", versionArgs: ["--version"] },
+  { id: "codex", versionArgs: ["--version"] },
+  { id: "copilot", versionArgs: ["--version"] },
+  { id: "cursor", versionArgs: ["--version"] },
+  { id: "gemini", versionArgs: ["--version"] },
+  { id: "grok", versionArgs: ["--version"] },
+  { id: "kiro", versionArgs: ["--version"] },
+  { id: "pi", versionArgs: ["--version"] },
+  { id: "antigravity", versionArgs: ["--version"] },
+  { id: "opencode", versionArgs: ["--version"] }
+];
+var PROVIDER_CLI_SPEC_IDS = PROVIDER_CLI_SPECS.map((s) => s.id);
+var AUTH_PROBE_HINT_PROVIDERS = /* @__PURE__ */ new Set(["grok"]);
+var PROVIDER_EXTRA_HEALTH_CHECKS = [
+  { providerId: "opencode", runWithoutProviderFilter: false, check: checkOpencodeDiscovery },
+  { providerId: "claude", runWithoutProviderFilter: true, check: checkClaudeStrictMcpConfig },
+  { providerId: "claude", runWithoutProviderFilter: true, check: checkLegacyClaudePlugin },
+  { providerId: "claude", runWithoutProviderFilter: true, check: checkClaudeAliasAdvisory }
+];
+async function collectProviderExtraHealthChecks(options) {
+  const checks = [];
+  for (const entry of PROVIDER_EXTRA_HEALTH_CHECKS) {
+    const requested = options.all === true || options.provider === entry.providerId || entry.runWithoutProviderFilter && !options.provider;
+    if (requested) {
+      checks.push(await entry.check());
+    }
+  }
+  return checks;
+}
+function providerHealthReadinessOptions(providerId) {
+  const activeAuthProviders = /* @__PURE__ */ new Set(["cursor", "grok"]);
+  return {
+    mode: "execute",
+    authProbeMode: activeAuthProviders.has(providerId) ? "active" : "passive"
+  };
+}
+async function formatLastSeenAuth(providerId) {
+  const lookup = await lookupAuthOutcome(providerId);
+  if (!lookup || lookup.stale || !lookup.contextMatches) {
+    return "none";
+  }
+  return `${lookup.entry.result}, ${lookup.entry.observedAt}`;
+}
+async function recordHealthAuthOutcome(providerId, result, message) {
+  await recordAuthOutcome(providerId, result, {
+    source: "health-probe",
+    message
+  }).catch(() => {
+  });
+}
+function normalizeProviderId(value) {
+  return normalizeEngineId(value.trim());
+}
+async function checkOpencodeDiscovery() {
+  let command;
+  let prefixArgs;
+  try {
+    ({ command, prefixArgs } = resolveProviderCliCommand("opencode"));
+  } catch {
+    return {
+      name: "OpenCode discovery",
+      category: "providers",
+      status: "fail",
+      message: "OpenCode CLI not resolved",
+      details: "Install OpenCode or set BUILD_OPENCODE_CLI_COMMAND. Run: build doctor --provider opencode"
+    };
+  }
+  const cliProbe = await probeProviderCli(command, ["--version"], prefixArgs, {
+    providerId: "opencode"
+  });
+  const cliInstalled = cliProbe.present;
+  const discovery = await discoverOpencode({
+    cliCommand: command,
+    prefixArgs,
+    cliInstalled,
+    refreshModels: false,
+    includeModelsDev: true,
+    modelsDevCacheDir: path3.join(
+      getRuntimeEnv("BUILD_TELEMETRY_DIR") ?? path3.join(process.cwd(), ".build-project"),
+      "cache",
+      "opencode"
+    )
+  });
+  const parts = [];
+  parts.push(`CLI installed: ${cliInstalled ? "yes" : "no"}`);
+  if (discovery.authList.rawOk) {
+    const credentialNames = discovery.authList.credentialProviders ?? [];
+    const environmentNames = discovery.authList.environmentProviders ?? [];
+    parts.push(`Auth: ${credentialNames.length > 0 ? credentialNames.join(", ") : "not observed"}`);
+    if (environmentNames.length > 0) {
+      parts.push(`Capability (parent-env): ${environmentNames.join(", ")}`);
+    }
+  } else {
+    parts.push(
+      `Providers (auth list): unsupported or failed${discovery.authList.unsupportedMessage ? ` (${discovery.authList.unsupportedMessage.slice(0, 80)})` : ""}`
+    );
+  }
+  if (discovery.models.rawOk) {
+    parts.push(
+      `Models: ${discovery.models.modelIds.length > 0 ? discovery.models.modelIds.slice(0, 15).join(", ") + (discovery.models.modelIds.length > 15 ? ` (+${discovery.models.modelIds.length - 15} more)` : "") : "none"}`
+    );
+  } else {
+    parts.push(
+      `Models: unsupported or failed${discovery.models.unsupportedMessage ? ` (${discovery.models.unsupportedMessage.slice(0, 80)})` : ""}`
+    );
+  }
+  if (discovery.modelsDev) {
+    const source = discovery.modelsDev.source === "network" ? "fresh" : "cache";
+    parts.push(
+      `models.dev: ${source}${discovery.modelsDev.fetchedAt ? ` @ ${new Date(discovery.modelsDev.fetchedAt).toISOString()}` : ""}`
+    );
+  }
+  const credentialProviders = discovery.authList.credentialProviders ?? [];
+  const environmentProviders = discovery.authList.environmentProviders ?? [];
+  const hasCredentialAuth = credentialProviders.length > 0;
+  const envOnlyCapability = cliInstalled && discovery.authList.rawOk && !hasCredentialAuth && (environmentProviders.length > 0 || discovery.models.modelIds.length > 0);
+  const status = cliInstalled && discovery.authList.rawOk && discovery.models.rawOk && hasCredentialAuth ? "pass" : cliInstalled ? "warn" : "fail";
+  const message = status === "pass" ? `CLI installed; ${credentialProviders.length} credential provider(s); ${discovery.models.modelIds.length} model(s)` : envOnlyCapability ? "CLI present; auth not observed (parent-env vendors are capability only)" : cliInstalled ? discovery.authList.rawOk && discovery.models.rawOk ? "CLI present; no OpenCode providers or models discovered" : "CLI present; auth list or models unavailable" : "OpenCode CLI not installed";
+  return {
+    name: "OpenCode discovery",
+    category: "providers",
+    status,
+    message,
+    details: parts.join(" | ")
+  };
+}
+async function getProvidersToCheck(options) {
+  const validIds = PROVIDER_CLI_SPECS.map((s) => s.id);
+  if (options.provider) {
+    const requested = normalizeProviderId(options.provider);
+    if (!validIds.includes(requested)) {
+      throw new Error(
+        `Unknown provider: ${options.provider}. Valid providers: ${validIds.join(", ")}`
+      );
+    }
+    return {
+      providers: [requested],
+      isDiscoveryMode: false,
+      selectionScope: "provider"
+    };
+  }
+  if (options.all) {
+    return {
+      providers: PROVIDER_CLI_SPECS.map((s) => s.id),
+      isDiscoveryMode: false,
+      selectionScope: "all"
+    };
+  }
+  const configured = /* @__PURE__ */ new Set();
+  const defaultProvider = process.env.BUILD_DEFAULT_PROVIDER;
+  if (defaultProvider) {
+    const normalized = normalizeProviderId(defaultProvider);
+    if (validIds.includes(normalized)) {
+      configured.add(normalized);
+    }
+  }
+  try {
+    const { ConfigManager: ConfigManager2 } = await import("./config-manager-J2UTO635.js");
+    const manager = new ConfigManager2({
+      enableCache: false,
+      cwd: process.cwd()
+    });
+    const resolved = await manager.loadConfig({}, true);
+    const config = resolved.config;
+    const hasExplicitConfig = resolved.sources.some(
+      (source) => (source.type === "project" || source.type === "user") && source.exists
+    );
+    if (hasExplicitConfig) {
+      for (const providerId of configuredProviderIds(config, resolved.sources)) {
+        configured.add(normalizeProviderId(providerId));
+      }
+      const configuredDefault = config?.defaults?.provider ?? config?.defaultProvider;
+      if (configuredDefault) {
+        configured.add(normalizeProviderId(String(configuredDefault)));
+      }
+    }
+  } catch (error) {
+    if (isConfigValidityError(error)) {
+      throw error;
+    }
+  }
+  if (configured.size > 0) {
+    const validIds2 = new Set(PROVIDER_CLI_SPECS.map((s) => s.id));
+    const filteredProviders = [...configured].filter((id) => validIds2.has(id));
+    if (filteredProviders.length > 0) {
+      return {
+        providers: filteredProviders,
+        isDiscoveryMode: false,
+        selectionScope: "configured"
+      };
+    }
+  }
+  return {
+    providers: PROVIDER_CLI_SPECS.map((s) => s.id),
+    isDiscoveryMode: true,
+    selectionScope: "discovery"
+  };
+}
+async function checkProviderCLIs(optionsOrVerbose = false) {
+  const options = typeof optionsOrVerbose === "boolean" ? { includeVerboseDetails: optionsOrVerbose } : optionsOrVerbose;
+  const includeVerboseDetails = options.includeVerboseDetails ?? false;
+  const {
+    providers: providersToCheck,
+    isDiscoveryMode,
+    selectionScope
+  } = await getProvidersToCheck(options);
+  const specsToCheck = PROVIDER_CLI_SPECS.filter((spec) => providersToCheck.includes(spec.id));
+  const uncheckedProviderIds = selectionScope === "configured" ? PROVIDER_CLI_SPECS.map((spec) => spec.id).filter((id) => !providersToCheck.includes(id)) : [];
+  const available = [];
+  const degraded = [];
+  const authUnobserved = [];
+  const sandboxBlocked = [];
+  const missing = [];
+  const providerBreakdown = [];
+  const providerReadiness = [];
+  const gateReadyProviders = /* @__PURE__ */ new Set();
+  const authMissing = [];
+  const authReady = [];
+  const lastSeenAuthMap = /* @__PURE__ */ new Map();
+  for (const spec of specsToCheck) {
+    lastSeenAuthMap.set(spec.id, await formatLastSeenAuth(spec.id));
+  }
+  const repoRoot = resolveRepoRootForBuildDir(process.cwd());
+  for (const spec of specsToCheck) {
+    let config;
+    try {
+      config = getProviderConfig(spec.id);
+    } catch {
+      missing.push({ id: spec.id });
+      if (includeVerboseDetails) {
+        providerBreakdown.push({ id: spec.id, status: "missing" });
+      }
+      continue;
+    }
+    if (!config?.cli) {
+      missing.push({ id: spec.id });
+      if (includeVerboseDetails) {
+        providerBreakdown.push({ id: spec.id, status: "missing" });
+      }
+      continue;
+    }
+    const readinessOptions = options.probe ? {
+      ...providerHealthReadinessOptions(spec.id)
+    } : {
+      ...SETUP_CHECK_READINESS_OPTIONS,
+      cliProbeMode: "execute",
+      sandboxProbeMode: "execute",
+      probeAuth: async () => "unknown"
+    };
+    const probeContext = readinessProbeContextForOptions(readinessOptions);
+    const readiness = await getProviderReadiness(spec.id, readinessOptions);
+    if (isGateReadyProvider(readiness)) gateReadyProviders.add(readiness.provider);
+    if (options.probe) {
+      void recordReadinessDiagnostic(readiness, {
+        phase: "health",
+        cliProbeMode: "execute",
+        ...readinessOptions.authProbeMode ? { authProbeMode: readinessOptions.authProbeMode } : {}
+      });
+    }
+    const dryRun = readProviderDryRunFreshness(spec.id, repoRoot);
+    const resolved = resolveNamedReadiness(readiness, dryRun);
+    const scope = resolveReadinessScope(readiness, resolved);
+    const parityLabel = resolveProviderParityLabel(readiness, resolved);
+    providerReadiness.push({
+      provider: spec.id,
+      known: readiness.known,
+      configured: readiness.configured,
+      installed: readiness.installed,
+      cliHealthy: readiness.cliHealthy,
+      authenticated: readiness.authenticated,
+      ready: readiness.ready,
+      scope: scope.label,
+      ...scope.detail ? { scopeDetail: scope.detail } : {},
+      ...readiness.readinessNote ? { readinessNote: readiness.readinessNote } : {},
+      ...readiness.reasonCode ? { reasonCode: readiness.reasonCode } : {},
+      parityLabel,
+      resolved,
+      probe: probeContext
+    });
+    const lastSeenAuth = lastSeenAuthMap.get(spec.id) ?? "";
+    if (!readiness.command && !readiness.installed) {
+      missing.push({
+        id: spec.id,
+        installCommand: config.cli?.install_command
+      });
+      if (includeVerboseDetails) {
+        providerBreakdown.push({
+          id: spec.id,
+          status: "missing",
+          installCommand: config.cli?.install_command,
+          lastSeenAuth
+        });
+      }
+      continue;
+    }
+    if (!readiness.installed) {
+      missing.push({
+        id: spec.id,
+        installCommand: config.cli?.install_command
+      });
+      if (includeVerboseDetails) {
+        providerBreakdown.push({
+          id: spec.id,
+          status: "missing",
+          resolvedCommand: readiness.command,
+          installCommand: config.cli?.install_command,
+          lastSeenAuth
+        });
+      }
+    } else if (!readiness.cliHealthy) {
+      degraded.push({
+        id: spec.id,
+        reason: readiness.reason ?? "Unknown issue"
+      });
+      if (includeVerboseDetails) {
+        providerBreakdown.push({
+          id: spec.id,
+          status: "degraded",
+          resolvedCommand: readiness.command,
+          degradedReason: readiness.reason,
+          lastSeenAuth
+        });
+      }
+    } else {
+      if (readiness.sandboxCapable === false) {
+        const deniedPaths = readiness.sandboxDeniedPaths?.join(", ") ?? "";
+        const summary = deniedPaths ? `${spec.id}: sandbox blocked (${deniedPaths})` : formatSandboxDegradedSummary({
+          providerId: spec.id,
+          capable: false,
+          probed: [],
+          missing: []
+        });
+        const verboseReason = readiness.sandboxReason ?? "CLI present, sandbox capability denied";
+        sandboxBlocked.push({ id: spec.id, paths: deniedPaths });
+        degraded.push({ id: spec.id, reason: summary });
+        if (includeVerboseDetails) {
+          providerBreakdown.push({
+            id: spec.id,
+            status: "degraded",
+            resolvedCommand: readiness.command,
+            degradedReason: verboseReason,
+            lastSeenAuth
+          });
+        }
+        continue;
+      }
+      const authState = readiness.authenticated;
+      if (authState === "no") {
+        if (options.probe) {
+          await recordHealthAuthOutcome(
+            spec.id,
+            "failed",
+            readiness.reason ?? "Health probe reported authentication missing"
+          );
+        }
+        authMissing.push(spec.id);
+        const authMissingReason = spec.id === "codex" && readEnv(BUILD_CODEX_BACKEND).value?.trim().toLowerCase() === "bedrock" ? 'CLI present, auth missing; Bedrock runs need an AWS credential chain, not "codex login"' : "CLI present, auth missing";
+        degraded.push({ id: spec.id, reason: authMissingReason });
+        if (includeVerboseDetails) {
+          providerBreakdown.push({
+            id: spec.id,
+            status: "degraded",
+            resolvedCommand: readiness.command,
+            degradedReason: authMissingReason,
+            lastSeenAuth: lastSeenAuthMap.get(spec.id) ?? ""
+          });
+        }
+        continue;
+      }
+      if (authState === "unknown") {
+        const activeProbeUnknown = options.probe === true && readiness.reason?.includes("active auth probe could not verify headless execution");
+        const defaultProbeHintUnknown = AUTH_PROBE_HINT_PROVIDERS.has(spec.id) && options.provider === spec.id && options.probe !== true;
+        if (activeProbeUnknown || defaultProbeHintUnknown) {
+          const reason2 = defaultProbeHintUnknown ? `installed; auth checked on first run; run \`build doctor --probe --provider ${spec.id}\` to verify headless execution` : readiness.reason ?? "CLI present, active auth probe inconclusive";
+          degraded.push({
+            id: spec.id,
+            reason: reason2
+          });
+          if (includeVerboseDetails) {
+            providerBreakdown.push({
+              id: spec.id,
+              status: "degraded",
+              resolvedCommand: readiness.command,
+              degradedReason: reason2,
+              lastSeenAuth
+            });
+          }
+          continue;
+        }
+        const cached = await lookupAuthOutcome(spec.id);
+        const freshFailure = cached?.entry.result === "failed" && !cached.stale && cached.contextMatches;
+        if (!freshFailure) {
+          authUnobserved.push(spec.id);
+          available.push(spec.id);
+          if (includeVerboseDetails) {
+            providerBreakdown.push({
+              id: spec.id,
+              status: "available",
+              resolvedCommand: readiness.command,
+              lastSeenAuth
+            });
+          }
+          continue;
+        }
+        const reason = "CLI present, cached auth failure";
+        degraded.push({
+          id: spec.id,
+          reason
+        });
+        if (includeVerboseDetails) {
+          providerBreakdown.push({
+            id: spec.id,
+            status: "degraded",
+            resolvedCommand: readiness.command,
+            degradedReason: reason,
+            lastSeenAuth
+          });
+        }
+        continue;
+      }
+      if (authState === "yes") {
+        if (readiness.authEvidence === "execution") {
+          await recordHealthAuthOutcome(spec.id, "ok", "Health probe succeeded");
+        }
+        authReady.push(spec.id);
+      }
+      available.push(spec.id);
+      if (includeVerboseDetails) {
+        providerBreakdown.push({
+          id: spec.id,
+          status: "available",
+          resolvedCommand: readiness.command,
+          degradedReason: readiness.warning,
+          lastSeenAuth: lastSeenAuthMap.get(spec.id) ?? ""
+        });
+      }
+    }
+  }
+  const missingDetails = missing.map(
+    (entry) => entry.installCommand ? `${entry.id} (install: ${entry.installCommand})` : entry.id
+  ).join(", ");
+  const degradedDetails = degraded.map((entry) => `${entry.id} (${entry.reason})`).join(", ");
+  const lastSeenParts = specsToCheck.map(
+    (spec) => `${spec.id}: ${lastSeenAuthMap.get(spec.id) ?? ""}`
+  );
+  const baseDetails = (() => {
+    const parts = [];
+    if (available.length > 0) {
+      parts.push(`CLI present: ${available.join(", ")}`);
+    }
+    if (degraded.length > 0) {
+      parts.push(`Degraded: ${degradedDetails}`);
+    }
+    if (authUnobserved.length > 0) {
+      parts.push(
+        `No current auth observation: ${authUnobserved.join(", ")} (expected; provider execution is the probe)`
+      );
+    }
+    if (authMissing.length > 0) {
+      parts.push(`Auth missing: ${authMissing.join(", ")}`);
+    }
+    if (authReady.length > 0) {
+      parts.push(`Auth ready: ${authReady.join(", ")}`);
+    }
+    const assumedReady = providerReadiness.filter((entry) => entry.readinessNote === "env-var-auth-assumed").map((entry) => entry.provider);
+    if (assumedReady.length > 0) {
+      parts.push(`Readiness assumed: ${assumedReady.join(", ")}`);
+    }
+    if (lastSeenParts.length > 0) {
+      parts.push(`Last seen auth: ${lastSeenParts.join(", ")}`);
+    }
+    if (missing.length > 0) {
+      parts.push(`Missing: ${missingDetails}`);
+    }
+    if (uncheckedProviderIds.length > 0) {
+      parts.push(`Not checked: ${uncheckedProviderIds.join(", ")} (use --all to include)`);
+    }
+    if (parts.length === 0) {
+      return "No provider CLIs checked";
+    }
+    return parts.join(" | ");
+  })();
+  const discoveryModeNote = isDiscoveryMode ? `
+
+     Info: Discovery mode: No configured providers found, checking all known providers.
+     Tip: Set BUILD_DEFAULT_PROVIDER or configure providers in build.config.jsonc / ${getUserConfigFile()}` : "";
+  const details = (() => {
+    if (!includeVerboseDetails) return baseDetails + discoveryModeNote;
+    if (providerBreakdown.length === 0) return baseDetails + discoveryModeNote;
+    const breakdown = providerBreakdown.map((provider) => {
+      let statusMark;
+      switch (provider.status) {
+        case "available":
+          statusMark = "OK";
+          break;
+        case "degraded":
+          statusMark = "Warning:";
+          break;
+        default:
+          statusMark = "Error";
+      }
+      const commandPart = provider.resolvedCommand ? `: ${provider.resolvedCommand}` : ": missing";
+      const statusSuffix = (() => {
+        if (provider.status === "missing" && provider.installCommand) {
+          return ` (install: ${provider.installCommand})`;
+        }
+        if (provider.status === "degraded" && provider.degradedReason) {
+          const lastSeen = provider.lastSeenAuth ? `; lastSeenAuth: ${provider.lastSeenAuth}` : "";
+          return ` (${provider.degradedReason}${lastSeen})`;
+        }
+        if (provider.lastSeenAuth) {
+          return ` (lastSeenAuth: ${provider.lastSeenAuth})`;
+        }
+        return "";
+      })();
+      return `${statusMark} ${provider.id}${commandPart}${statusSuffix}`;
+    }).join("\n     ");
+    return `${baseDetails}${discoveryModeNote}
+
+     ${breakdown}`;
+  })();
+  const totalChecked = specsToCheck.length;
+  const healthyCount = available.length;
+  const degradedCount = degraded.length;
+  const missingCount = missing.length;
+  const gateReadyCount = gateReadyProviders.size;
+  const readinessGateLabel = gateReadyCount === 0 ? "zero-ready" : gateReadyCount === 1 ? "one-ready" : "multi-ready";
+  const gateMeta = {
+    readinessGateLabel,
+    readinessReadyCount: gateReadyCount
+  };
+  if (options.requireReady && gateReadyCount === 0) {
+    return {
+      name: "Provider CLIs",
+      category: "providers",
+      status: "fail",
+      message: isDiscoveryMode ? "No ready providers (--require-ready, discovery mode)" : "No ready providers (--require-ready)",
+      details,
+      ...providerReadiness.length > 0 ? { providerReadiness } : {},
+      ...gateMeta
+    };
+  }
+  if (healthyCount === 0 && degradedCount === 0) {
+    return {
+      name: "Provider CLIs",
+      category: "providers",
+      status: "fail",
+      message: isDiscoveryMode ? "No provider CLIs present (discovery mode)" : "No provider CLIs present",
+      details,
+      ...providerReadiness.length > 0 ? { providerReadiness } : {},
+      ...gateMeta
+    };
+  }
+  if (missingCount > 0 || degradedCount > 0) {
+    const statusParts = [];
+    if (healthyCount > 0) statusParts.push(`${healthyCount} healthy`);
+    if (degradedCount > 0) statusParts.push(`${degradedCount} degraded`);
+    if (missingCount > 0) statusParts.push(`${missingCount} missing`);
+    if ((options.strict || options.requireReady) && gateReadyCount > 0) {
+      statusParts.push(`${gateReadyCount} ready`);
+    }
+    return {
+      name: "Provider CLIs",
+      category: "providers",
+      status: degradedCount > 0 || missingCount > 0 ? "warn" : "pass",
+      message: (() => {
+        if (options.provider) {
+          const sandboxEntry = sandboxBlocked.find((entry) => entry.id === options.provider);
+          if (sandboxEntry) {
+            return sandboxEntry.paths ? `${options.provider} sandbox blocked (${sandboxEntry.paths})` : `${options.provider} sandbox/policy blocked`;
+          }
+          if (authMissing.includes(options.provider)) {
+            return `${options.provider} CLI present, auth missing`;
+          }
+        }
+        return `${statusParts.join(", ")} of ${totalChecked} ${selectionScope === "configured" ? "configured " : ""}checked${isDiscoveryMode ? " (discovery mode)" : ""}${uncheckedProviderIds.length > 0 ? `; ${uncheckedProviderIds.length} known provider(s) not checked` : ""}`;
+      })(),
+      details,
+      ...providerReadiness.length > 0 ? { providerReadiness } : {},
+      ...gateMeta
+    };
+  }
+  const scopedPassMessage = selectionScope === "configured" && uncheckedProviderIds.length > 0 ? `${healthyCount} of ${totalChecked} configured provider CLIs present; ${uncheckedProviderIds.length} known provider(s) not checked` : void 0;
+  return {
+    name: "Provider CLIs",
+    category: "providers",
+    status: "pass",
+    message: options.provider && authReady.includes(options.provider) ? `${options.provider} CLI present and authenticated` : scopedPassMessage ?? (totalChecked === PROVIDER_CLI_SPECS.length ? `All ${healthyCount} provider CLIs present${isDiscoveryMode ? " (discovery mode)" : ""}` : `${healthyCount} of ${totalChecked} checked provider CLIs present${isDiscoveryMode ? " (discovery mode)" : ""}`),
+    details,
+    ...providerReadiness.length > 0 ? { providerReadiness } : {},
+    ...gateMeta
+  };
+}
+async function checkBuildDirectory(cwd) {
+  const buildDir = path3.join(cwd, ".build-project");
+  try {
+    await fs3.stat(buildDir);
+    try {
+      await fs3.access(buildDir, fs3.constants.W_OK);
+      return {
+        name: ".build-project Directory",
+        category: "build",
+        status: "pass",
+        message: "Directory exists and is writable",
+        details: buildDir
+      };
+    } catch (_error) {
+      return {
+        name: ".build-project Directory",
+        category: "build",
+        status: "fail",
+        message: "Directory not writable",
+        details: buildDir,
+        fixable: false
+      };
+    }
+  } catch (_error) {
+    return {
+      name: ".build-project Directory",
+      category: "build",
+      status: "warn",
+      message: "Directory not found",
+      details: 'Run "build init" or "build doctor --fix" to initialize',
+      fixable: true
+    };
+  }
+}
+async function checkNestedBuildDirectory(cwd) {
+  const nestedDir = path3.join(cwd, ".build-project", ".build-project");
+  try {
+    const stats = await fs3.stat(nestedDir);
+    if (stats.isDirectory()) {
+      return {
+        name: "Nested .build-project Directory",
+        category: "build",
+        status: "warn",
+        message: "Found nested .build-project/.build-project/ directory (bug artifact)",
+        details: `This directory was created by a bug and should be removed: ${nestedDir}`,
+        fixable: true
+      };
+    }
+  } catch (_error) {
+  }
+  return null;
+}
+async function checkRequiredDirectories(cwd) {
+  const missing = [];
+  const present = [];
+  for (const dir of RuntimeRequirements.directories) {
+    const fullPath = path3.join(cwd, ".build-project", dir);
+    try {
+      await fs3.stat(fullPath);
+      present.push(dir);
+    } catch (_error) {
+      missing.push(dir);
+    }
+  }
+  if (missing.length === 0) {
+    return {
+      name: "Required Directories",
+      category: "build",
+      status: "pass",
+      message: `All ${RuntimeRequirements.directories.length} directories present`,
+      details: `All present: ${present.join(", ")}`
+    };
+  }
+  if (missing.length === RuntimeRequirements.directories.length) {
+    return {
+      name: "Required Directories",
+      category: "build",
+      status: "fail",
+      message: "No directories found",
+      details: `Present: ${present.join(", ")} | Missing: ${missing.join(", ")}`,
+      fixable: true
+    };
+  }
+  return {
+    name: "Required Directories",
+    category: "build",
+    status: "warn",
+    message: `${missing.length} directories missing`,
+    details: `Present: ${present.join(", ")} | Missing: ${missing.join(", ")}`,
+    fixable: true
+  };
+}
+async function checkArchiveReconciliation() {
+  let report;
+  try {
+    report = await detectArchiveReconciliationIssues();
+  } catch (error) {
+    const unavailable = planningStorageUnavailableReason(error);
+    return {
+      name: "Archive Reconciliation",
+      category: "build",
+      status: "warn",
+      message: unavailable ? `Planning storage unavailable: ${unavailable}` : "Could not scan for archive reconciliation issues",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (report.totalIssues === 0) {
+    return {
+      name: "Archive Reconciliation",
+      category: "build",
+      status: "pass",
+      message: "No archive/restore reconciliation issues"
+    };
+  }
+  return {
+    name: "Archive Reconciliation",
+    category: "build",
+    status: "warn",
+    message: `${report.totalIssues} archive reconciliation issue(s) detected`,
+    details: formatArchiveReconciliationReport(report)
+  };
+}
+async function checkProviderConfig(cwd) {
+  const providersConfigPath = resolveProvidersConfigPath({ cwd });
+  try {
+    ProviderRegistry.load(void 0, cwd);
+    const ignoredUserModelEntries = ProviderRegistry.describeIgnoredUserModelEntries();
+    if (ignoredUserModelEntries) {
+      return {
+        name: "Provider Config",
+        category: "build",
+        status: "warn",
+        message: "Provider catalog loaded; invalid user model entries were ignored",
+        details: ignoredUserModelEntries
+      };
+    }
+    const projectPolicyPresent = await fs3.stat(providersConfigPath).then(() => true).catch((error) => {
+      if (error.code === "ENOENT") return false;
+      throw error;
+    });
+    return {
+      name: "Provider Config",
+      category: "build",
+      status: "pass",
+      message: "Provider catalog loaded",
+      details: projectPolicyPresent ? `Release catalog with project policy: ${providersConfigPath}` : `Release catalog: ${ProviderRegistry.getLoadedConfigPath()}`
+    };
+  } catch (error) {
+    return {
+      name: "Provider Config",
+      category: "build",
+      status: "warn",
+      message: "Cannot load provider catalog",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function checkExecutionRoles() {
+  try {
+    const outcome = await runExecutionRolesPreflight(process.cwd());
+    if (!outcome.result || !outcome.roles) {
+      return null;
+    }
+    const { errors, warnings } = outcome.result;
+    const details = formatPreflightDetails(outcome.result);
+    const reviewer = outcome.roles.reviewer;
+    if (errors.length > 0) {
+      return {
+        name: "Execution Roles",
+        category: "build",
+        status: "fail",
+        message: `Reviewer not ready for gate "${reviewer.gate}"`,
+        details
+      };
+    }
+    if (warnings.length > 0) {
+      const deferredAuthOnly = warnings.every(
+        (warning) => warning.code === "reviewer_auth_unknown"
+      );
+      return {
+        name: "Execution Roles",
+        category: "build",
+        status: deferredAuthOnly ? "info" : "warn",
+        message: deferredAuthOnly ? `Reviewer installed; auth checked on first run (gate "${reviewer.gate}")` : `Reviewer degraded (gate "${reviewer.gate}")`,
+        details
+      };
+    }
+    return {
+      name: "Execution Roles",
+      category: "build",
+      status: "pass",
+      message: `Reviewer ready (gate "${reviewer.gate}")`
+    };
+  } catch (error) {
+    return {
+      name: "Execution Roles",
+      category: "build",
+      status: "fail",
+      message: "Invalid execution-role configuration",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function checkSteeringInstructions() {
+  const { getShadowedLegacyInstructionsPath, getUserInstructionsPath, loadUserInstructionsFile } = await import("./user-agents-QLIGPLP2.js");
+  const instructionsPath = getUserInstructionsPath();
+  const loaded = loadUserInstructionsFile();
+  const shadowedLegacy = getShadowedLegacyInstructionsPath();
+  const shadowedNote = shadowedLegacy ? ` ${shadowedLegacy} is ignored because instructions.md exists beside it; merge and delete it.` : "";
+  if (!loaded) {
+    return {
+      name: "Global Instructions",
+      category: "build",
+      status: "info",
+      message: "No Build instructions file; using built-in steering defaults",
+      details: `Optional: customize provider runs with "build config instructions edit" (${instructionsPath}). Steering-capable provider runs inherit it.`
+    };
+  }
+  if (!loaded.source.editedByUser) {
+    return {
+      name: "Global Instructions",
+      category: "build",
+      status: "info",
+      message: "Build instructions file present (unedited default)",
+      details: `Tip: tailor it with "build config instructions edit" (${instructionsPath}). Steering-capable provider runs inherit it.${shadowedNote}`
+    };
+  }
+  if (shadowedLegacy) {
+    return {
+      name: "Global Instructions",
+      category: "build",
+      status: "info",
+      message: "Build instructions file present (customized); a legacy AGENTS.md is ignored",
+      details: `${instructionsPath}.${shadowedNote}`
+    };
+  }
+  return {
+    name: "Global Instructions",
+    category: "build",
+    status: "pass",
+    message: "Build instructions file present (customized)",
+    details: instructionsPath
+  };
+}
+async function checkLinuxWriteBoundary() {
+  try {
+    const { resolveLinuxHostClass, formatLinuxHostClassNote } = await import("./linux-host-class-YDWQX65O.js");
+    const resolution = resolveLinuxHostClass();
+    if (resolution.hostClass === "desktop-unacked") {
+      return {
+        name: "Linux write boundary",
+        category: "system",
+        status: "warn",
+        message: "Linux desktop write consent is not recorded; on a VM, container or cloud host run `build sandbox trust linux --host isolated`, on a desktop `--ack-desktop`",
+        details: "This is not a sandbox-blocked provider. Write-capable runs need `build sandbox trust linux --ack-desktop` or, for a VM/container/cloud instance, `build sandbox trust linux --host isolated`."
+      };
+    }
+    if (resolution.hostClass === "not-applicable") {
+      return {
+        name: "Linux write boundary",
+        category: "system",
+        status: "pass",
+        message: "Host class not applicable on this platform",
+        details: `source=${resolution.source}`
+      };
+    }
+    const note = resolution.note ?? formatLinuxHostClassNote(resolution);
+    return {
+      name: "Linux write boundary",
+      category: "system",
+      status: "pass",
+      message: `Host class ${resolution.hostClass} (source=${resolution.source}); writes allowed`,
+      details: note ?? "Provider CLIs can write anywhere $USER can. This is not Seatbelt-sandboxed."
+    };
+  } catch (error) {
+    return {
+      name: "Linux write boundary",
+      category: "system",
+      status: "info",
+      message: "Linux host-class posture could not be resolved",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function checkVerificationPrivilegeBoundary() {
+  let verificationLabel = "unavailable";
+  try {
+    const { PROJECT_VERIFICATION_SANDBOX_ID, resolveSandboxLabel } = await import("./safety-stanza-HE6GXP4G.js");
+    verificationLabel = resolveSandboxLabel(
+      PROJECT_VERIFICATION_SANDBOX_ID,
+      PROJECT_VERIFICATION_SANDBOX_ID
+    );
+  } catch {
+    verificationLabel = "unavailable";
+  }
+  return {
+    name: "Verification Privileges",
+    category: "system",
+    status: "info",
+    message: "Project verification wraps when a boundary is available; otherwise it is an ordinary child",
+    details: `Test, build, lint, and typecheck commands from the target repository wrap when a generated macOS seatbelt or accepted container boundary is available. On unsupported platforms or when the sandbox is disabled, they run as ordinary child processes. Live verification posture: ${verificationLabel}. The command allowlist constrains the command string, not what the invoked script does. Treat running Build against an unfamiliar repository as running that repository's code. See docs/reference/SECURITY.md (Project Verification Executes Target-Repository Code).`
+  };
+}
+async function checkClaudeStrictMcpConfig() {
+  let command;
+  let prefixArgs;
+  try {
+    const resolved = resolveProviderCliCommand("claude");
+    command = resolved.command;
+    prefixArgs = resolved.prefixArgs ?? [];
+  } catch {
+    return {
+      name: "Claude strict-mcp-config",
+      category: "providers",
+      status: "info",
+      message: "Claude CLI not configured; skipping strict-mcp-config check"
+    };
+  }
+  const probe = await probeProviderCli(command, ["--version"], prefixArgs, {
+    providerId: "claude"
+  });
+  if (!probe.present) {
+    return {
+      name: "Claude strict-mcp-config",
+      category: "providers",
+      status: "info",
+      message: "Claude CLI not installed; skipping strict-mcp-config check"
+    };
+  }
+  if (!hasStrictMcpConfigBeenProbed()) {
+    const { wrapWithSandbox } = await import("./sandbox-ASWCDYZL.js");
+    const { metadata } = await import("./metadata-UKSMWM6J.js");
+    const sandboxed = wrapWithSandbox({
+      workingDir: process.cwd(),
+      command,
+      args: [...prefixArgs, "--help"],
+      providerName: metadata.name,
+      env: process.env
+    });
+    await probeStrictMcpConfig(
+      sandboxed?.command ?? command,
+      sandboxed?.args ?? [...prefixArgs, "--help"]
+    );
+  }
+  if (!hasStrictMcpConfigBeenProbed()) {
+    return {
+      name: "Claude strict-mcp-config",
+      category: "providers",
+      status: "info",
+      message: "Claude CLI --strict-mcp-config support not determined; probe did not complete",
+      details: "The claude --help probe timed out or failed to start; re-run doctor to retry."
+    };
+  }
+  const supported = isStrictMcpConfigSupported();
+  if (supported) {
+    return {
+      name: "Claude strict-mcp-config",
+      category: "providers",
+      status: "pass",
+      message: "Claude CLI supports --strict-mcp-config; judge MCP isolation active"
+    };
+  }
+  return {
+    name: "Claude strict-mcp-config",
+    category: "providers",
+    status: "warn",
+    message: "Claude CLI does not support --strict-mcp-config; judge MCP isolation unavailable",
+    details: "Judge runs may inherit project MCP servers, reducing determinism. Upgrade the Claude CLI to enable strict MCP isolation."
+  };
+}
+async function checkLegacyClaudePlugin() {
+  const { checkClaudeCode } = await import("./setup-claude-code-NF4ZSHVE.js");
+  const { resolveBuildRoot } = await import("./build-root-S7DINODY.js");
+  const result = await checkClaudeCode(resolveBuildRoot(), { scope: "user" });
+  const cleanupCommand = "build provider disconnect claude";
+  if (!result.hasLegacyResidue && result.pluginState.hasClaudeCli && !result.pluginState.listAvailable) {
+    return {
+      name: "Legacy Claude plugin",
+      category: "providers",
+      status: "info",
+      message: "legacy plugin residue could not be checked",
+      details: `Claude plugin enumeration was unavailable. Optional cleanup: ${cleanupCommand}. Does not affect native Claude CLI provider readiness.`
+    };
+  }
+  if (!result.hasLegacyResidue) {
+    return {
+      name: "Legacy Claude plugin",
+      category: "providers",
+      status: "pass",
+      message: "no legacy Build Claude Code plugin residue"
+    };
+  }
+  return {
+    name: "Legacy Claude plugin",
+    category: "providers",
+    status: "info",
+    message: `legacy residue present (plugin ids: ${result.pluginState.installedIds.join(", ")})`,
+    details: `Optional cleanup: ${cleanupCommand}. Does not affect native Claude CLI provider readiness.`
+  };
+}
+async function checkLegacyRepoLocalTelemetry(buildDir) {
+  const { hasLegacyRepoLocalTelemetryPaths } = await import("./data-migration-state-OAUL2WPQ.js");
+  const legacy = hasLegacyRepoLocalTelemetryPaths(buildDir);
+  const present = [legacy.db, legacy.invocations, legacy.synthesis].filter(
+    (entry) => entry !== null
+  );
+  if (present.length === 0) {
+    return null;
+  }
+  const parts = [];
+  for (const legacyDb of [legacy.db, legacy.invocations]) {
+    if (!legacyDb) continue;
+    parts.push(
+      `${legacyDb} is leftover checkout SQLite; the live databases are under the data root. Run "build data migrate execute" to merge those databases. Do not delete the checkout copy until migration has finished.`
+    );
+  }
+  if (legacy.synthesis) {
+    parts.push(
+      `${legacy.synthesis} is leftover checkout synthesis; live artifacts write under the resolved telemetry directory (printed by \`build doctor --verbose\`). \`build data migrate execute\` does not move synthesis records. Do not delete this path.`
+    );
+  }
+  return {
+    name: "Legacy repo-local telemetry",
+    category: "build",
+    status: "info",
+    message: "Legacy repo-local telemetry present",
+    details: parts.join(" ")
+  };
+}
+async function checkDatabases(cwd) {
+  const buildDir = path3.join(cwd, ".build-project");
+  const dbDir = TelemetryPathResolver.getInstance().resolveDbDir(buildDir);
+  const variantsDbPath = path3.join(dbDir, "variants.db");
+  const validationsDbPath = path3.join(dbDir, "validations.db");
+  const checks = [];
+  const legacyCheck = await checkLegacyRepoLocalTelemetry(buildDir);
+  if (legacyCheck) {
+    checks.push(legacyCheck);
+  }
+  let variantsDbExists = false;
+  try {
+    await fs3.stat(variantsDbPath);
+    variantsDbExists = true;
+  } catch {
+  }
+  if (!variantsDbExists) {
+    checks.push({
+      name: "variants.db",
+      category: "build",
+      status: "info",
+      message: "Not initialized yet",
+      details: 'Telemetry database is created automatically on first execution. Run "build init --db" to pre-create, or "build doctor --fix" to initialize now.',
+      fixable: true
+    });
+  } else {
+    try {
+      const SqliteDB = await getBetterSqlite3();
+      const db = new SqliteDB(variantsDbPath, { readonly: true });
+      try {
+        const result = db.prepare("SELECT 1 as test").get();
+        if (result?.test !== 1) {
+          checks.push({
+            name: "variants.db",
+            category: "build",
+            status: "fail",
+            message: "Database query failed",
+            details: variantsDbPath,
+            fixable: true
+          });
+          db.close();
+          return checks;
+        }
+        const integrityResult = db.prepare("PRAGMA quick_check").get();
+        if (integrityResult?.quick_check !== "ok") {
+          checks.push({
+            name: "variants.db",
+            category: "build",
+            status: "fail",
+            message: "Database integrity check failed",
+            details: `${variantsDbPath} - Run "build doctor --fix"; if corruption remains, follow the database quarantine procedure in docs/TROUBLESHOOTING.md`,
+            fixable: true
+          });
+          db.close();
+          return checks;
+        }
+        const schemaVersion = checkSchemaVersion(db);
+        if (schemaVersion !== SCHEMA_VERSION) {
+          checks.push({
+            name: "variants.db",
+            category: "build",
+            status: "warn",
+            message: `Schema version mismatch (expected ${SCHEMA_VERSION}, found ${schemaVersion})`,
+            details: variantsDbPath,
+            fixable: true
+          });
+        } else {
+          checks.push({
+            name: "variants.db",
+            category: "build",
+            status: "pass",
+            message: `Healthy (schema v${schemaVersion})`,
+            details: variantsDbPath
+          });
+        }
+        db.close();
+      } catch (error) {
+        db.close();
+        checks.push({
+          name: "variants.db",
+          category: "build",
+          status: "fail",
+          message: "Database error",
+          details: error instanceof Error ? error.message : String(error),
+          fixable: true
+        });
+      }
+    } catch (error) {
+      const likelyNativeMismatch = isLikelyBetterSqlite3NativeLoadMismatch(error);
+      checks.push({
+        name: "variants.db",
+        category: "build",
+        status: "fail",
+        message: likelyNativeMismatch ? "better-sqlite3 native module load mismatch" : "Database could not be opened",
+        details: formatDatabaseNativeErrorDetails(error),
+        fixable: true
+      });
+    }
+  }
+  let validationsDbExists = false;
+  try {
+    await fs3.stat(validationsDbPath);
+    validationsDbExists = true;
+  } catch {
+  }
+  if (!validationsDbExists) {
+    checks.push({
+      name: "validations.db",
+      category: "build",
+      status: "info",
+      message: "Not present (optional)"
+    });
+  } else {
+    try {
+      const SqliteDB = await getBetterSqlite3();
+      const db = new SqliteDB(validationsDbPath, { readonly: true });
+      try {
+        const result = db.prepare("SELECT 1 as test").get();
+        if (result?.test === 1) {
+          checks.push({
+            name: "validations.db",
+            category: "build",
+            status: "pass",
+            message: "Accessible",
+            details: validationsDbPath
+          });
+        }
+        db.close();
+      } catch (error) {
+        db.close();
+        checks.push({
+          name: "validations.db",
+          category: "build",
+          status: "warn",
+          message: "Database error",
+          details: error instanceof Error ? error.message : String(error)
+        });
+      }
+    } catch (error) {
+      const likelyNativeMismatch = isLikelyBetterSqlite3NativeLoadMismatch(error);
+      checks.push({
+        name: "validations.db",
+        category: "build",
+        status: "warn",
+        message: likelyNativeMismatch ? "better-sqlite3 native module load mismatch" : "Database could not be opened",
+        details: formatDatabaseNativeErrorDetails(error)
+      });
+    }
+  }
+  return checks;
+}
+async function checkStateMarker(cwd) {
+  const stateFile = path3.join(cwd, ".build-project", "state", "init.json");
+  try {
+    const content = await fs3.readFile(stateFile, "utf-8");
+    const state = JSON.parse(content);
+    const issues = [];
+    if (state.schemaVersion !== SCHEMA_VERSION) {
+      issues.push(`Schema v${state.schemaVersion} (expected v${SCHEMA_VERSION})`);
+    }
+    if (state.tier !== "runtime" && state.tier !== "full") {
+      issues.push(`Invalid tier: ${state.tier}`);
+    }
+    if (issues.length > 0) {
+      return {
+        name: "State Marker",
+        category: "build",
+        status: "warn",
+        message: "State file has issues",
+        details: issues.join(", "),
+        fixable: true
+      };
+    }
+    return {
+      name: "State Marker",
+      category: "build",
+      status: "pass",
+      message: `Initialized (v${state.version}, tier: ${state.tier})`,
+      details: state.lastCheckedAt ? `Last checked: ${new Date(state.lastCheckedAt).toLocaleString()}` : "Last checked: unknown"
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        name: "State Marker",
+        category: "build",
+        status: "warn",
+        message: "State file not found",
+        details: 'Run "build doctor --fix" to initialize',
+        fixable: true
+      };
+    }
+    return {
+      name: "State Marker",
+      category: "build",
+      status: "warn",
+      message: "Cannot read state file",
+      details: error instanceof Error ? error.message : String(error),
+      fixable: true
+    };
+  }
+}
+async function checkTelemetryMode(repoRoot) {
+  const buildDir = getRuntimeEnv("BUILD_TELEMETRY_DIR") ?? path3.join(repoRoot, ".build-project");
+  const dbDir = TelemetryPathResolver.getInstance().resolveDbDir(buildDir);
+  const variantsDbPath = path3.join(dbDir, "variants.db");
+  try {
+    await fs3.stat(variantsDbPath);
+    const SqliteDB = await getBetterSqlite3();
+    const db = new SqliteDB(variantsDbPath, { readonly: true });
+    try {
+      db.prepare("SELECT 1").get();
+      db.close();
+      return {
+        name: "Telemetry Mode",
+        category: "build",
+        status: "pass",
+        message: "Database mode (full features)",
+        details: variantsDbPath
+      };
+    } catch (_error) {
+      db.close();
+      return {
+        name: "Telemetry Mode",
+        category: "build",
+        status: "warn",
+        message: "Degraded mode (JSONL-only)",
+        details: variantsDbPath
+      };
+    }
+  } catch (_error) {
+    return {
+      name: "Telemetry Mode",
+      category: "build",
+      status: "warn",
+      message: "Degraded mode (JSONL-only)",
+      details: variantsDbPath
+    };
+  }
+}
+async function resolveBuildPackageRoot() {
+  let current = path3.dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    try {
+      const packageJsonPath = path3.join(current, "package.json");
+      const packageJson = JSON.parse(await fs3.readFile(packageJsonPath, "utf8"));
+      if (packageJson.name === "@ebrindley/build") {
+        return current;
+      }
+    } catch {
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return process.cwd();
+    }
+    current = parent;
+  }
+}
+async function checkDistArtifacts() {
+  try {
+    const { checkBuildFreshness } = await import("./flywheel-preflight-III2C7TH.js");
+    const result = await checkBuildFreshness(await resolveBuildPackageRoot());
+    if (result.passed) {
+      return {
+        name: "Build Artifacts",
+        category: "build",
+        status: "pass",
+        message: result.metadata?.packageMode ? "packaged dist artifacts are present" : "dist/entry.js is present and fresh",
+        details: result.warning
+      };
+    }
+    return {
+      name: "Build Artifacts",
+      category: "build",
+      status: "warn",
+      message: "Build artifacts need refresh",
+      details: result.error ? `${result.error} This is expected after source changes in a development checkout. Most source tests do not require fresh dist output; run npm run build when testing the bundled build binary against the latest source.` : "Most source tests do not require fresh dist output; run npm run build when testing the bundled build binary against the latest source."
+    };
+  } catch (error) {
+    return {
+      name: "Build Artifacts",
+      category: "build",
+      status: "warn",
+      message: "Could not verify dist artifacts",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function calculateDirectorySize(dirPath) {
+  let totalSize = 0;
+  const entries = await fs3.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path3.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      totalSize += await calculateDirectorySize(entryPath);
+    } else if (entry.isFile()) {
+      const stat2 = await fs3.stat(entryPath);
+      totalSize += stat2.size;
+    }
+  }
+  return totalSize;
+}
+var FOREIGN_COORDINATION_LOCK_REMEDIATION = "Local process liveness cannot be verified for foreign locks. Verify the owning machine is not running Build against this repo, then delete the lock file:";
+var UNREADABLE_COORDINATION_LOCK_REMEDIATION = "Build cannot safely verify unreadable coordination locks. Verify no Build process owns the lock, then delete the lock file:";
+function formatCoordinationLockAge(ageMs) {
+  const ageSec = Math.round(ageMs / 1e3);
+  if (ageSec < 60) {
+    return `${ageSec}s`;
+  }
+  const ageMin = Math.round(ageSec / 60);
+  if (ageMin < 60) {
+    return `${ageMin}m`;
+  }
+  const ageHours = Math.round(ageMin / 60);
+  return `${ageHours}h`;
+}
+function formatCoordinationLockLine(diagnostic) {
+  const machinePart = diagnostic.machineIdShort ?? "unknown";
+  const pidPart = diagnostic.pid ?? "n/a";
+  const agePart = formatCoordinationLockAge(diagnostic.ageMs);
+  return `${diagnostic.name}: ${diagnostic.classification} (pid=${pidPart}, machine=${machinePart}, age=${agePart})`;
+}
+function isForeignStaleCoordinationLock(diagnostic, staleMs) {
+  if (diagnostic.classification !== "foreign-machine") {
+    return false;
+  }
+  return diagnostic.ageMs >= staleMs;
+}
+async function checkCoordinationLocks() {
+  const { DEFAULT_STALE_LOCK_MS, diagnoseCoordinationLocks } = await import("./backend-YUTFDZXZ.js");
+  const cwd = process.cwd();
+  const locksDir = path3.join(cwd, ".build-project", "planning", "coordination", "locks");
+  const diagnostics = diagnoseCoordinationLocks(locksDir);
+  if (diagnostics.length === 0) {
+    return null;
+  }
+  const foreignStaleLocks = diagnostics.filter(
+    (diagnostic) => isForeignStaleCoordinationLock(diagnostic, DEFAULT_STALE_LOCK_MS)
+  );
+  const unreadableLocks = diagnostics.filter((d) => d.classification === "unreadable");
+  const liveCount = diagnostics.filter((d) => d.classification === "live").length;
+  const staleSameMachineCount = diagnostics.filter(
+    (d) => d.classification === "stale-same-machine"
+  ).length;
+  const foreignCount = diagnostics.filter((d) => d.classification === "foreign-machine").length;
+  const detailLines = diagnostics.map(formatCoordinationLockLine);
+  const remediationLines = foreignStaleLocks.map(
+    (diagnostic) => `${FOREIGN_COORDINATION_LOCK_REMEDIATION} ${diagnostic.lockPath}`
+  );
+  remediationLines.push(
+    ...unreadableLocks.map(
+      (diagnostic) => `${UNREADABLE_COORDINATION_LOCK_REMEDIATION} ${diagnostic.lockPath}`
+    )
+  );
+  const manualRemediationCount = foreignStaleLocks.length + unreadableLocks.length;
+  let status = "pass";
+  if (foreignStaleLocks.length > 0 || unreadableLocks.length > 0) {
+    status = "warn";
+  } else if (staleSameMachineCount > 0) {
+    status = "info";
+  }
+  const messageParts = [`${diagnostics.length} coordination lock(s)`];
+  if (liveCount > 0) {
+    messageParts.push(`${liveCount} live`);
+  }
+  if (staleSameMachineCount > 0) {
+    messageParts.push(`${staleSameMachineCount} stale-same-machine`);
+  }
+  if (foreignCount > 0) {
+    messageParts.push(`${foreignCount} foreign-machine`);
+  }
+  if (unreadableLocks.length > 0) {
+    messageParts.push(`${unreadableLocks.length} unreadable`);
+  }
+  if (manualRemediationCount > 0) {
+    messageParts.push(`${manualRemediationCount} require manual remediation`);
+  }
+  const detailsParts = [...detailLines];
+  if (remediationLines.length > 0) {
+    detailsParts.push("", ...remediationLines);
+  }
+  return {
+    name: "Coordination Locks",
+    category: "build",
+    status,
+    message: messageParts.join("; "),
+    details: detailsParts.join("\n     ")
+  };
+}
+async function checkDiskSpace(repoRoot) {
+  const buildDir = getRuntimeEnv("BUILD_TELEMETRY_DIR") ?? path3.join(repoRoot, ".build-project");
+  const telemetryDir = TelemetryPathResolver.getInstance().resolveTelemetryDir(buildDir);
+  try {
+    try {
+      await fs3.stat(telemetryDir);
+    } catch (_error) {
+      return {
+        name: "Telemetry Storage",
+        category: "resources",
+        status: "info",
+        message: "Telemetry directory not found",
+        details: 'Run "build init" to initialize'
+      };
+    }
+    const totalSize = await calculateDirectorySize(telemetryDir);
+    const sizeMB = totalSize / (1024 * 1024);
+    const sizeGB = sizeMB / 1024;
+    if (sizeGB > 2) {
+      return {
+        name: "Telemetry Storage",
+        category: "resources",
+        status: "fail",
+        message: `Telemetry directory very large: ${sizeGB.toFixed(2)} GB`,
+        details: 'Consider running "build cleanup" to remove old data'
+      };
+    }
+    if (sizeMB > 500) {
+      return {
+        name: "Telemetry Storage",
+        category: "resources",
+        status: "warn",
+        message: `Telemetry directory: ${sizeMB.toFixed(1)} MB`,
+        details: "Consider periodic cleanup"
+      };
+    }
+    return {
+      name: "Telemetry Storage",
+      category: "resources",
+      status: "pass",
+      message: `Telemetry directory: ${sizeMB.toFixed(1)} MB`,
+      details: telemetryDir
+    };
+  } catch (error) {
+    return {
+      name: "Telemetry Storage",
+      category: "resources",
+      status: "fail",
+      message: "Cannot measure telemetry directory size",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function checkMemory() {
+  try {
+    const totalGB = os.totalmem() / (1024 * 1024 * 1024);
+    const freeGB = getAvailableMemoryGB();
+    const usedPercent = Math.max(0, (totalGB - freeGB) / totalGB * 100);
+    if (freeGB < 0.5) {
+      return {
+        name: "Memory",
+        category: "resources",
+        status: "fail",
+        message: `Critical: only ${freeGB.toFixed(2)} GB available`,
+        details: `${usedPercent.toFixed(1)}% used of ${totalGB.toFixed(1)} GB total`
+      };
+    }
+    if (freeGB < 1) {
+      return {
+        name: "Memory",
+        category: "resources",
+        status: "warn",
+        message: `Low memory: ${freeGB.toFixed(2)} GB available`,
+        details: `${usedPercent.toFixed(1)}% used of ${totalGB.toFixed(1)} GB total`
+      };
+    }
+    return {
+      name: "Memory",
+      category: "resources",
+      status: "pass",
+      message: `${freeGB.toFixed(2)} GB available of ${totalGB.toFixed(1)} GB`,
+      details: `${usedPercent.toFixed(1)}% used`
+    };
+  } catch (error) {
+    return {
+      name: "Memory",
+      category: "resources",
+      status: "fail",
+      message: "Cannot check system memory",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function checkNodeVersion() {
+  const currentVersion = process.version;
+  const preferredPath = await preferredNode24Path();
+  if (!isSupportedNodeMajor(parseNodeMajor(currentVersion))) {
+    return {
+      name: "Node.js",
+      category: "system",
+      status: "fail",
+      message: `Node.js ${currentVersion} is not supported`,
+      details: formatNode24Remediation(preferredPath)
+    };
+  }
+  const homebrewDetail = preferredPath ? ` | Homebrew Node 24: ${preferredPath}` : "";
+  return {
+    name: "Node.js",
+    category: "system",
+    status: "pass",
+    message: `Node.js ${currentVersion}`,
+    details: `${process.platform}/${process.arch} \u2014 ${process.execPath}${homebrewDetail}`
+  };
+}
+async function checkGitRepository() {
+  try {
+    const result = await execa("git", ["rev-parse", "--is-inside-work-tree"]);
+    if (result.stdout.trim() === "true") {
+      let branchName = "unknown";
+      let unbornBranch;
+      const branch = await execa("git", ["rev-parse", "--symbolic-full-name", "HEAD"], {
+        reject: false
+      });
+      const parsedBranch = branch.exitCode === 0 ? parseCurrentBranchRef(branch.stdout) : "HEAD";
+      if (parsedBranch !== "HEAD") {
+        branchName = parsedBranch;
+      } else {
+        unbornBranch = await detectUnbornBranch(process.cwd());
+        if (unbornBranch) {
+          branchName = unbornBranch;
+        } else {
+          const symbolicBranch = await execa("git", ["symbolic-ref", "--short", "HEAD"], {
+            reject: false
+          });
+          if (symbolicBranch.exitCode === 0 && symbolicBranch.stdout.trim()) {
+            branchName = symbolicBranch.stdout.trim();
+          }
+        }
+      }
+      const unbornNote = unbornBranch ? "; repository has no commits yet" : "";
+      let details;
+      try {
+        const remoteResult = await execa("git", ["remote", "get-url", "origin"], { reject: false });
+        const remoteUrl = remoteResult.stdout.trim();
+        details = remoteUrl ? `branch: ${branchName}, remote: ${remoteUrl}` : `branch: ${branchName}, no remote`;
+      } catch (_remoteError) {
+        details = `branch: ${branchName}, no remote`;
+      }
+      try {
+        const missing = [];
+        for (const key of ["user.name", "user.email"]) {
+          const identity = await execGit(["config", "--get", key], { cwd: process.cwd() });
+          if (identity.exitCode !== 0 || !identity.stdout.trim()) missing.push(key);
+        }
+        if (missing.length > 0) {
+          return {
+            name: "Git Repository",
+            category: "git",
+            status: "warn",
+            message: `Inside git repository (branch: ${branchName})${unbornNote}; commit identity is incomplete`,
+            details: `${details}. Set ${missing.map((key) => `git config ${key} "${key === "user.name" ? "Your Name" : "you@example.com"}"`).join(" and ")} (or use --global for your usual identity).`
+          };
+        }
+      } catch {
+        return {
+          name: "Git Repository",
+          category: "git",
+          status: "warn",
+          message: `Inside git repository (branch: ${branchName})${unbornNote}; commit identity could not be checked`,
+          details
+        };
+      }
+      if (unbornBranch) {
+        return {
+          name: "Git Repository",
+          category: "git",
+          status: "warn",
+          message: `Inside git repository (branch: ${branchName})${unbornNote}`,
+          details: `${details}. HEAD does not resolve to a commit yet; the first commit will create ${branchName}.`
+        };
+      }
+      return {
+        name: "Git Repository",
+        category: "git",
+        status: "pass",
+        message: `Inside git repository (branch: ${branchName})`,
+        details
+      };
+    }
+    return {
+      name: "Git Repository",
+      category: "git",
+      status: "warn",
+      message: "Not inside a git repository",
+      details: "Some features may not work correctly"
+    };
+  } catch (_error) {
+    return {
+      name: "Git Repository",
+      category: "git",
+      status: "warn",
+      message: "Not inside a git repository",
+      details: "Some features may not work correctly"
+    };
+  }
+}
+var DOCTOR_LINK_CHECK_TIMEOUT_MS = 5e3;
+async function checkKnowledgeKit(cwd, options = {}) {
+  const checkLinks = options.checkLinks === true;
+  try {
+    const result = await knowledgeDoctorChecks(cwd, {
+      checkLinks,
+      linkTimeoutMs: DOCTOR_LINK_CHECK_TIMEOUT_MS,
+      ...options.probeLink ? { probeLink: options.probeLink } : {}
+    });
+    if (!result.manifestPresent) {
+      const intent = readIntentContract(cwd);
+      if (intent.status === "ok" && intent.contract.status !== "retired") {
+        const resolved = resolveIntent(detectStack(cwd), intent.contract).contract;
+        const lines = resolved.dimensions.map((d) => describeDimension(d));
+        const hasConflict = resolved.status === "conflict";
+        return {
+          name: "Knowledge Kit",
+          category: "knowledge",
+          status: "warn",
+          message: hasConflict ? `No kit accepted; stack intent "${intent.contract.spec}" has unresolved conflicts \u2014 run build init knowledge offer (headless) or build init in a terminal to receive the kit` : `No knowledge kit accepted yet (stack intent "${intent.contract.spec}" pending) \u2014 run build init knowledge offer (headless) or build init in a terminal to receive the kit`,
+          details: `Declared ${intent.contract.declaredAt.slice(0, 10)}${intent.contract.rationale ? ` \u2014 ${intent.contract.rationale}` : ""}
+     ${lines.join("\n     ")}
+     Run 'build init knowledge offer' (headless) or 'build init' in a terminal to review recommendations${hasConflict ? " and resolve the conflict" : ""}.`
+        };
+      }
+      return {
+        name: "Knowledge Kit",
+        category: "knowledge",
+        status: "info",
+        message: isStackUndetectedAndUndeclared(cwd) ? `No knowledge kit accepted yet; no stack detected. If the intended stack is decided, declare it: ${DECLARE_STACK_COMMAND}` : "No knowledge kit accepted yet",
+        details: "Run 'build init' in an interactive session to review stack recommendations."
+      };
+    }
+    if (result.findings.length === 0) {
+      return {
+        name: "Knowledge Kit",
+        category: "knowledge",
+        status: "pass",
+        message: checkLinks ? "Knowledge manifest present; no issues found (links checked)" : "Knowledge manifest present; no issues found"
+      };
+    }
+    const severityToStatus = (severity) => severity === "error" ? "fail" : severity === "warn" ? "warn" : "info";
+    const worst = result.findings.some((f) => f.severity === "error") ? "fail" : result.findings.some((f) => f.severity === "warn") ? "warn" : "info";
+    const details = result.findings.map((finding) => `[${severityToStatus(finding.severity)}] ${finding.message}`).join("\n     ");
+    return {
+      name: "Knowledge Kit",
+      category: "knowledge",
+      status: worst,
+      message: `${result.findings.length} knowledge finding(s)`,
+      details
+    };
+  } catch (error) {
+    return {
+      name: "Knowledge Kit",
+      category: "knowledge",
+      status: "warn",
+      message: "Could not run knowledge checks",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function runAllHealthChecks(options) {
+  const allChecks = [];
+  if (options.providersOnly) {
+    const includeVerboseProviderDetails2 = Boolean(options.verbose) && !options.json;
+    allChecks.push(
+      await checkProviderCLIs({
+        includeVerboseDetails: includeVerboseProviderDetails2,
+        all: options.all,
+        provider: options.provider,
+        probe: options.probe,
+        strict: options.strict,
+        requireReady: options.requireReady
+      })
+    );
+    allChecks.push(...await collectProviderExtraHealthChecks(options));
+    return allChecks;
+  }
+  allChecks.push(await checkNodeVersion());
+  allChecks.push(await checkMemory());
+  allChecks.push(await checkGit());
+  allChecks.push(await checkGitRepository());
+  const includeVerboseProviderDetails = Boolean(options.verbose) && !options.json;
+  allChecks.push(
+    await checkProviderCLIs({
+      includeVerboseDetails: includeVerboseProviderDetails,
+      all: options.all,
+      provider: options.provider,
+      probe: options.probe,
+      strict: options.strict,
+      requireReady: options.requireReady
+    })
+  );
+  allChecks.push(...await collectProviderExtraHealthChecks(options));
+  allChecks.push(await checkVerificationPrivilegeBoundary());
+  allChecks.push(await checkLinuxWriteBoundary());
+  const repoRoot = resolveRepoRootForBuildDir(process.cwd());
+  allChecks.push(await checkBuildDirectory(repoRoot));
+  const nestedCheck = await checkNestedBuildDirectory(repoRoot);
+  if (nestedCheck) allChecks.push(nestedCheck);
+  allChecks.push(await checkRequiredDirectories(repoRoot));
+  allChecks.push(await checkRepoTaskTypes(repoRoot));
+  allChecks.push(await checkArchiveReconciliation());
+  allChecks.push(await checkProviderConfig(repoRoot));
+  const executionRolesCheck = await checkExecutionRoles();
+  if (executionRolesCheck) allChecks.push(executionRolesCheck);
+  allChecks.push(await checkSteeringInstructions());
+  allChecks.push((await import("./doctor-instructions-import-JXHDDOE5.js")).checkInstructionsImport());
+  allChecks.push(await checkNativeSqlite());
+  allChecks.push(...await checkDatabases(repoRoot));
+  allChecks.push(await checkStateMarker(repoRoot));
+  allChecks.push(await checkTelemetryMode(repoRoot));
+  allChecks.push(await checkDistArtifacts());
+  const coordinationLockCheck = await checkCoordinationLocks();
+  if (coordinationLockCheck) allChecks.push(coordinationLockCheck);
+  const knowledgeCwd = repoRoot;
+  allChecks.push(await checkKnowledgeKit(knowledgeCwd, { checkLinks: options.checkLinks }));
+  allChecks.push(checkPendingInitNotices(knowledgeCwd));
+  allChecks.push(checkPendingOfferNotice(knowledgeCwd));
+  const purposeCheck = (await import("./doctor-purpose-6YJOXPBE.js")).checkPurposeSuggestion(knowledgeCwd);
+  if (purposeCheck) allChecks.push(purposeCheck);
+  allChecks.push(...(await import("./doctor-context-blocks-LPY75VZA.js")).checkContextBlocks(knowledgeCwd));
+  allChecks.push(await checkCiIntegrationHealth(knowledgeCwd));
+  allChecks.push(...await checkGuardrails(knowledgeCwd));
+  const storageCheck = checkPlanningStorageBackend(repoRoot);
+  if (storageCheck) allChecks.push(storageCheck);
+  const branchNameCheck = await checkBuildBranchNameConflict(repoRoot);
+  if (branchNameCheck) allChecks.push(branchNameCheck);
+  allChecks.push(await checkDiskSpace(repoRoot));
+  allChecks.push(await checkConcurrencyBudget());
+  return allChecks;
+}
+async function checkConcurrencyBudget() {
+  try {
+    const budget = detectHostConcurrencyBudget();
+    const basis = `${budget.totalMemoryGB.toFixed(0)} GB RAM, ${budget.performanceCores} performance cores`;
+    const recommendation = `up to ${budget.legSlots} concurrent legs, ${budget.validationSlots} concurrent validations (${basis})`;
+    let effectiveValue;
+    try {
+      const merged = await new ConfigManager().loadConfig();
+      const asValidConcurrency = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+      effectiveValue = asValidConcurrency(merged.config.variants?.maxConcurrent) ?? asValidConcurrency(merged.config.worktree?.maxConcurrent);
+    } catch {
+    }
+    if (effectiveValue !== void 0 && effectiveValue > budget.legSlots) {
+      return {
+        name: "Concurrency budget",
+        category: "resources",
+        status: "warn",
+        message: `Effective max concurrent (${effectiveValue}) exceeds this host's recommendation`,
+        details: `This host recommends ${recommendation}. The configured value still runs as asked; validation pacing covers only repair-loop gates and baseline capture, and memory pressure shedding runs only in health-assisted mode and the flywheel.`
+      };
+    }
+    return {
+      name: "Concurrency budget",
+      category: "resources",
+      status: "info",
+      message: `Recommended: ${recommendation}`,
+      details: `Effective max concurrent (config or default): ${effectiveValue ?? 4}. Recommendations are advisory; Build runs what you ask for.`
+    };
+  } catch (error) {
+    return {
+      name: "Concurrency budget",
+      category: "resources",
+      status: "info",
+      message: "Could not compute a host concurrency recommendation",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function displayHealthResults(checks, options) {
+  if (options.json) {
+    console.log(JSON.stringify(checks, null, 2));
+    return;
+  }
+  console.log(chalk2.bold.cyan("\nBuild Health Check\n"));
+  const categories = {
+    system: [],
+    git: [],
+    providers: [],
+    build: [],
+    knowledge: [],
+    guardrails: [],
+    resources: []
+  };
+  for (const check of checks) {
+    categories[check.category]?.push(check);
+  }
+  const categoryNames = {
+    system: "System Environment",
+    git: "Git Configuration",
+    providers: "AI Providers",
+    build: "Build Installation",
+    knowledge: "Knowledge & Init Drift",
+    guardrails: "Guardrails",
+    resources: "System Resources"
+  };
+  for (const [category, categoryChecks] of Object.entries(categories)) {
+    if (categoryChecks.length === 0) continue;
+    console.log(chalk2.bold(categoryNames[category]));
+    for (const check of categoryChecks) {
+      let statusIcon = "";
+      let statusColor;
+      switch (check.status) {
+        case "pass":
+          statusIcon = "OK";
+          statusColor = chalk2.green;
+          break;
+        case "warn":
+          statusIcon = "Warning: ";
+          statusColor = chalk2.yellow;
+          break;
+        case "fail":
+          statusIcon = "Error";
+          statusColor = chalk2.red;
+          break;
+        case "info":
+          statusIcon = "Info:";
+          statusColor = chalk2.blue;
+          break;
+      }
+      const checkName = check.name.padEnd(25);
+      console.log(`  ${statusColor(statusIcon)} ${chalk2.bold(checkName)} ${check.message}`);
+      if (options.verbose && check.details) {
+        console.log(chalk2.gray(`     ${check.details}`));
+      }
+    }
+    console.log();
+  }
+  const passCount = checks.filter((c) => c.status === "pass").length;
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  const failCount = checks.filter((c) => c.status === "fail").length;
+  const infoCount = checks.filter((c) => c.status === "info").length;
+  const fixableCount = checks.filter((c) => c.fixable && c.status !== "pass").length;
+  console.log(chalk2.bold.cyan("Summary\n"));
+  console.log(`  ${chalk2.green("Passed")}: ${passCount}`);
+  if (warnCount > 0) console.log(`  ${chalk2.yellow("Warnings")}: ${warnCount}`);
+  if (failCount > 0) console.log(`  ${chalk2.red("Failed")}: ${failCount}`);
+  if (infoCount > 0) console.log(`  ${chalk2.blue("Info")}: ${infoCount}`);
+  console.log();
+  if (failCount > 0) {
+    console.log(chalk2.bold.red("Error: Checks Failed\n"));
+    console.log(chalk2.gray("   Some checks failed. Review the issues above."));
+    if (fixableCount > 0) {
+      console.log(chalk2.gray(`   ${fixableCount} issue(s) can be fixed automatically.`));
+      console.log(chalk2.gray("   Run: build doctor --fix"));
+    }
+  } else if (warnCount > 0) {
+    console.log(chalk2.bold.yellow("Warning: Warnings Detected\n"));
+    console.log(chalk2.gray("   System is operational but some issues were found."));
+    if (fixableCount > 0) {
+      console.log(chalk2.gray(`   ${fixableCount} issue(s) can be fixed automatically.`));
+      console.log(chalk2.gray("   Run: build doctor --fix"));
+    }
+  } else {
+    console.log(chalk2.bold.green("OK: All Systems Healthy\n"));
+    console.log(chalk2.gray("   Build is ready to use!"));
+  }
+  const unrepaired = options.fix ? describeUnrepairedChecks(checks) : void 0;
+  if (unrepaired) console.log(chalk2.gray(`   ${unrepaired}`));
+  if (!options.verbose && (warnCount > 0 || failCount > 0)) {
+    console.log(chalk2.gray("\nTip: Run with --verbose flag for more details"));
+  }
+  console.log();
+}
+function createDoctorCommand() {
+  const health = new Command2("doctor");
+  health.description(
+    "Check system health and diagnose issues\n\nExamples:\n  build doctor                    # Check configured providers only\n  build doctor --all              # Check all known providers\n  build doctor --provider claude  # Check specific provider\n  build doctor --providers-only --provider claude  # Check provider CLI and cached auth evidence\n  build doctor --probe --provider claude  # Probe provider auth and update cached evidence\n  build doctor --verbose          # Show detailed information\n  build doctor --fix              # Automatically repair issues\n  build doctor --json             # Output as JSON\n  build doctor --matrix           # Show provider support matrix"
+  );
+  health.aliases(["d"]);
+  health.addCommand(createDoctorMetricsCommand());
+  health.option("--json", "(OPTIONAL) Output results as JSON");
+  health.option("-v, --verbose", "(OPTIONAL) Show detailed information");
+  health.option("--fix", "(OPTIONAL) Attempt to repair issues automatically");
+  health.option("-a, --all", "(OPTIONAL) Check all known providers");
+  health.option("-p, --provider <id>", "(OPTIONAL) Check specific provider only");
+  health.option("--providers-only", "(OPTIONAL) Check provider CLI and cached auth evidence only");
+  health.option("--matrix", "(OPTIONAL) Show provider support matrix with tier and health status");
+  health.option(
+    "--strict",
+    "(OPTIONAL) Exit non-zero on identity failures (CLI missing, config invalid). Unobserved auth and zero ready providers do not fail"
+  );
+  health.option(
+    "--require-ready",
+    "(OPTIONAL) Exit non-zero when no checked provider can run (opt-in readiness gate)"
+  );
+  health.option("--probe", "(OPTIONAL) Run provider auth probes and update auth liveness cache");
+  health.option("--refresh", "(OPTIONAL) Clear cached auth liveness before checking");
+  health.option(
+    "--check-links",
+    "(OPTIONAL) Probe knowledge-kit source URLs for dead links (network; 5s/link; default off)"
+  );
+  health.action(async (options) => {
+    const validatedOptions = validateCommandOptions(HealthCommandOptionsSchema, options);
+    if (validatedOptions.refresh) {
+      await invalidateAuthOutcome(validatedOptions.provider);
+    }
+    if (validatedOptions.matrix) {
+      const { collectProviderMatrix } = await import("./provider-matrix-2KO2V5OM.js");
+      const { renderProviderMatrix } = await import("./provider-matrix-renderer-MEC3PER7.js");
+      const rows = await collectProviderMatrix({
+        probeAuth: true,
+        providerFilter: validatedOptions.provider
+      });
+      if (validatedOptions.json) {
+        const checks2 = await runAllHealthChecks(validatedOptions);
+        console.log(JSON.stringify({ checks: checks2, providerMatrix: rows }, null, 2));
+        exitForHealthFailures(checks2, validatedOptions);
+        return;
+      }
+      console.log(renderProviderMatrix(rows));
+      const skipNormalChecks = !validatedOptions.all && !validatedOptions.providersOnly && !validatedOptions.fix;
+      if (skipNormalChecks) {
+        if (rows.some((row) => row.status !== "available")) {
+          process.exit(1);
+        }
+        return;
+      }
+    }
+    if (validatedOptions.fix) {
+      const repairOutput = validatedOptions.json ? console.error : console.log;
+      repairOutput(chalk2.bold.cyan("\nRepairing Build Installation\n"));
+      const cwd = resolveRepoRootForBuildDir(process.cwd());
+      const nestedDir = path3.join(cwd, ".build-project", ".build-project");
+      try {
+        const stats = await fs3.stat(nestedDir);
+        if (stats.isDirectory()) {
+          repairOutput(
+            chalk2.gray("Removing nested .build-project/.build-project/ directory (bug artifact)...")
+          );
+          await fs3.rm(nestedDir, { recursive: true, force: true });
+          repairOutput(chalk2.green("  OK Removed nested directory"));
+        }
+      } catch (_error) {
+      }
+      try {
+        const result = await ensureBuildInitialized({
+          cwd,
+          tier: "runtime",
+          repair: true,
+          verbose: validatedOptions.verbose && !validatedOptions.json,
+          allowDegraded: true
+        });
+        if (result.status === "ok") {
+          repairOutput(chalk2.green("OK: Repair completed successfully"));
+        } else if (result.status === "degraded") {
+          repairOutput(chalk2.yellow("Warning: Repair completed with warnings (degraded mode)"));
+        } else {
+          repairOutput(chalk2.red("Error: Repair failed"));
+        }
+        if (result.actions.created.length > 0) {
+          repairOutput(chalk2.gray(`
+Created ${result.actions.created.length} item(s):`));
+          for (const item of result.actions.created) {
+            repairOutput(chalk2.gray(`  - ${item}`));
+          }
+        }
+        if (result.actions.repaired.length > 0) {
+          repairOutput(chalk2.gray(`
+Repaired ${result.actions.repaired.length} item(s):`));
+          for (const item of result.actions.repaired) {
+            repairOutput(chalk2.gray(`  - ${item}`));
+          }
+        }
+        if (result.warnings.length > 0) {
+          repairOutput(chalk2.yellow(`
+Warnings (${result.warnings.length}):`));
+          for (const warning of result.warnings) {
+            repairOutput(chalk2.yellow(`  Warning: ${warning}`));
+          }
+        }
+        if (result.errors.length > 0) {
+          repairOutput(chalk2.red(`
+Errors (${result.errors.length}):`));
+          for (const error of result.errors) {
+            repairOutput(chalk2.red(`  Error ${error.message}`));
+            if (error.path) {
+              repairOutput(chalk2.gray(`    Path: ${error.path}`));
+            }
+          }
+        }
+        if (result.nextSteps.length > 0) {
+          repairOutput(chalk2.bold("\nNext Steps:"));
+          for (const step of result.nextSteps) {
+            repairOutput(chalk2.gray(`  \u2022 ${step}`));
+          }
+        }
+        repairOutput(chalk2.gray(`
+Completed in ${result.initDurationMs}ms`));
+        repairOutput(chalk2.gray(`Telemetry mode: ${result.telemetryMode}`));
+        if (result.schemaVersion) {
+          repairOutput(chalk2.gray(`Schema version: ${result.schemaVersion}`));
+        }
+        repairOutput();
+        repairOutput(chalk2.bold.cyan("Re-running Health Checks\n"));
+      } catch (error) {
+        console.error(
+          chalk2.red("Error: Repair failed:"),
+          error instanceof Error ? error.message : String(error)
+        );
+        process.exit(1);
+      }
+    }
+    const checks = await runAllHealthChecks(validatedOptions);
+    displayHealthResults(checks, validatedOptions);
+    renderDoctorPendingNudges(resolveRepoRootForBuildDir(process.cwd()), validatedOptions);
+    exitForHealthFailures(checks, validatedOptions);
+  });
+  return health;
+}
+
+export {
+  checkPendingInitNotices,
+  checkPendingOfferNotice,
+  renderDoctorPendingNudges,
+  isStrictBlockingWarning,
+  PROVIDER_CLI_SPEC_IDS,
+  checkProviderCLIs,
+  checkLinuxWriteBoundary,
+  checkCoordinationLocks,
+  checkGitRepository,
+  checkKnowledgeKit,
+  runAllHealthChecks,
+  createDoctorCommand
+};
+//# sourceMappingURL=chunk-MQ4TFJAG.js.map