@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-YPDCLXNZ.js

@@ -0,0 +1,568 @@
+import {
+  runProvider
+} from "./chunk-VCGSWN5M.js";
+import {
+  resolveUserModelAlias
+} from "./chunk-QTOLTG4L.js";
+import {
+  getProcessRegistryStateDirectory
+} from "./chunk-QP5ST7RI.js";
+import {
+  readProviderTimeoutEnvMs
+} from "./chunk-URMSZXAD.js";
+import {
+  TIMEOUT_REMEDY_HINT_SENTENCE
+} from "./chunk-JBBB2Y47.js";
+import {
+  resolveIdleTimeoutPlan
+} from "./chunk-WJAL4JL3.js";
+import {
+  resolveAskConfig,
+  resolveProviderModel,
+  warnIfExplicitModelUnobserved
+} from "./chunk-C3DH3NCY.js";
+import {
+  logReasoningEffortResolution,
+  resolveProviderNativeReasoningEffort,
+  resolveReasoningEffort
+} from "./chunk-TGXXYDL4.js";
+import {
+  willReadOnlyWorkspaceBeEnforced
+} from "./chunk-B7YRSULE.js";
+import {
+  parsePorcelainEntriesZ
+} from "./chunk-EVE3OD2W.js";
+import {
+  getAuthLivenessCachePath
+} from "./chunk-PPZESPJT.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  ProviderRegistry,
+  disabledBySuffix
+} from "./chunk-QJ6OEH4K.js";
+import {
+  getIsolatedCodexHomePath
+} from "./chunk-BD3PGW6A.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  ValidationError
+} from "./chunk-RRC5BL7B.js";
+import {
+  classifyHostTermination
+} from "./chunk-M6UHOC4I.js";
+import {
+  BUILD_IDLE_KILL_CEILING_FRACTION,
+  BUILD_TIMEOUT_MS,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/ask/ask-budget.ts
+var ASK_DEFAULT_TIMEOUT_MS = 9e5;
+var ASK_DEFAULT_IDLE_WARN_MS = 3e5;
+var ASK_DEFAULT_IDLE_KILL_MS = 6e5;
+var ASK_DEFAULT_STDIN_DEADLINE_MS = 3e4;
+function positiveMsFromSeconds(seconds) {
+  return typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : void 0;
+}
+function resolveConfigTier(project, user) {
+  const fromProject = positiveMsFromSeconds(project);
+  if (fromProject !== void 0) return { ms: fromProject, source: "config:project" };
+  const fromUser = positiveMsFromSeconds(user);
+  if (fromUser !== void 0) return { ms: fromUser, source: "config:user" };
+  return void 0;
+}
+function providerTimeoutEnvName(provider) {
+  return `BUILD_TIMEOUT_${provider.toUpperCase()}_MS`;
+}
+function resolveHardBudget(provider, timeoutMsFlag, project, user) {
+  if (typeof timeoutMsFlag === "number" && Number.isFinite(timeoutMsFlag) && timeoutMsFlag > 0) {
+    return { ms: timeoutMsFlag, source: "flag" };
+  }
+  const fromConfig = resolveConfigTier(project?.timeoutSeconds, user?.timeoutSeconds);
+  if (fromConfig) return fromConfig;
+  const providerEnvMs = readProviderTimeoutEnvMs(provider);
+  if (providerEnvMs !== void 0) {
+    return { ms: providerEnvMs, source: `env:${providerTimeoutEnvName(provider)}` };
+  }
+  const globalEnvMs = readEnv(BUILD_TIMEOUT_MS).value;
+  if (globalEnvMs !== void 0 && globalEnvMs > 0) {
+    return { ms: globalEnvMs, source: `env:${BUILD_TIMEOUT_MS.name}` };
+  }
+  return { ms: ASK_DEFAULT_TIMEOUT_MS, source: "default" };
+}
+function cappedIdleSource(hardSource) {
+  return readEnv(BUILD_IDLE_KILL_CEILING_FRACTION).source === "env" ? `env:${BUILD_IDLE_KILL_CEILING_FRACTION.name}` : hardSource;
+}
+function resolveAskBudget(input) {
+  const ask = resolveAskConfig(input.cwd);
+  const project = ask?.projectBudget;
+  const user = ask?.userBudget;
+  const hard = resolveHardBudget(input.provider, input.timeoutMsFlag, project, user);
+  const warn = resolveConfigTier(project?.idleWarnSeconds, user?.idleWarnSeconds);
+  const kill = resolveConfigTier(project?.idleKillSeconds, user?.idleKillSeconds);
+  const requestedWarnMs = warn?.ms ?? ASK_DEFAULT_IDLE_WARN_MS;
+  const requestedKillMs = kill?.ms ?? ASK_DEFAULT_IDLE_KILL_MS;
+  const plan = resolveIdleTimeoutPlan(input.provider, [], hard.ms, {
+    idleWarnMs: requestedWarnMs,
+    idleKillMs: requestedKillMs
+  });
+  const idleKillMs = plan?.killMs ?? requestedKillMs;
+  return {
+    timeoutMs: hard.ms,
+    idleWarnMs: plan?.warnMs ?? requestedWarnMs,
+    idleKillMs,
+    source: hard.source,
+    idleSource: idleKillMs < requestedKillMs ? cappedIdleSource(hard.source) : kill?.source ?? "default"
+  };
+}
+function resolveAskStdinDeadline(cwd) {
+  const ask = resolveAskConfig(cwd);
+  const resolved = resolveConfigTier(
+    ask?.projectBudget?.stdinDeadlineSeconds,
+    ask?.userBudget?.stdinDeadlineSeconds
+  );
+  return resolved ?? { ms: ASK_DEFAULT_STDIN_DEADLINE_MS, source: "default" };
+}
+function toSeconds(ms) {
+  return Math.round(ms / 1e3);
+}
+function formatAskStdinDeadlineMessage(deadline) {
+  return `Error: ask stopped waiting for piped stdin after ${toSeconds(deadline.ms)}s (deadline source: ${deadline.source}). ask never proceeds with partial input. Pass --no-stdin when nothing is piped, or raise ask.stdinDeadlineSeconds.`;
+}
+function readAskStdinWithDeadline(stream, deadline) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const chunks = [];
+    const detach = () => {
+      clearTimeout(timer);
+      stream.off("data", onData);
+      stream.off("end", onEnd);
+      stream.off("error", onError);
+      stream.pause();
+    };
+    const onData = (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    };
+    const onEnd = () => {
+      detach();
+      const text = Buffer.concat(chunks).toString("utf8").trim();
+      resolvePromise(text || void 0);
+    };
+    const onError = (error) => {
+      detach();
+      rejectPromise(error);
+    };
+    const timer = setTimeout(() => {
+      detach();
+      rejectPromise(new ValidationError(formatAskStdinDeadlineMessage(deadline)));
+    }, deadline.ms);
+    stream.on("data", onData);
+    stream.on("end", onEnd);
+    stream.on("error", onError);
+    stream.resume();
+  });
+}
+function getAskBudgetCancellation(error) {
+  if (error && typeof error === "object" && "askBudgetCancellation" in error) {
+    return error.askBudgetCancellation;
+  }
+  return void 0;
+}
+function formatAskCancellationMessage(provider, cancellation, providerDetail) {
+  const idle = cancellation.terminationReason === "idle_timeout";
+  const configuredIdle = toSeconds(cancellation.budget.idleKillMs);
+  const firedIdle = idle ? /idle time(?:out|d out) after (\d+)s/.exec(providerDetail ?? "")?.[1] : void 0;
+  const idleLimit = firedIdle === void 0 ? `idle timer fired (ask configured ${configuredIdle}s; the attempt's effective value is unknown)` : Number(firedIdle) === configuredIdle ? `idle timer fired after ${configuredIdle}s of silence` : `idle timer fired after ${firedIdle}s of silence (ask configured ${configuredIdle}s; this attempt's effective limit was lower)`;
+  const limit = idle ? idleLimit : `hard budget ${toSeconds(cancellation.budget.timeoutMs)}s`;
+  const source = idle ? cancellation.budget.idleSource : cancellation.budget.source;
+  const remedy = idle ? "Raise ask.idleKillSeconds (in whole seconds) if this provider goes quiet for longer." : "Rerun with a longer --timeout (in whole seconds) if this provider needs more time.";
+  const head = `Error: ask consult with "${provider}" cancelled: ${limit} (source: ${source}). ${remedy}`;
+  return providerDetail ? `${head}
+Info: ${providerDetail}` : head;
+}
+function annotateAskBudgetCancellation(error, provider, budget) {
+  if (!error || typeof error !== "object") return error;
+  const reason = error.reason;
+  if (typeof reason !== "string") return error;
+  const terminationSource = error.terminationSource;
+  if (classifyHostTermination({
+    reason,
+    terminationSource: typeof terminationSource === "string" ? terminationSource : void 0
+  }) !== "timeout") {
+    return error;
+  }
+  const exitCode = error.exitCode;
+  const cancellation = {
+    terminationReason: reason === "idle_timeout" ? "idle_timeout" : "timeout",
+    budget,
+    ...typeof exitCode === "number" ? { providerExitCode: exitCode } : {}
+  };
+  error.askBudgetCancellation = cancellation;
+  const providerMessage = error.message;
+  const detail = typeof providerMessage === "string" ? providerMessage.replace(TIMEOUT_REMEDY_HINT_SENTENCE, "").trim() : void 0;
+  error.message = formatAskCancellationMessage(
+    provider,
+    cancellation,
+    detail || void 0
+  );
+  return error;
+}
+
+// src/core/ask/ask-service.ts
+import fs from "fs/promises";
+import path from "path";
+function withAttributionEnv(attribution) {
+  if (!attribution) return void 0;
+  return {
+    BUILD_RUN_ID: attribution.runId,
+    ...attribution.taskId ? { BUILD_ACTIVE_TASK_ID: attribution.taskId } : {},
+    ...attribution.role ? { BUILD_AGENT_ROLE: attribution.role } : {}
+  };
+}
+var PEER_CONSULT_ENVELOPE = [
+  "You are a peer engineer being consulted by another AI coding agent.",
+  "You have read-only access to this project and cannot make edits. Advise only.",
+  "Infer from the question and attached context what kind of feedback is most useful: architecture, plan, analysis, implementation, code review, or a mixture.",
+  "Lead with the most important issues. Be concrete and direct."
+].join("\n");
+function normalizeProviderId(provider) {
+  const trimmed = provider?.trim().toLowerCase();
+  return trimmed || void 0;
+}
+function isAskEligibleProvider(config) {
+  if (config.capabilities.supports_ask_consult === true) {
+    return true;
+  }
+  return willReadOnlyWorkspaceBeEnforced(config.name, config.id);
+}
+function listAskEligibleProviders() {
+  return ProviderRegistry.getEnabledProviders().filter((provider) => isAskEligibleProvider(provider)).map((provider) => provider.id).sort();
+}
+function resolveAskEligibility(providerId) {
+  const normalized = normalizeProviderId(providerId);
+  const eligible = listAskEligibleProviders();
+  if (!normalized) {
+    return {
+      eligible: false,
+      reason: "unknown",
+      message: "Error: ask requires a target provider. Use --to <provider> or positional <provider>."
+    };
+  }
+  let config;
+  try {
+    config = ProviderRegistry.getProviderConfig(normalized);
+  } catch {
+    const known = ProviderRegistry.getEnabledProviders().map((provider) => provider.id).sort().join(", ");
+    return {
+      eligible: false,
+      reason: "unknown",
+      message: `Error: Unknown provider "${normalized}". Available providers: ${known || "none"}.`
+    };
+  }
+  if (!ProviderRegistry.isProviderEnabled(normalized)) {
+    return {
+      eligible: false,
+      reason: "disabled",
+      message: `Error: Provider "${normalized}" is not enabled${disabledBySuffix(ProviderRegistry.getActiveRegistry(), normalized)}.`
+    };
+  }
+  if (!isAskEligibleProvider(config)) {
+    return {
+      eligible: false,
+      reason: "unsupported",
+      message: `Error: Provider "${normalized}" is not eligible for ask on this host: it has no native read-only posture and no enforced read-only confinement boundary is available here. Eligible providers: ${eligible.join(", ") || "none"}.`
+    };
+  }
+  if (isStructurallyUnsafeForAsk(config.capabilities)) {
+    return {
+      eligible: false,
+      reason: "unsafe",
+      message: `Error: Provider "${normalized}" is marked for ask consultation but does not have a safe read-only execution posture.`
+    };
+  }
+  return { eligible: true };
+}
+function isStructurallyUnsafeForAsk(_capabilities) {
+  return false;
+}
+function buildAskPrompt(input) {
+  const question = input.question?.trim();
+  const stdin = input.stdin?.trim();
+  if (!question && !stdin) {
+    throw new ValidationError("Error: ask requires a question or piped stdin.");
+  }
+  const parts = [PEER_CONSULT_ENVELOPE, ""];
+  if (question) {
+    parts.push("Question:", question);
+  }
+  if (stdin) {
+    parts.push(question ? "Context from stdin:" : "Question:", stdin);
+  }
+  return parts.join("\n");
+}
+function extractAskAnswer(result) {
+  return result.stdout?.trim() ?? "";
+}
+function assertAskTerminalResultComplete(provider, result) {
+  const diagnostics = result.providerDiagnostics;
+  if (diagnostics?.terminalResultPresent === false) {
+    throw new Error(
+      `Error: Provider "${provider}" returned an incomplete stream without a terminal result.`
+    );
+  }
+  const warnings = result.warnings ?? [];
+  const incompleteWarning = warnings.find(
+    (warning) => /missing a terminal result event/i.test(warning) || /output appears truncated/i.test(warning) || /output was truncated/i.test(warning)
+  );
+  if (incompleteWarning) {
+    throw new Error(
+      `Error: Provider "${provider}" returned an incomplete stream without a terminal result.`
+    );
+  }
+}
+var SENTINEL_STATUS_ARGS = ["status", "--porcelain=v1", "--untracked-files=all", "-z"];
+var SENTINEL_GIT_ENV = { GIT_OPTIONAL_LOCKS: "0" };
+function buildOwnedWritePaths(cwd) {
+  const processRegistryStateDir = getProcessRegistryStateDirectory();
+  return [
+    getAuthLivenessCachePath(),
+    getIsolatedCodexHomePath(cwd),
+    path.join(processRegistryStateDir, "processes.json"),
+    path.join(processRegistryStateDir, "processes.json.lock")
+  ];
+}
+async function resolvePhysicalPath(target) {
+  const absolute = path.resolve(target);
+  const missingSegments = [];
+  let current = absolute;
+  for (; ; ) {
+    const real = await fs.realpath(current).catch(() => void 0);
+    if (real) return path.join(real, ...missingSegments.reverse());
+    const parent = path.dirname(current);
+    if (parent === current) return absolute;
+    missingSegments.push(path.basename(current));
+    current = parent;
+  }
+}
+async function resolveRepoRelativePrefix(repoRoot, target) {
+  const lexicalSegments = [];
+  let current = path.resolve(target);
+  for (; ; ) {
+    const physical = await fs.realpath(current).catch(() => void 0);
+    if (physical === repoRoot) {
+      return lexicalSegments.length > 0 ? lexicalSegments.join("/") : void 0;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return void 0;
+    lexicalSegments.unshift(path.basename(current));
+    current = parent;
+  }
+}
+async function resolveBuildOwnedPathPrefixes(cwd) {
+  let repoRoot;
+  try {
+    const toplevel = await execGit(["rev-parse", "--show-toplevel"], {
+      cwd,
+      env: { ...SENTINEL_GIT_ENV }
+    });
+    const trimmed = toplevel.stdout.trim();
+    if (toplevel.exitCode !== 0 || !trimmed) return [];
+    repoRoot = await resolvePhysicalPath(trimmed);
+  } catch {
+    return [];
+  }
+  const prefixes = [];
+  for (const target of buildOwnedWritePaths(cwd)) {
+    const prefix = await resolveRepoRelativePrefix(repoRoot, target);
+    if (prefix) prefixes.push(prefix);
+  }
+  return prefixes;
+}
+function isBuildOwnedPath(porcelainPath, prefixes) {
+  const normalized = porcelainPath.replace(/\/+$/, "");
+  return prefixes.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix}/`));
+}
+async function captureWorktreeFingerprint(cwd, buildOwnedPrefixes) {
+  try {
+    const status = await execGit([...SENTINEL_STATUS_ARGS], { cwd, env: { ...SENTINEL_GIT_ENV } });
+    if (status.exitCode !== 0) return void 0;
+    const head = await execGit(["rev-parse", "HEAD"], { cwd, env: { ...SENTINEL_GIT_ENV } });
+    return {
+      statusByPath: porcelainStatusByPath(
+        parsePorcelainEntriesZ(status.stdout).filter(
+          (entry) => !isBuildOwnedPath(entry.path, buildOwnedPrefixes)
+        )
+      ),
+      // An unborn HEAD (fresh repo, no commits) fails rev-parse; record '' but
+      // keep the fingerprint available — status still describes the worktree.
+      head: head.exitCode === 0 ? head.stdout.trim() : ""
+    };
+  } catch {
+    return void 0;
+  }
+}
+function porcelainStatusByPath(entries) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    byPath.set(entry.path, entry.status);
+  }
+  return byPath;
+}
+function diffPorcelainPaths(before, after) {
+  const changed = /* @__PURE__ */ new Set();
+  for (const [pathKey, status] of after) {
+    if (before.get(pathKey) !== status) changed.add(pathKey);
+  }
+  for (const pathKey of before.keys()) {
+    if (!after.has(pathKey)) changed.add(pathKey);
+  }
+  return [...changed].sort();
+}
+function evaluateMutationSentinel(before, after) {
+  if (!before || !after) {
+    return { status: "unavailable" };
+  }
+  const headMoved = before.head !== after.head;
+  const changedPaths = diffPorcelainPaths(before.statusByPath, after.statusByPath);
+  if (!headMoved && changedPaths.length === 0) {
+    return { status: "unchanged" };
+  }
+  return {
+    status: "mutated",
+    changedPaths,
+    headMoved
+  };
+}
+function withMutationSentinel(error, sentinel) {
+  if (error && typeof error === "object") {
+    error.mutationSentinel = sentinel;
+  }
+  return error;
+}
+function getAskMutationSentinel(error) {
+  if (error && typeof error === "object" && "mutationSentinel" in error) {
+    return error.mutationSentinel;
+  }
+  return void 0;
+}
+async function runAsk(input) {
+  const provider = normalizeProviderId(input.target);
+  const eligibility = resolveAskEligibility(provider);
+  if (!eligibility.eligible) {
+    throw new ValidationError(
+      eligibility.message ?? "Error: Provider is not eligible for ask consultation."
+    );
+  }
+  if (!provider) {
+    throw new ValidationError("Error: ask requires a target provider.");
+  }
+  const cwd = path.resolve(input.cwd);
+  const stat = await fs.stat(cwd).catch(() => void 0);
+  if (!stat?.isDirectory()) {
+    throw new ValidationError(`Error: --cwd must be an existing directory: ${cwd}`);
+  }
+  const prompt = buildAskPrompt({ question: input.question, stdin: input.stdin });
+  const configuredModel = input.model ? void 0 : resolveProviderModel(provider, { provider }, cwd);
+  const requestedModel = input.model ?? (configuredModel && configuredModel.source !== "registry" && configuredModel.source !== "fallback" ? configuredModel.value : void 0);
+  const aliasedModel = requestedModel ? resolveUserModelAlias(provider, requestedModel, cwd).model : void 0;
+  const model = aliasedModel ? ProviderRegistry.resolveModel(provider, aliasedModel) : void 0;
+  if (model && input.model) warnIfExplicitModelUnobserved(provider, model);
+  let modelReasoningEffort;
+  let variantRequest;
+  if (input.effort) {
+    const requested = normalizeReasoningEffortInput(input.effort);
+    const nativeEffort = requested ? void 0 : resolveProviderNativeReasoningEffort(provider, input.effort, model);
+    if (nativeEffort) {
+      variantRequest = { provider, ...model ? { model } : {}, effort: nativeEffort };
+    } else if (requested) {
+      const resolution = resolveReasoningEffort(provider, requested, true, model, {
+        deferDefaultModelCapability: true
+      });
+      logReasoningEffortResolution(resolution, provider);
+      modelReasoningEffort = resolution.outcome === "unsupported" ? void 0 : resolution.resolvedLevel;
+    } else {
+      throw new ValidationError(`Error: Invalid reasoning effort "${input.effort}".`);
+    }
+  }
+  const runner = input.runner ?? runProvider;
+  const buildOwnedPrefixes = await resolveBuildOwnedPathPrefixes(cwd);
+  const fingerprintBefore = await captureWorktreeFingerprint(cwd, buildOwnedPrefixes);
+  const finalizeSentinel = async () => evaluateMutationSentinel(
+    fingerprintBefore,
+    await captureWorktreeFingerprint(cwd, buildOwnedPrefixes)
+  );
+  const budget = resolveAskBudget({
+    provider,
+    cwd,
+    timeoutMsFlag: input.timeoutMs
+  });
+  const deadlineMs = Date.now() + budget.timeoutMs;
+  let providerResult;
+  try {
+    providerResult = await runner({
+      ...variantRequest ? { variantRequest } : {},
+      provider,
+      profile: "default",
+      prompt,
+      workingDir: cwd,
+      model,
+      modelReasoningEffort,
+      executionIntent: "analysis",
+      inheritanceScope: "ask",
+      workspaceMode: "passthrough",
+      readOnlyWorkingDir: true,
+      nativeWebSearch: true,
+      allowEmptyResults: true,
+      timeoutMs: budget.timeoutMs,
+      deadlineMs,
+      idleWarnMs: budget.idleWarnMs,
+      idleKillMs: budget.idleKillMs,
+      // Operator cancellation: the runner terminates the provider process
+      // instead of letting an abandoned consult run to completion.
+      abortSignal: input.signal,
+      env: withAttributionEnv(input.attribution),
+      presentationProfile: "quiet",
+      entryPoint: "provider-native"
+    });
+  } catch (error) {
+    throw withMutationSentinel(
+      annotateAskBudgetCancellation(error, provider, budget),
+      await finalizeSentinel()
+    );
+  }
+  const mutationSentinel = await finalizeSentinel();
+  if (providerResult.exitCode === void 0 || providerResult.exitCode !== 0) {
+    const detail = providerResult.stderr?.trim() || providerResult.stdout?.trim();
+    throw withMutationSentinel(
+      new Error(
+        detail || (providerResult.exitCode === void 0 ? `Error: Provider "${provider}" did not report a successful exit.` : `Error: Provider "${provider}" exited with code ${providerResult.exitCode}.`)
+      ),
+      mutationSentinel
+    );
+  }
+  try {
+    assertAskTerminalResultComplete(provider, providerResult);
+  } catch (error) {
+    throw withMutationSentinel(error, mutationSentinel);
+  }
+  return {
+    provider,
+    model: providerResult.resolvedModel ?? model,
+    prompt,
+    answer: extractAskAnswer(providerResult),
+    mutationSentinel
+  };
+}
+
+export {
+  resolveAskStdinDeadline,
+  readAskStdinWithDeadline,
+  getAskBudgetCancellation,
+  resolveAskEligibility,
+  getAskMutationSentinel,
+  runAsk
+};
+//# sourceMappingURL=chunk-YPDCLXNZ.js.map

package/dist/chunk-YSQPGVFK.js

@@ -0,0 +1,116 @@
+import {
+  BACKUP_DB_ROOTS,
+  BACKUP_JSONL_ROOTS,
+  resolveBuildBase
+} from "./chunk-OI734GRS.js";
+
+// src/telemetry/backup-active-store.ts
+import path from "path";
+function isCoveredDirectory(candidate, buildBase) {
+  const resolved = path.resolve(candidate);
+  return BACKUP_DB_ROOTS.some((root) => path.resolve(buildBase, root) === resolved);
+}
+function isCoveredLogsDirectory(candidate, buildBase) {
+  const resolved = path.resolve(candidate);
+  return BACKUP_JSONL_ROOTS.some((entry) => {
+    const rootPath = path.resolve(buildBase, entry.root);
+    return resolved === rootPath || resolved.startsWith(rootPath + path.sep);
+  });
+}
+async function inspectActiveStores(buildBase = resolveBuildBase(), env = process.env) {
+  const coveredLabels = [];
+  const external = [];
+  let telemetryDbDir;
+  let telemetryLogsDir;
+  let isDataRoot = false;
+  try {
+    const [{ TelemetryPathResolver }, { getGlobalTelemetryDir }] = await Promise.all([
+      import("./telemetry-path-resolver-H3NFHHQY.js"),
+      import("./default-paths-UILB62BN.js")
+    ]);
+    const layout = TelemetryPathResolver.getInstance().resolveDbLayout(buildBase);
+    telemetryDbDir = layout.dbDir;
+    telemetryLogsDir = path.join(layout.telemetryDir, "logs");
+    isDataRoot = path.resolve(telemetryDbDir) === path.resolve(path.join(getGlobalTelemetryDir(), "db"));
+  } catch {
+    return { coveredLabels, external };
+  }
+  const redirectedBy = env.BUILD_TELEMETRY_DB ? "BUILD_TELEMETRY_DB" : isDataRoot ? "the Build data root, where telemetry is written by default" : "a configured telemetry path";
+  if (isCoveredDirectory(telemetryDbDir, buildBase)) {
+    coveredLabels.push("telemetry databases");
+  } else {
+    external.push({
+      label: "telemetry databases",
+      location: telemetryDbDir,
+      kind: "directory",
+      redirectedBy
+    });
+  }
+  if (isCoveredLogsDirectory(telemetryLogsDir, buildBase)) {
+    coveredLabels.push("telemetry logs");
+  } else {
+    external.push({
+      label: "telemetry logs",
+      location: telemetryLogsDir,
+      kind: "directory",
+      redirectedBy
+    });
+  }
+  try {
+    const { resolveInvocationsDbPath } = await import("./model-invocations-db-XTUPPQ34.js");
+    const invocationsDb = path.resolve(resolveInvocationsDbPath(buildBase));
+    const invocationsDir = path.dirname(invocationsDb);
+    if (isCoveredDirectory(invocationsDir, buildBase)) {
+      coveredLabels.push("invocations database");
+    } else if (invocationsDir !== path.resolve(telemetryDbDir)) {
+      external.push({
+        label: "invocations database",
+        location: invocationsDb,
+        kind: "file",
+        redirectedBy
+      });
+    }
+  } catch {
+  }
+  const routingOverride = env.BUILD_ROUTING_HISTORY_DB;
+  if (routingOverride) {
+    const routingDir = path.dirname(path.resolve(routingOverride));
+    if (isCoveredDirectory(routingDir, buildBase)) {
+      coveredLabels.push("routing history database");
+    } else {
+      external.push({
+        label: "routing history database",
+        location: path.resolve(routingOverride),
+        kind: "file",
+        redirectedBy: "BUILD_ROUTING_HISTORY_DB"
+      });
+    }
+  }
+  try {
+    const { resolveProjectRuntimeDir } = await import("./project-runtime-paths-2UQNG5Y4.js");
+    const lifecycleDir = resolveProjectRuntimeDir(buildBase, "lifecycle");
+    if (isCoveredDirectory(lifecycleDir, buildBase)) {
+      coveredLabels.push("lifecycle database");
+    } else {
+      external.push({
+        label: "lifecycle database",
+        location: lifecycleDir,
+        kind: "directory",
+        redirectedBy: "the project data migration"
+      });
+    }
+  } catch {
+  }
+  return { coveredLabels, external };
+}
+function formatExternalStoreWarnings(report) {
+  return report.external.map(
+    (store) => `Warning: ${store.label} resolve to ${store.location}, outside the backed-up roots (redirected by ${store.redirectedBy}). This backup does NOT contain them; back that location up separately.`
+  );
+}
+
+export {
+  inspectActiveStores,
+  formatExternalStoreWarnings
+};
+//# sourceMappingURL=chunk-YSQPGVFK.js.map