@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-EXA26FFC.js

@@ -0,0 +1,459 @@
+import {
+  HIDDEN_TASK_OPTION_FLAGS,
+  TASK_OPTION_FLAGS
+} from "./chunk-EAEVKNJA.js";
+import {
+  PUBLIC_ROOT_SUMMARIES,
+  TIER_LABELS,
+  getCommandTier,
+  listPublicRootsByDomain,
+  listRootsByTier
+} from "./chunk-NRFRY3GE.js";
+import {
+  findNearestBuildDir
+} from "./chunk-PSTKWHHN.js";
+import {
+  QUICK_START_GUIDE_URL
+} from "./chunk-3JKNRYEE.js";
+import {
+  getProjectDataDir
+} from "./chunk-56WPYDJH.js";
+
+// src/cli/utils/command-surface-help.ts
+function padCommand(name, width) {
+  return name.length >= width ? name : `${name}${" ".repeat(width - name.length)}`;
+}
+function renderRunTaskLines() {
+  const lines = [
+    "Run a task:",
+    '  build "<task>" [options]   Pursue a task to a shippable result (not a project compiler)',
+    "  build - [options]          Read the task from standard input",
+    '  build -- "<task>"          Run a command name or text starting with "-" as a task',
+    "",
+    "Task options:"
+  ];
+  let line = "";
+  for (const flags of TASK_OPTION_FLAGS) {
+    if (HIDDEN_TASK_OPTION_FLAGS.has(flags)) continue;
+    const next = line ? `${line}  ${flags}` : `  ${flags}`;
+    if (line && next.length > 80) {
+      lines.push(line);
+      line = `  ${flags}`;
+    } else {
+      line = next;
+    }
+  }
+  lines.push(line);
+  lines.push("");
+  return lines;
+}
+function renderOrdinaryHelp(version) {
+  const groups = listPublicRootsByDomain();
+  const lines = [
+    "Build - AI orchestration CLI for intelligent software development",
+    "",
+    "Usage: build [command] [options]",
+    "",
+    ...renderRunTaskLines(),
+    "Public commands:"
+  ];
+  for (const group of groups) {
+    lines.push("");
+    lines.push(`${group.domain}:`);
+    for (const root of group.roots) {
+      lines.push(`  ${padCommand(root, 12)} ${PUBLIC_ROOT_SUMMARIES[root]}`);
+    }
+  }
+  lines.push("");
+  lines.push("First-run journey:");
+  lines.push("  build provider setup --first-run");
+  lines.push("  cd /path/to/target-git-repo");
+  lines.push("  build init");
+  lines.push("  build doctor");
+  lines.push(`  Guide: ${QUICK_START_GUIDE_URL}`);
+  lines.push("");
+  lines.push("Examples:");
+  lines.push("  build plan next");
+  lines.push('  build plan backlog add "Add JWT auth to the API"');
+  lines.push("  build run task --backlog-item <id>");
+  lines.push("  build run competition --backlog-item <id>");
+  lines.push('  build "Ship a health endpoint"');
+  lines.push("");
+  lines.push("Run 'build <command> --help' for command-specific help.");
+  lines.push("Run 'build --help-full' for complete command reference (loads full CLI).");
+  lines.push("");
+  lines.push(`Version: ${version}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function describeCommand(program, name) {
+  const cmd = program.commands.find((c) => c.name() === name);
+  return (cmd?.description() || "").split("\n")[0]?.trim() ?? "";
+}
+function renderFullTieredHelp(program, version) {
+  const lines = [
+    "Build - AI orchestration CLI for intelligent software development",
+    "",
+    "Usage: build [command] [options]",
+    "",
+    "Complete command reference (Public / Advanced / Internal).",
+    "Hidden compatibility aliases remain callable but are omitted here.",
+    "",
+    ...renderRunTaskLines()
+  ];
+  const sections = [
+    { tier: "default", heading: `${TIER_LABELS.default} commands` },
+    { tier: "operator", heading: `${TIER_LABELS.operator} commands` },
+    { tier: "power", heading: `${TIER_LABELS.power} commands` }
+  ];
+  for (const section of sections) {
+    const roots = listRootsByTier(section.tier);
+    if (roots.length === 0) continue;
+    lines.push(`${section.heading}:`);
+    if (section.tier === "default") {
+      for (const group of listPublicRootsByDomain()) {
+        lines.push(`  ${group.domain}`);
+        for (const root of group.roots) {
+          lines.push(`    ${padCommand(root, 12)} ${PUBLIC_ROOT_SUMMARIES[root]}`);
+        }
+      }
+    } else {
+      for (const root of roots) {
+        lines.push(`  ${padCommand(root, 18)} ${describeCommand(program, root)}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("Global options:");
+  lines.push("  -q, --quiet          Suppress non-essential CLI diagnostics");
+  lines.push("  --no-color           Disable ANSI color output");
+  lines.push("  --no-auto-init       Skip automatic initialization check");
+  lines.push("  -h, --help           Display help");
+  lines.push("  -V, --version        Display version");
+  lines.push("");
+  lines.push("Run 'build <command> --help' for command-specific help.");
+  lines.push(`Version: ${version}`);
+  lines.push("");
+  for (const name of program.commands.map((c) => c.name())) {
+    if (name === "help") continue;
+    const hidden = program.commands.find((c) => c.name() === name)?._hidden;
+    if (hidden) continue;
+    if (getCommandTier(name) === void 0) {
+      lines.push(`Warning: unclassified visible command '${name}'`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/utils/global-command-routing.ts
+var GLOBAL_FLAGS_WITHOUT_VALUES = /* @__PURE__ */ new Set([
+  "-q",
+  "--quiet",
+  "--no-color",
+  "-v",
+  "--verbose",
+  "--debug"
+]);
+var GLOBAL_FLAGS_WITH_VALUES = /* @__PURE__ */ new Set([]);
+var FORWARDED_GLOBAL_FLAGS_WITHOUT_VALUES = /* @__PURE__ */ new Set(["-j", "--json"]);
+var FORWARDED_GLOBAL_FLAGS_WITH_VALUES = /* @__PURE__ */ new Set(["--output"]);
+var OPTIONAL_BOOLEAN_VALUE_FLAGS = /* @__PURE__ */ new Set(["--color"]);
+var BOOLEAN_FLAG_VALUES = /* @__PURE__ */ new Set(["true", "false"]);
+var CLEANUP_DRY_RUN_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "branches",
+  "external-temp",
+  "provider-temp",
+  "prune",
+  "prune-removed",
+  "remote",
+  "stale",
+  "state",
+  "variants",
+  "worktrees"
+]);
+var CLEANUP_READ_ONLY_SUBCOMMANDS = /* @__PURE__ */ new Set(["doctor", "preview"]);
+function isInlineValueFlag(arg, flags) {
+  return Array.from(flags).some((flag) => arg.startsWith(`${flag}=`));
+}
+function resolveCliCommand(args) {
+  const forwardedGlobalArgs = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--") {
+      return {
+        command: void 0,
+        commandIndex: -1,
+        commandArgs: [],
+        forwardedGlobalArgs
+      };
+    }
+    if (GLOBAL_FLAGS_WITHOUT_VALUES.has(arg)) {
+      continue;
+    }
+    if (OPTIONAL_BOOLEAN_VALUE_FLAGS.has(arg)) {
+      const next = args[i + 1];
+      if (next !== void 0 && BOOLEAN_FLAG_VALUES.has(next.toLowerCase())) {
+        i += 1;
+      }
+      continue;
+    }
+    if (FORWARDED_GLOBAL_FLAGS_WITHOUT_VALUES.has(arg)) {
+      forwardedGlobalArgs.push(arg);
+      continue;
+    }
+    if (GLOBAL_FLAGS_WITH_VALUES.has(arg)) {
+      i += 1;
+      continue;
+    }
+    if (FORWARDED_GLOBAL_FLAGS_WITH_VALUES.has(arg)) {
+      const next = args[i + 1];
+      if (next !== void 0) {
+        forwardedGlobalArgs.push(arg, next);
+        i += 1;
+        continue;
+      }
+      return {
+        command: arg,
+        commandIndex: i,
+        commandArgs: args.slice(i),
+        forwardedGlobalArgs
+      };
+    }
+    if (isInlineValueFlag(arg, GLOBAL_FLAGS_WITH_VALUES)) {
+      continue;
+    }
+    if (isInlineValueFlag(arg, OPTIONAL_BOOLEAN_VALUE_FLAGS)) {
+      continue;
+    }
+    if (isInlineValueFlag(arg, FORWARDED_GLOBAL_FLAGS_WITH_VALUES)) {
+      forwardedGlobalArgs.push(arg);
+      continue;
+    }
+    return {
+      command: arg,
+      commandIndex: i,
+      commandArgs: args.slice(i),
+      forwardedGlobalArgs
+    };
+  }
+  return {
+    command: void 0,
+    commandIndex: -1,
+    commandArgs: [],
+    forwardedGlobalArgs
+  };
+}
+function buildRoutedArgv(argv, route) {
+  if (route.commandIndex < 0) {
+    return [...argv];
+  }
+  return [
+    argv[0] ?? "node",
+    argv[1] ?? "build",
+    ...route.commandArgs,
+    ...route.forwardedGlobalArgs
+  ];
+}
+function isHelpOrVersionArg(arg) {
+  return arg === "--help" || arg === "-h" || arg === "--help-advanced" || arg.startsWith("--help-") || arg === "--version" || arg === "-V";
+}
+function isCleanupPreviewInvocation(args) {
+  const route = resolveCliCommand(args);
+  if (route.command !== "cleanup") {
+    return false;
+  }
+  const subcommand = route.commandArgs[1] && !route.commandArgs[1].startsWith("-") ? route.commandArgs[1] : void 0;
+  if (!subcommand) {
+    return false;
+  }
+  if (CLEANUP_READ_ONLY_SUBCOMMANDS.has(subcommand)) {
+    return true;
+  }
+  return CLEANUP_DRY_RUN_SUBCOMMANDS.has(subcommand) && !route.commandArgs.includes("--execute");
+}
+var READ_ONLY_PLAN_SUBCOMMANDS = /* @__PURE__ */ new Set(["inspect", "status", "next"]);
+function planNestedPositionals(commandArgs) {
+  const tokens = [];
+  for (let i = 1; i < commandArgs.length; i += 1) {
+    const arg = commandArgs[i];
+    if (!arg || arg === "--") {
+      break;
+    }
+    if (arg.startsWith("-")) {
+      continue;
+    }
+    tokens.push(arg);
+  }
+  return tokens;
+}
+function matchPlanCommand(command, commandArgs, subcommand) {
+  if (command !== "plan" && command !== "pl") {
+    return false;
+  }
+  return commandArgs[1] === subcommand;
+}
+function matchPlanNestedCommand(command, commandArgs, noun, verb) {
+  if (command !== "plan" && command !== "pl") {
+    return false;
+  }
+  const [nestedNoun, nestedVerb] = planNestedPositionals(commandArgs);
+  return nestedNoun === noun && nestedVerb === verb;
+}
+function isReadOnlyPlanInvocation(args) {
+  const route = resolveCliCommand(args);
+  if (route.command !== "plan" && route.command !== "pl") {
+    return false;
+  }
+  const [subcommand, nestedVerb] = planNestedPositionals(route.commandArgs);
+  if (subcommand !== void 0 && READ_ONLY_PLAN_SUBCOMMANDS.has(subcommand)) {
+    return true;
+  }
+  return subcommand === "task" && (nestedVerb === "list" || nestedVerb === "status") || subcommand === "sprint" && (nestedVerb === "status" || nestedVerb === "list") || subcommand === "backlog" && (nestedVerb === "list" || nestedVerb === "show");
+}
+var PROCESSES_VALUE_FLAGS = /* @__PURE__ */ new Set(["--kill", "--category", "--type"]);
+function processesPositionalAction(commandArgs) {
+  for (let i = 1; i < commandArgs.length; i += 1) {
+    const arg = commandArgs[i];
+    if (!arg || arg === "--") {
+      break;
+    }
+    if (arg.startsWith("--") && arg.includes("=")) {
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      if (PROCESSES_VALUE_FLAGS.has(arg)) {
+        i += 1;
+      }
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+function hasProcessesMutatingFlag(commandArgs) {
+  const action = processesPositionalAction(commandArgs);
+  if (action === "cleanup" || action === "kill") {
+    return true;
+  }
+  return commandArgs.some(
+    (arg) => arg === "--cleanup" || arg === "-c" || arg === "--kill" || arg.startsWith("--kill=")
+  );
+}
+function processesInvocationArgs(args) {
+  const route = resolveCliCommand(args);
+  if (route.command !== "processes") {
+    return null;
+  }
+  return [...route.commandArgs, ...route.forwardedGlobalArgs];
+}
+function isObservationalProcessesHealthInvocation(args) {
+  const commandArgs = processesInvocationArgs(args);
+  if (!commandArgs || !commandArgs.includes("--health")) {
+    return false;
+  }
+  return !hasProcessesMutatingFlag(commandArgs);
+}
+function isObservationalProcessesJsonInvocation(args) {
+  const commandArgs = processesInvocationArgs(args);
+  if (!commandArgs) {
+    return false;
+  }
+  const hasJson = commandArgs.includes("--json") || commandArgs.includes("-j");
+  if (!hasJson) {
+    return false;
+  }
+  return !hasProcessesMutatingFlag(commandArgs);
+}
+function isReadOnlyConfigInvocation(args) {
+  const route = resolveCliCommand(args);
+  if (route.command !== "config" && route.command !== "settings") return false;
+  const subcommand = route.commandArgs[1];
+  if (!subcommand || ["show", "resolved", "get", "list", "precedence", "explain", "audit"].includes(subcommand))
+    return true;
+  if (subcommand === "user") return route.commandArgs[2] === "get";
+  if (subcommand === "aliases") return route.commandArgs[2] === "list";
+  if (subcommand === "instructions") return route.commandArgs[2] === "path";
+  return ["validate", "diagnose"].includes(subcommand) && !route.commandArgs.includes("--fix");
+}
+function isProjectlessConfigWriteInvocation(args) {
+  const route = resolveCliCommand(args);
+  return (route.command === "config" || route.command === "settings") && (["set", "export"].includes(route.commandArgs[1] ?? "") || route.commandArgs[1] === "user" && route.commandArgs[2] === "set");
+}
+function isDocumentedReadOnlyInvocation(args) {
+  if (isReadOnlyPlanInvocation(args)) {
+    return true;
+  }
+  if (isObservationalProcessesJsonInvocation(args)) {
+    return true;
+  }
+  const route = resolveCliCommand(args);
+  return route.command === "task" && route.commandArgs[1] === "list" || isReadOnlyConfigInvocation(args) || // `worktree list` only inspects worktrees. Flags may precede the subcommand
+  // (`worktree --no-color list`). `telemetry task` stays on the preflight path: skipping
+  // it would derive the telemetry project from the data dir when `.build-project` is missing.
+  route.command === "worktree" && planNestedPositionals(route.commandArgs)[0] === "list" || // The installer runs this from any folder; `--check` must leave that folder alone.
+  route.command === "config" && route.commandArgs[1] === "instructions" && route.commandArgs[2] === "import" && route.commandArgs.includes("--check") || // `upgrade --check` only compares the installed version with the registry.
+  route.command === "upgrade" && route.commandArgs.includes("--check");
+}
+function shouldOwnStartupCleanup(args, env = process.env) {
+  const routeArgs = args.filter((arg) => arg !== "--no-auto-init");
+  const routeEnv = { ...env };
+  delete routeEnv.BUILD_NO_AUTO_INIT;
+  return !isObservationalInvocation(routeArgs, routeEnv);
+}
+function isObservationalInvocation(args, env = process.env) {
+  if (env.BUILD_NO_AUTO_INIT === "1" || args.includes("--no-auto-init")) {
+    return true;
+  }
+  if (args.some(isHelpOrVersionArg)) {
+    return true;
+  }
+  const route = resolveCliCommand(args);
+  const command = route.command;
+  if (!command) {
+    return true;
+  }
+  if (isCleanupPreviewInvocation(args)) {
+    return true;
+  }
+  if (command === "context") {
+    return true;
+  }
+  if (command === "ci" && route.commandArgs[1] === "status") {
+    return true;
+  }
+  if (isDocumentedReadOnlyInvocation(args)) {
+    return true;
+  }
+  return (command === "doctor" || command === "d") && !route.commandArgs.includes("--fix");
+}
+
+// src/cli/utils/startup-build-dir.ts
+import path from "path";
+function resolveStartupBuildDir(options) {
+  const repoRoot = path.resolve(options.repoRoot);
+  const repoLocalBuildDir = path.join(repoRoot, ".build-project");
+  if (!isObservationalInvocation(options.args, options.env)) {
+    return repoLocalBuildDir;
+  }
+  return findNearestBuildDir(repoRoot) ?? getProjectDataDir(repoRoot);
+}
+
+export {
+  renderOrdinaryHelp,
+  renderFullTieredHelp,
+  resolveCliCommand,
+  buildRoutedArgv,
+  matchPlanCommand,
+  matchPlanNestedCommand,
+  isObservationalProcessesHealthInvocation,
+  isObservationalProcessesJsonInvocation,
+  isReadOnlyConfigInvocation,
+  isProjectlessConfigWriteInvocation,
+  shouldOwnStartupCleanup,
+  isObservationalInvocation,
+  resolveStartupBuildDir
+};
+//# sourceMappingURL=chunk-EXA26FFC.js.map

package/dist/chunk-EXSPAA35.js

@@ -0,0 +1,244 @@
+import {
+  getAskBudgetCancellation,
+  getAskMutationSentinel,
+  readAskStdinWithDeadline,
+  resolveAskStdinDeadline,
+  runAsk
+} from "./chunk-YPDCLXNZ.js";
+import {
+  buildJsonErrorEnvelope
+} from "./chunk-5YDE3Q62.js";
+import {
+  expandPreset,
+  loadAskPresets,
+  loadAskPresetsWithSources,
+  lookupPreset
+} from "./chunk-FUUVZZUB.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  ValidationError
+} from "./chunk-RRC5BL7B.js";
+
+// src/cli/commands/ask.ts
+import { Command } from "commander";
+function splitTargetAndQuestion(args, to, presets) {
+  const first = args[0]?.trim();
+  const providerIds = new Set(ProviderRegistry.getAllProviderIds().map((id) => id.toLowerCase()));
+  const positionalProvider = first && providerIds.has(first.toLowerCase()) ? first : void 0;
+  if (to) {
+    return {
+      target: to,
+      question: args.join(" ").trim() || void 0
+    };
+  }
+  if (positionalProvider) {
+    return {
+      target: positionalProvider,
+      question: args.slice(1).join(" ").trim() || void 0
+    };
+  }
+  const positionalPreset = lookupPreset(first, presets);
+  if (positionalPreset) {
+    return {
+      positionalPreset: positionalPreset.name,
+      question: args.slice(1).join(" ").trim() || void 0
+    };
+  }
+  return { question: args.join(" ").trim() || void 0 };
+}
+function parseTimeoutMs(raw) {
+  if (!raw) return void 0;
+  if (!/^[1-9]\d*$/.test(raw.trim())) {
+    throw new ValidationError("Error: --timeout must be a positive integer number of seconds.");
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new ValidationError("Error: --timeout must be a positive integer number of seconds.");
+  }
+  return parsed * 1e3;
+}
+async function readStdinIfPiped(cwd, readStdin) {
+  if (!readStdin || process.stdin.isTTY) return void 0;
+  return readAskStdinWithDeadline(process.stdin, resolveAskStdinDeadline(cwd));
+}
+function formatSentinelWarning(providerLabel, sentinel) {
+  if (sentinel?.status !== "mutated") return void 0;
+  const detail = [];
+  if (sentinel.changedPaths.length > 0) {
+    detail.push(`changed paths: ${sentinel.changedPaths.join(", ")}`);
+  }
+  if (sentinel.headMoved) {
+    detail.push("HEAD moved");
+  }
+  const detailText = detail.length > 0 ? ` (${detail.join("; ")})` : "";
+  return `Warning: worktree changed during ask consult with "${providerLabel}"${detailText}. ask runs in your real working directory, so this cannot be attributed to the consult versus a concurrent process or session.
+`;
+}
+function createAskCommand() {
+  return new Command("ask").description("Ask an eligible provider for read-only peer consultation").argument("[args...]", "provider or preset and question, or question when --to is used").option("--to <provider>", "target provider").option("--model <model>", "provider-scoped model override").option("--effort <level>", "reasoning effort override").option("--preset <name>", "apply a named ask preset (ask.presets in build config)").option("--presets", "list defined presets with their source tier and exit").option("--cwd <dir>", "working directory for the consult", process.cwd()).option("--timeout <seconds>", "hard time budget in whole seconds (default: 900)").option("--no-stdin", "do not read piped stdin").option("--json", "print structured JSON output").action(async (args, options) => {
+    let providerLabel = options.to?.trim() || "the provider";
+    try {
+      const cwd = options.cwd ?? process.cwd();
+      if (options.presets) {
+        const resolved = loadAskPresetsWithSources(cwd);
+        if (options.json) {
+          process.stdout.write(
+            `${JSON.stringify(
+              {
+                presets: resolved.map((r) => ({
+                  name: r.name,
+                  source: r.source,
+                  ...r.preset
+                }))
+              },
+              null,
+              2
+            )}
+`
+          );
+          return;
+        }
+        if (resolved.length === 0) {
+          process.stdout.write("No ask presets defined.\n");
+          return;
+        }
+        for (const r of resolved) {
+          const fields = [
+            r.preset.to ? `to=${r.preset.to}` : void 0,
+            r.preset.model ? `model=${r.preset.model}` : void 0,
+            r.preset.effort ? `effort=${r.preset.effort}` : void 0
+          ].filter(Boolean).join(" ");
+          process.stdout.write(`${r.name}  (${r.source})  ${fields}
+`);
+        }
+        return;
+      }
+      const presets = loadAskPresets(cwd);
+      const split = splitTargetAndQuestion(args, options.to, presets);
+      const presetName = options.preset?.trim().toLowerCase() || split.positionalPreset;
+      let expansion;
+      if (options.preset && !presets[options.preset.trim().toLowerCase()]) {
+        const known = Object.keys(presets).sort();
+        throw new ValidationError(
+          known.length ? `Error: unknown preset "${options.preset}". Defined presets: ${known.join(", ")}.` : `Error: unknown preset "${options.preset}". No ask.presets are defined in build config.`
+        );
+      }
+      const selectedPreset = presetName ? presets[presetName] : void 0;
+      if (presetName && selectedPreset) {
+        expansion = expandPreset(presetName, selectedPreset, {
+          target: split.target ?? options.to,
+          model: options.model,
+          effort: options.effort
+        });
+        if (expansion.modelDropped) {
+          process.stderr.write(
+            `Info: preset "${presetName}" model ignored (provider overridden to "${expansion.target}").
+`
+          );
+        }
+      }
+      const target = expansion?.target ?? split.target ?? options.to;
+      providerLabel = target ?? providerLabel;
+      const stdin = await readStdinIfPiped(cwd, options.stdin !== false);
+      const selectedModel = expansion?.model ?? options.model;
+      if (target && ProviderRegistry.getEnabledProviders().some((provider) => provider.id === target)) {
+        const { prepareModelSelectionCatalog } = await import("./model-catalog-readiness-R5KJBP5M.js");
+        await prepareModelSelectionCatalog({
+          providerId: target,
+          projectRoot: cwd,
+          model: selectedModel
+        });
+      }
+      const { triggerOpportunisticModelRefresh } = await import("./opportunistic-TL4S26VX.js");
+      triggerOpportunisticModelRefresh({
+        projectRoot: cwd,
+        entryPath: process.argv[1] ?? "",
+        command: "ask",
+        args: process.argv.slice(2)
+      });
+      const result = await runAsk({
+        target,
+        question: split.question,
+        stdin,
+        cwd,
+        model: selectedModel,
+        effort: expansion?.effort ?? options.effort,
+        timeoutMs: parseTimeoutMs(options.timeout)
+      });
+      const sentinel = result.mutationSentinel;
+      if (!result.answer) {
+        throw Object.assign(
+          new Error(`Error: Provider "${result.provider}" returned no answer.`),
+          {
+            mutationSentinel: sentinel
+          }
+        );
+      }
+      if (options.json) {
+        process.stdout.write(
+          `${JSON.stringify(
+            {
+              provider: result.provider,
+              model: result.model,
+              ...expansion ? { preset: expansion.preset } : {},
+              answer: result.answer,
+              // Always emit the sentinel so JSON consumers can distinguish
+              // unchanged / unavailable / mutated (human output warns on
+              // mutated only).
+              mutationSentinel: sentinel
+            },
+            null,
+            2
+          )}
+`
+        );
+        return;
+      }
+      process.stdout.write(result.answer.endsWith("\n") ? result.answer : `${result.answer}
+`);
+      const warning = formatSentinelWarning(result.provider, sentinel);
+      if (warning) process.stderr.write(warning);
+    } catch (error) {
+      const sentinel = getAskMutationSentinel(error);
+      const cancellation = getAskBudgetCancellation(error);
+      if (options.json) {
+        process.stdout.write(
+          `${JSON.stringify(
+            {
+              ...buildJsonErrorEnvelope(error),
+              ...sentinel ? { mutationSentinel: sentinel } : {},
+              ...cancellation ? {
+                budget: {
+                  timeoutMs: cancellation.budget.timeoutMs,
+                  idleWarnMs: cancellation.budget.idleWarnMs,
+                  idleKillMs: cancellation.budget.idleKillMs,
+                  source: cancellation.budget.source,
+                  idleSource: cancellation.budget.idleSource
+                },
+                terminationReason: cancellation.terminationReason,
+                ...cancellation.providerExitCode !== void 0 ? { providerExitCode: cancellation.providerExitCode } : {}
+              } : {}
+            },
+            null,
+            2
+          )}
+`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+      const warning = formatSentinelWarning(providerLabel, sentinel);
+      if (warning) process.stderr.write(warning);
+      process.exitCode = 1;
+    }
+  });
+}
+
+export {
+  createAskCommand
+};
+//# sourceMappingURL=chunk-EXSPAA35.js.map