@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/entry.js

@@ -0,0 +1,922 @@
+#!/usr/bin/env node
+import {
+  buildRoutedArgv,
+  isObservationalProcessesHealthInvocation,
+  isObservationalProcessesJsonInvocation,
+  isProjectlessConfigWriteInvocation,
+  isReadOnlyConfigInvocation,
+  matchPlanCommand,
+  matchPlanNestedCommand,
+  renderOrdinaryHelp,
+  resolveCliCommand,
+  resolveStartupBuildDir
+} from "./chunk-EXA26FFC.js";
+import {
+  createLocalCiDetachedChildEnv
+} from "./chunk-SVJM3LJA.js";
+import {
+  TASK_EXEC_COMMAND,
+  routeBareTask
+} from "./chunk-EAEVKNJA.js";
+import {
+  acquireCliBuildLock
+} from "./chunk-LRGH3CCV.js";
+import "./chunk-NRFRY3GE.js";
+import {
+  localCiRootMappingPath
+} from "./chunk-BV3XQQLU.js";
+import "./chunk-PSTKWHHN.js";
+import {
+  setProcessExitHandler
+} from "./chunk-KTMW65UX.js";
+import "./chunk-3JKNRYEE.js";
+import "./chunk-MT2WAIR3.js";
+import {
+  PARENT_ENV_DENYLIST,
+  isSandboxAuthorityEnvVar
+} from "./chunk-WGQAXLNA.js";
+import "./chunk-ONHAMBN6.js";
+import "./chunk-XSJTIFUY.js";
+import {
+  isDebugOutputRequested,
+  isJsonOutputRequested,
+  isQuietOutputRequested,
+  isVerboseOutputRequested,
+  outputPolicyToEnv,
+  resolveOutputPolicyFromArgs
+} from "./chunk-XWIZ6B5S.js";
+import "./chunk-U4DRS6ZW.js";
+import "./chunk-I56TH7VM.js";
+import "./chunk-Z5WGNULV.js";
+import {
+  validateEnvironmentVars
+} from "./chunk-O26L6F7F.js";
+import {
+  readBuildPackageVersion
+} from "./chunk-RJ6RSNT6.js";
+import {
+  assertBuildRuntimeReady,
+  isDiagnosticInvocation,
+  prepareDiagnosticRuntime
+} from "./chunk-ZORW64QH.js";
+import "./chunk-TAJPCXSB.js";
+import {
+  getStableRepoIdentity
+} from "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import {
+  BUILD_CI_RECONCILING,
+  BUILD_CLI_REEXEC_AFTER_BUILD,
+  BUILD_PROJECT_ID,
+  BUILD_RUN_ID,
+  BUILD_TELEMETRY_DIR,
+  createExecutionContext,
+  describeRepoRootOverride,
+  readEnv,
+  resolveCliRepoRoot,
+  setExecutionContext
+} from "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import {
+  sanitizeValue
+} from "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/entry.ts
+import { spawn as spawn2 } from "child_process";
+import { randomUUID } from "crypto";
+import fs2 from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+
+// src/core/ci/local-ci-opportunistic.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import path2 from "path";
+
+// src/core/ci/local-ci-throttle.ts
+import { closeSync, mkdirSync, openSync, statSync, unlinkSync } from "fs";
+import path from "path";
+var RECONCILE_THROTTLE_MS = 6e4;
+function acquireLocalCiReconcileThrottle(mappingPath, now = Date.now()) {
+  const stampPath = `${mappingPath}.reconcile-stamp`;
+  mkdirSync(path.dirname(stampPath), { recursive: true, mode: 448 });
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      closeSync(openSync(stampPath, "wx", 384));
+      return true;
+    } catch (error) {
+      if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) {
+        return false;
+      }
+      try {
+        if (now - statSync(stampPath).mtimeMs < RECONCILE_THROTTLE_MS) return false;
+        unlinkSync(stampPath);
+      } catch {
+        return false;
+      }
+    }
+  }
+  return false;
+}
+
+// src/core/ci/local-ci-opportunistic.ts
+function createLocalCiReconcileChildEnv() {
+  return createLocalCiDetachedChildEnv({ BUILD_CI_RECONCILING: "1" });
+}
+function triggerOpportunisticLocalCiReconcile(input, dependencies = {}) {
+  if (input.command === "ci") return;
+  try {
+    const isReconciling = dependencies.isReconciling ?? (() => readEnv(BUILD_CI_RECONCILING).value === true);
+    if (isReconciling()) return;
+    const mappingPath = localCiRootMappingPath(input.repoRoot);
+    if (!(dependencies.mappingExists ?? existsSync)(mappingPath)) return;
+    if (!(dependencies.acquireThrottle ?? acquireLocalCiReconcileThrottle)(mappingPath)) return;
+    const child = (dependencies.spawnProcess ?? spawn)(
+      process.execPath,
+      [path2.resolve(input.entryPath), "ci", "reconcile", "--quiet"],
+      {
+        cwd: input.repoRoot,
+        detached: process.platform !== "win32",
+        stdio: "ignore",
+        env: createLocalCiReconcileChildEnv()
+      }
+    );
+    child.on("error", () => void 0);
+    child.unref();
+  } catch {
+  }
+}
+
+// src/core/config/mock-providers-policy.ts
+function isTestRunner(env) {
+  if (env.NODE_ENV === "test") {
+    return true;
+  }
+  const vitest = env.VITEST;
+  return vitest === "true" || vitest === "1";
+}
+function applyMockProvidersPolicy(env = process.env) {
+  const requested = env.BUILD_MOCK_PROVIDERS === "1";
+  if (!requested) {
+    return { allowed: false, reason: "not-requested" };
+  }
+  if (isTestRunner(env)) {
+    return { allowed: true, reason: "test-runner" };
+  }
+  if (env.BUILD_ALLOW_MOCK_PROVIDERS === "1") {
+    return { allowed: true, reason: "explicit-allow" };
+  }
+  const scrubbedValue = env.BUILD_MOCK_PROVIDERS;
+  delete env.BUILD_MOCK_PROVIDERS;
+  return { allowed: false, reason: "scrubbed", scrubbedValue };
+}
+
+// src/cli/build-freshness-policy.ts
+function isHelpRequested(args2) {
+  if (!args2) return false;
+  for (let index = 1; index < args2.length; index += 1) {
+    const arg = args2[index];
+    if (arg === "--") return false;
+    if (arg !== "--help" && arg !== "-h") continue;
+    const predecessor = args2[index - 1];
+    if (predecessor !== void 0 && predecessor.startsWith("-") && !predecessor.includes("=")) {
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+function shouldEnsureFreshBuildBeforeStartup({
+  command: command2,
+  args: args2
+}) {
+  if (command2 === void 0) {
+    return false;
+  }
+  if (isHelpRequested(args2)) {
+    return false;
+  }
+  return true;
+}
+
+// src/cli/utils/home-dot-env.ts
+import fs from "fs";
+import os from "os";
+import path3 from "path";
+import { parseEnv } from "util";
+var CREDENTIAL_SUFFIX = /_(?:KEY|TOKEN|SECRET|PASSWORD|CREDENTIALS?)$/;
+var AUTHORITY_SEGMENTS = /* @__PURE__ */ new Set(["TRUST", "BYPASS", "SKIP", "ALLOW"]);
+var AUTHORITY_KEYS = /* @__PURE__ */ new Set(["BUILD_PROJECT_ROOT", "BUILD_REPO"]);
+function isCredentialLikeKey(key) {
+  return CREDENTIAL_SUFFIX.test(key);
+}
+function isAuthorityKey(key) {
+  return AUTHORITY_KEYS.has(key) || PARENT_ENV_DENYLIST.has(key) || isSandboxAuthorityEnvVar(key) || key.split("_").some((segment) => AUTHORITY_SEGMENTS.has(segment));
+}
+function loadHomeDotEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const overrides = {};
+  let raw;
+  try {
+    raw = fs.readFileSync(path3.join(options.homeDir ?? os.homedir(), ".build", ".env"), "utf8");
+  } catch {
+    return overrides;
+  }
+  for (const [key, value] of Object.entries(parseEnv(raw))) {
+    if (value === void 0) continue;
+    if (key === "BUILD_RESEARCH_NATIVE_PROVIDERS") continue;
+    if (env[key] !== void 0) continue;
+    overrides[key] = value;
+  }
+  for (const [key, value] of Object.entries(overrides)) {
+    if (key.startsWith("BUILD_") && !isCredentialLikeKey(key) && !isAuthorityKey(key)) {
+      env[key] = value;
+    }
+  }
+  return overrides;
+}
+
+// src/cli/utils/repo-root-override-diagnostic.ts
+function formatRepoRootOverrideDiagnostic() {
+  if (!isVerboseOutputRequested() || isQuietOutputRequested()) return void 0;
+  const override = describeRepoRootOverride();
+  if (!override) return void 0;
+  return `Info: project root override ${override.variable}=${override.resolvedRoot}`;
+}
+
+// src/cli/entry.ts
+setProcessExitHandler({ exit: (code) => process.exit(code) });
+function safeErrorMessage(error) {
+  return sanitizeValue(error);
+}
+function safeErrorSuffix(error) {
+  const message = safeErrorMessage(error);
+  return message ? `: ${message}` : "";
+}
+var _entryFile = fileURLToPath(import.meta.url);
+var BUILD_VERSION = readBuildPackageVersion(_entryFile) ?? "0.0.0";
+var bareTaskRoute = routeBareTask(process.argv.slice(2));
+if (bareTaskRoute.kind === "refuse") {
+  process.stderr.write(`${bareTaskRoute.lines.join("\n")}
+`);
+  process.exit(1);
+}
+if (bareTaskRoute.kind === "task") {
+  process.argv = [process.argv[0] ?? "node", process.argv[1] ?? "build", ...bareTaskRoute.args];
+}
+var args = process.argv.slice(2);
+var route = resolveCliCommand(args);
+var command = route.command;
+var commandArgs = route.commandArgs;
+var routedArgv = buildRoutedArgv(process.argv, route);
+var outputPolicyEnvOverrides = outputPolicyToEnv(resolveOutputPolicyFromArgs(args));
+var mockPolicy = applyMockProvidersPolicy();
+if (mockPolicy.reason === "scrubbed") {
+  process.stderr.write(
+    `Warning: ignoring BUILD_MOCK_PROVIDERS=${mockPolicy.scrubbedValue} (set BUILD_ALLOW_MOCK_PROVIDERS=1 to opt in to synthetic provider responses).
+`
+  );
+}
+if (command === "cleanup") {
+  process.env.BUILD_DISABLE_AUTOMATIC_WORKTREE_CLEANUP ??= "1";
+}
+for (const [key, value] of Object.entries(outputPolicyEnvOverrides)) {
+  process.env[key] = value;
+}
+if (outputPolicyEnvOverrides.NO_COLOR) {
+  chalk.level = 0;
+}
+if (command === "--version" || command === "-V") {
+  console.log(BUILD_VERSION);
+  process.exit(0);
+}
+function printLightHelp() {
+  process.stdout.write(renderOrdinaryHelp(BUILD_VERSION));
+}
+if (command === "--help" || command === "-h" || command === "help" && args.length === 1) {
+  printLightHelp();
+  process.exit(0);
+}
+var diagnosticInvocation = isDiagnosticInvocation({ command, args });
+var isNextInvocation = matchPlanCommand(command, commandArgs, "next");
+var isTaskListInvocation = command === "task" && commandArgs[1] === "list" || matchPlanNestedCommand(command, commandArgs, "task", "list");
+var requiresNativeTelemetry = !isNextInvocation && !isTaskListInvocation;
+if (diagnosticInvocation) {
+  prepareDiagnosticRuntime();
+} else {
+  try {
+    assertBuildRuntimeReady({
+      command: command === TASK_EXEC_COMMAND ? void 0 : command,
+      requiresNativeTelemetry
+    });
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  }
+}
+var repoRoot = process.cwd();
+try {
+  repoRoot = resolveCliRepoRoot(process.cwd());
+} catch {
+}
+var repoRootOverrideDiagnostic = formatRepoRootOverrideDiagnostic();
+if (repoRootOverrideDiagnostic) {
+  process.stderr.write(`${repoRootOverrideDiagnostic}
+`);
+}
+triggerOpportunisticLocalCiReconcile({
+  repoRoot,
+  entryPath: _entryFile,
+  command
+});
+var homeDotEnvOverrides = loadHomeDotEnv();
+var entryBuildDir;
+try {
+  entryBuildDir = resolveStartupBuildDir({ args, repoRoot });
+} catch (error) {
+  process.stderr.write(`Error: ${safeErrorMessage(error)}
+`);
+  process.exit(1);
+}
+var entryRunId = readEnv(BUILD_RUN_ID).value?.trim() || randomUUID();
+var entryProjectId = readEnv(BUILD_PROJECT_ID).value?.trim() || getStableRepoIdentity(repoRoot);
+var entryEnvOverrides = {
+  ...homeDotEnvOverrides,
+  ...outputPolicyEnvOverrides,
+  BUILD_RUN_ID: entryRunId,
+  BUILD_PROJECT_ID: entryProjectId
+};
+if (!readEnv(BUILD_TELEMETRY_DIR).value) {
+  entryEnvOverrides.BUILD_TELEMETRY_DIR = entryBuildDir;
+}
+setExecutionContext(
+  createExecutionContext({
+    repoRoot,
+    buildDir: entryBuildDir,
+    taskId: "cli-entry",
+    envOverrides: entryEnvOverrides
+  })
+);
+if (process.env.BUILD_STRICT_ENV === "1") {
+  validateEnvironmentVars();
+}
+function isMissingDistChunkError(error) {
+  if (!(error instanceof Error)) return false;
+  const code = error.code;
+  return code === "ERR_MODULE_NOT_FOUND" || error.message.includes("Cannot find module") || error.message.includes("ERR_MODULE_NOT_FOUND");
+}
+async function reexecEntryAfterBuildRace() {
+  const entryPath = process.argv[1] ? path4.resolve(process.argv[1]) : _entryFile;
+  const child = spawn2(process.execPath, [entryPath, ...process.argv.slice(2)], {
+    cwd: repoRoot,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      BUILD_CLI_REEXEC_AFTER_BUILD: "1"
+    }
+  });
+  const exitCode = await new Promise((resolve) => {
+    child.once("exit", (code, signal) => {
+      if (typeof code === "number") {
+        resolve(code);
+        return;
+      }
+      if (signal === "SIGINT") resolve(130);
+      else if (signal === "SIGTERM") resolve(143);
+      else if (signal === "SIGHUP") resolve(129);
+      else resolve(signal ? 1 : 0);
+    });
+    child.once("error", () => resolve(1));
+  });
+  process.exit(exitCode);
+}
+async function ensureHeavyCommandFreshBuild() {
+  if (readEnv(BUILD_CLI_REEXEC_AFTER_BUILD).value) return;
+  const releaseBuildLock = await acquireCliBuildLock(repoRoot);
+  try {
+    let buildHelpers;
+    try {
+      buildHelpers = await import("./flywheel-preflight-III2C7TH.js");
+    } catch (error) {
+      if (isMissingDistChunkError(error)) {
+        await releaseBuildLock();
+        await reexecEntryAfterBuildRace();
+      }
+      throw error;
+    }
+    const { describeInstalledDependencyDrift, ensureFreshBuild, reexecCurrentCliCommand } = buildHelpers;
+    const dependencyDriftWarning = await describeInstalledDependencyDrift();
+    if (dependencyDriftWarning) console.error(dependencyDriftWarning);
+    const buildResult = await ensureFreshBuild({
+      quiet: !(isVerboseOutputRequested() || isDebugOutputRequested())
+    });
+    if (buildResult.rebuilt) {
+      await releaseBuildLock();
+      await reexecCurrentCliCommand(repoRoot);
+    }
+  } finally {
+    await releaseBuildLock();
+  }
+}
+async function ensureStartupFreshBuildOrExit() {
+  try {
+    await ensureHeavyCommandFreshBuild();
+  } catch (error) {
+    console.error("Error: Failed to prepare fresh CLI build:", safeErrorMessage(error));
+    process.exit(1);
+  }
+}
+function isReadOnlyConfigCommand(cliArgs) {
+  return cliArgs[1] !== "resolved" && (isReadOnlyConfigInvocation(cliArgs) || isProjectlessConfigWriteInvocation(cliArgs));
+}
+function isReadOnlyCostCommand(cliArgs) {
+  const subcommand = cliArgs[1];
+  if (!subcommand) {
+    return true;
+  }
+  const hasWriteFlag = (flag) => cliArgs.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+  return !hasWriteFlag("--output-file") && !hasWriteFlag("--recalculate");
+}
+function isReadOnlyMonitorCommand(cliArgs) {
+  return !cliArgs.includes("--follow") && !cliArgs.includes("--detailed");
+}
+function isReadOnlySprintCommand(cliArgs) {
+  return cliArgs[1] === "status" || cliArgs[1] === "list" || cliArgs[1] === "capacity";
+}
+function hasPositionalSubcommand(cliArgs, subcommand) {
+  for (let i = 1; i < cliArgs.length; i += 1) {
+    if (cliArgs[i] === subcommand) return true;
+  }
+  return false;
+}
+if (command === void 0) {
+  printLightHelp();
+} else if (isNextInvocation) {
+  import("./next-UKPFRXOO.js").then(async ({ createPlanNextCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError, reportExitCodeError } = await import("./exit-code-error-QIY5DOKF.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createPlanNextCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        reportExitCodeError(error);
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute next command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (isTaskListInvocation) {
+  import("./task-list-fast-7AT6LTTA.js").then(async ({ createTaskListFastCommand, createPlanTaskListFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError, reportExitCodeError } = await import("./exit-code-error-QIY5DOKF.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    const { attachCompatibilityNotice } = await import("./compatibility-notice-IHNXR2JR.js");
+    program.addCommand(
+      command === "task" ? attachCompatibilityNotice(createTaskListFastCommand(), "task") : createPlanTaskListFastCommand()
+    );
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        reportExitCodeError(error);
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute task list command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (matchPlanNestedCommand(command, commandArgs, "backlog", "list")) {
+  import("./plan-backlog-list-fast-SSTQL5XP.js").then(async ({ createPlanBacklogListFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError, reportExitCodeError } = await import("./exit-code-error-QIY5DOKF.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createPlanBacklogListFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        reportExitCodeError(error);
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute plan backlog list command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (matchPlanNestedCommand(command, commandArgs, "backlog", "show")) {
+  import("./plan-backlog-show-fast-PFRAQ3JB.js").then(async ({ createPlanBacklogShowFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError, reportExitCodeError } = await import("./exit-code-error-QIY5DOKF.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createPlanBacklogShowFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        reportExitCodeError(error);
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute plan backlog show command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (matchPlanNestedCommand(command, commandArgs, "task", "status")) {
+  import("./plan-task-status-fast-JU5PNLUU.js").then(async ({ createPlanTaskStatusFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError, reportExitCodeError } = await import("./exit-code-error-QIY5DOKF.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createPlanTaskStatusFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        reportExitCodeError(error);
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute plan task status command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (matchPlanNestedCommand(command, commandArgs, "sprint", "status")) {
+  import("./plan-sprint-status-fast-YFYH7WQF.js").then(async ({ createPlanSprintStatusFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError, reportExitCodeError } = await import("./exit-code-error-QIY5DOKF.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createPlanSprintStatusFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        reportExitCodeError(error);
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute plan sprint status command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (matchPlanNestedCommand(command, commandArgs, "sprint", "list")) {
+  import("./plan-sprint-list-fast-HD2KBZSY.js").then(async ({ createPlanSprintListFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError, reportExitCodeError } = await import("./exit-code-error-QIY5DOKF.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createPlanSprintListFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        reportExitCodeError(error);
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute plan sprint list command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (command === "ask") {
+  (async () => {
+    if (shouldEnsureFreshBuildBeforeStartup({ command, args: commandArgs })) {
+      await ensureStartupFreshBuildOrExit();
+    }
+    try {
+      const { createAskCommand } = await import("./ask-2OZ4JFQR.js");
+      const { Command } = await import("commander");
+      const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+      program.addCommand(createAskCommand());
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      console.error("Failed to execute ask command:", safeErrorMessage(error));
+      process.exitCode = 1;
+    }
+  })();
+} else if ((command === "config" || command === "settings") && isReadOnlyConfigCommand(commandArgs)) {
+  import("./config-4HHE4OIK.js").then(async ({ createConfigCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createConfigCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute config command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if ((command === "doctor" || command === "d") && !commandArgs.includes("--fix")) {
+  import("./doctor-BBSMCDWE.js").then(async ({ createDoctorCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createDoctorCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute doctor command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if ((command === "cost" || command === "$") && isReadOnlyCostCommand(commandArgs)) {
+  import("./cost-HSIV5U2Y.js").then(async ({ createCostCommand }) => {
+    const { Command } = await import("commander");
+    const {
+      disposeSharedTelemetry,
+      ensurePricingLoaded,
+      getSharedCostCalculator,
+      getSharedCostTracker,
+      getSharedModelInvocationsDb,
+      getSharedTelemetry
+    } = await import("./cli-utils-ER33ODC5.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    const { attachCompatibilityNotice } = await import("./compatibility-notice-IHNXR2JR.js");
+    program.addCommand(
+      attachCompatibilityNotice(
+        createCostCommand({
+          get telemetry() {
+            return getSharedTelemetry();
+          },
+          get costCalculator() {
+            return getSharedCostCalculator();
+          },
+          get costTracker() {
+            return getSharedCostTracker();
+          },
+          get modelInvocationsDb() {
+            return getSharedModelInvocationsDb();
+          },
+          ensurePricingLoaded
+        }),
+        "cost"
+      )
+    );
+    await program.parseAsync(routedArgv);
+    disposeSharedTelemetry();
+  }).catch((error) => {
+    console.error("Failed to execute cost command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (isObservationalProcessesHealthInvocation(args)) {
+  import("./processes-6FHVGT72.js").then(async ({ processesCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(processesCommand);
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    const exitError = error;
+    if (exitError.name === "ExitCodeError" && typeof exitError.exitCode === "number") {
+      process.exitCode = exitError.exitCode;
+      return;
+    }
+    console.error("Failed to execute processes health command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (isObservationalProcessesJsonInvocation(args)) {
+  import("./processes-json-fast-YWTMUWXB.js").then(async ({ createProcessesJsonFastCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createProcessesJsonFastCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    const exitError = error;
+    if (exitError.name === "ExitCodeError" && typeof exitError.exitCode === "number") {
+      process.exitCode = exitError.exitCode;
+      return;
+    }
+    console.error("Failed to execute processes json command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if ((command === "monitor" || command === "m") && isReadOnlyMonitorCommand(commandArgs)) {
+  import("./monitor-F4SIU5G2.js").then(async ({ createMonitorCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError, reportExitCodeError } = await import("./exit-code-error-QIY5DOKF.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createMonitorCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        reportExitCodeError(error);
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error("Failed to execute monitor command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "sprint" && isReadOnlySprintCommand(commandArgs)) {
+  import("./sprint-N7JFTEGL.js").then(async ({ registerSprintCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    registerSprintCommand(program, { hidden: true });
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute sprint command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "profile") {
+  import("./profile-HWTC56SG.js").then(async ({ createProfileCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError, reportExitCodeError } = await import("./exit-code-error-QIY5DOKF.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createProfileCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        reportExitCodeError(error);
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error("Failed to execute profile command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "sandbox" && !commandArgs.includes("--probe")) {
+  import("./sandbox-7LBZC5PE.js").then(async ({ createSandboxCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createSandboxCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute sandbox command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "package") {
+  import("./package-HJR4QJT4.js").then(async ({ createPackageCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    program.addCommand(createPackageCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    process.stderr.write(`Failed to execute package command: ${safeErrorMessage(error)}
+`);
+    process.exitCode = 1;
+  });
+} else if (command === "run" && commandArgs[1] === "competition" && hasPositionalSubcommand(commandArgs, "results")) {
+  import("./compete-results-XUM3PJHS.js").then(async ({ createCompeteResultsCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    const competition = new Command("competition").description("Run multi-provider competition");
+    competition.addCommand(createCompeteResultsCommand());
+    const run = new Command("run").description("Run orchestration workflows");
+    run.addCommand(competition);
+    program.addCommand(run);
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute compete results command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "run" && hasPositionalSubcommand(commandArgs, "fusion") && hasPositionalSubcommand(commandArgs, "results")) {
+  import("./compete-results-XUM3PJHS.js").then(async ({ createCompeteResultsCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    const fusion = new Command("fusion").description("Merge AI perspectives into a synthesis");
+    fusion.addCommand(createCompeteResultsCommand({ surface: "fusion" }));
+    const run = new Command("run").description("Run orchestration workflows");
+    run.addCommand(fusion);
+    program.addCommand(run);
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute fusion results command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "telemetry" && hasPositionalSubcommand(commandArgs, "reliability")) {
+  import("./telemetry-reliability-URJDTNPZ.js").then(async ({ createTelemetryReliabilityCommand }) => {
+    const { Command } = await import("commander");
+    const { setTelemetryLabContext } = await import("./cli-utils-ER33ODC5.js");
+    const { findLabRun, findLatestLabRun } = await import("./lab-utils-5QAMDJR5.js");
+    const { LabPathResolver } = await import("./lab-mode-YXQ2Y3NG.js");
+    const program = new Command().name("build").description("AI orchestration CLI").version(BUILD_VERSION);
+    const telemetry = new Command("telemetry").description(
+      "View telemetry and variant performance data"
+    );
+    telemetry.option("--lab [selector]", "Use lab telemetry data (value: latest)").option("--lab-id <labId>", "(OPTIONAL) Specify lab ID (requires --run-id)").option("--run-id <runId>", "(OPTIONAL) Specify run ID (requires --lab-id)").hook("preAction", (thisCommand) => {
+      const telemetryOpts = thisCommand.opts();
+      const failLabOptions = (message) => {
+        throw new Error(`${message}. Run \`build lab list\` to browse available lab runs.`);
+      };
+      if (telemetryOpts.lab && (telemetryOpts.labId || telemetryOpts.runId)) {
+        failLabOptions("--lab cannot be combined with --lab-id/--run-id");
+      }
+      if (telemetryOpts.labId && !telemetryOpts.runId) {
+        failLabOptions("--lab-id requires --run-id");
+      }
+      if (telemetryOpts.runId && !telemetryOpts.labId) {
+        failLabOptions("--run-id requires --lab-id");
+      }
+      let labSelection = null;
+      if (telemetryOpts.lab) {
+        const selector = typeof telemetryOpts.lab === "string" ? telemetryOpts.lab.trim().toLowerCase() : telemetryOpts.lab === true ? "latest" : null;
+        if (!selector || selector === "latest") {
+          labSelection = findLatestLabRun(path4.join(repoRoot, ".build-project"));
+          if (!labSelection) {
+            failLabOptions(
+              "No lab runs found. Start a lab run with `build run competition --lab` before querying telemetry"
+            );
+          }
+        } else {
+          failLabOptions("Unsupported --lab value. Supported value: latest");
+        }
+      } else if (telemetryOpts.labId && telemetryOpts.runId) {
+        labSelection = findLabRun(
+          telemetryOpts.labId,
+          telemetryOpts.runId,
+          path4.join(repoRoot, ".build-project")
+        );
+        if (!labSelection) {
+          failLabOptions(`Lab run not found: ${telemetryOpts.labId}/${telemetryOpts.runId}`);
+        }
+      }
+      if (labSelection) {
+        setTelemetryLabContext({ labId: labSelection.labId, runId: labSelection.runId });
+        LabPathResolver.getInstance().setContext({
+          labId: labSelection.labId,
+          runId: labSelection.runId,
+          baseline: "HEAD",
+          task: "telemetry-cli"
+        });
+      } else {
+        setTelemetryLabContext(null);
+        LabPathResolver.getInstance().clearContext();
+      }
+    }).hook("postAction", () => {
+      setTelemetryLabContext(null);
+      LabPathResolver.getInstance().clearContext();
+    });
+    telemetry.addCommand(createTelemetryReliabilityCommand());
+    program.addCommand(telemetry);
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute telemetry reliability command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "--help-full") {
+  globalThis.__BUILD_HELP_FULL__ = true;
+  process.argv = [process.argv[0] ?? "node", process.argv[1] ?? "dist/entry.js", "--help"];
+  await import("./index.js").catch((error) => {
+    console.error("Failed to load CLI:", safeErrorMessage(error));
+    process.exit(1);
+  });
+} else {
+  if (shouldEnsureFreshBuildBeforeStartup({ command, args: commandArgs })) {
+    await ensureStartupFreshBuildOrExit();
+  }
+  const isTsxPath = process.argv[1]?.includes("entry.ts");
+  const suppressWarning = args.includes("--json") || isJsonOutputRequested();
+  if (isTsxPath && !suppressWarning) {
+    try {
+      const srcStat = fs2.statSync(new URL(import.meta.url));
+      const distStat = fs2.statSync(new URL("../../dist/entry.js", import.meta.url));
+      if (srcStat.mtimeMs > distStat.mtimeMs) {
+        process.stderr.write(
+          "\x1B[2m(build binary may be stale \u2014 run npm run build to update)\x1B[0m\n"
+        );
+      }
+    } catch {
+    }
+  }
+  await import("./index.js").catch((error) => {
+    const isStaleBuild = error.message.includes("Dynamic require") || error.message.includes("Cannot find module") || error.code === "ERR_MODULE_NOT_FOUND";
+    if (isStaleBuild) {
+      console.error("\x1B[31mCLI build is missing or outdated\x1B[0m\n");
+      console.log("\x1B[33mHow to fix:\x1B[0m");
+      console.log("\x1B[90m  1) Rebuild the CLI:\x1B[0m");
+      console.log("\x1B[36m     npm run build\x1B[0m\n");
+      console.log("\x1B[90m  2) Or use the automated script:\x1B[0m");
+      console.log("\x1B[36m     ./scripts/compile-dist.sh\x1B[0m\n");
+      console.log("\x1B[90mCommon causes:\x1B[0m");
+      console.log("\x1B[90m  \u2022 git pull/checkout changed source files\x1B[0m");
+      console.log("\x1B[90m  \u2022 Local edits to src/ directory\x1B[0m");
+      console.log("\x1B[90m  \u2022 Deleted dist/ directory\x1B[0m\n");
+      console.log("\x1B[90mFor more help: docs/TROUBLESHOOTING.md#stale-cli-build\x1B[0m");
+      process.exit(1);
+    }
+    console.error("\x1B[31mFailed to load CLI:\x1B[0m", safeErrorMessage(error));
+    process.exit(1);
+  });
+}
+//# sourceMappingURL=entry.js.map