@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-UB7LQITD.js

@@ -0,0 +1,1040 @@
+import {
+  hasMigratableRepoLocalData,
+  isDataMigrationComplete
+} from "./chunk-7TUTZTI2.js";
+import {
+  SCHEMA_VERSION,
+  TelemetryDatabase,
+  checkSchemaVersion
+} from "./chunk-XIBVFMLQ.js";
+import {
+  signalCoordinator
+} from "./chunk-GC4CRMTS.js";
+import {
+  ensureWorktreeGitExclude,
+  parseSingleAbsoluteGitPath
+} from "./chunk-AHU3FKPA.js";
+import {
+  isKernelSandboxActive
+} from "./chunk-MJ6WNSIX.js";
+import {
+  TelemetryPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  execGit,
+  execGitSync
+} from "./chunk-MHLEZQQI.js";
+import {
+  getGlobalTelemetryDir,
+  getProjectDataDir
+} from "./chunk-56WPYDJH.js";
+import {
+  findTemplatePackageRoot
+} from "./chunk-STW7OFOA.js";
+import {
+  getRuntimeEnv,
+  hasExplicitBuildRoot,
+  resolveBuildRepoStartDir,
+  resolveRepoRootOverride
+} from "./chunk-7VRJHTGZ.js";
+
+// src/bootstrap/ensure-initialized.ts
+import { AsyncLocalStorage } from "async_hooks";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+import Database from "better-sqlite3";
+import * as lockfile2 from "proper-lockfile";
+
+// src/core/sandbox/host-sandbox-hint.ts
+var NESTED_AGENT_ROLE_ENV_KEY = "BUILD_AGENT_ROLE";
+var HOST_SANDBOX_EPERM_HINT = "Build was denied write access (EPERM) to its own state while running inside another agent's sandbox. Run `build` outside the host sandbox; see docs/reference/SECURITY.md, \"Running Build from another agent's sandbox\".";
+function isBuildOwnedEperm(failure) {
+  const cause = failure.cause;
+  const isEperm = cause?.code === "EPERM" || /\bEPERM\b|operation not permitted/i.test(failure.message);
+  if (!isEperm) return false;
+  const path3 = typeof cause?.path === "string" ? cause.path : failure.message;
+  return /[\\/]\.build(?:-project)?(?![\w.-])/.test(path3);
+}
+function hostSandboxEpermHint(failures) {
+  if (!failures.some(isBuildOwnedEperm)) return void 0;
+  if (getRuntimeEnv(NESTED_AGENT_ROLE_ENV_KEY)) return void 0;
+  return isKernelSandboxActive() ? HOST_SANDBOX_EPERM_HINT : void 0;
+}
+function hostSandboxHintForError(error) {
+  if (!(error instanceof Error)) return void 0;
+  return hostSandboxEpermHint([{ message: error.message, cause: error }]);
+}
+
+// src/bootstrap/build-git-ignore.ts
+import * as fs from "fs";
+import * as path from "path";
+var GITIGNORE_REL_PATH = ".build-project/.gitignore";
+function normalizeGitignoreEntry(entry) {
+  return entry.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function entrySet(content) {
+  return new Set(
+    content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map(normalizeGitignoreEntry).filter(Boolean)
+  );
+}
+function missingRuntimeEntries(content, templateEntries) {
+  const present = entrySet(content);
+  return templateEntries.filter((entry) => !present.has(normalizeGitignoreEntry(entry)));
+}
+function toExcludeLine(entry) {
+  const trimmed = entry.trim();
+  if (trimmed.startsWith("!")) return void 0;
+  const anchored = trimmed.startsWith("/");
+  const bare = trimmed.replace(/^\/+/, "");
+  const hasSlash = bare.replace(/\/+$/, "").includes("/");
+  return anchored || hasSlash ? `/.build-project/${bare}` : `/.build-project/**/${bare}`;
+}
+async function inspectBuildIgnore(repoRoot) {
+  try {
+    const indexed = await execGit(["ls-files", "--", GITIGNORE_REL_PATH], { cwd: repoRoot });
+    const inHead = await execGit(["cat-file", "-e", `HEAD:${GITIGNORE_REL_PATH}`], {
+      cwd: repoRoot
+    });
+    const gitignoreTracked = indexed.exitCode === 0 && indexed.stdout.trim().length > 0 || inHead.exitCode === 0;
+    const exclude = await execGit(
+      ["rev-parse", "--path-format=absolute", "--git-path", "info/exclude"],
+      { cwd: repoRoot }
+    );
+    const excludePath = exclude.exitCode === 0 ? parseSingleAbsoluteGitPath(exclude.stdout) : void 0;
+    return excludePath ? { gitignoreTracked, excludePath } : { gitignoreTracked };
+  } catch {
+    return { gitignoreTracked: false };
+  }
+}
+function hasBuildGitignoreRuntimeEntries(buildDir, templateEntries, state) {
+  if (state.gitignoreTracked) return true;
+  try {
+    const content = fs.readFileSync(path.join(buildDir, ".gitignore"), "utf-8");
+    return missingRuntimeEntries(content, templateEntries).length === 0;
+  } catch {
+    return false;
+  }
+}
+function ensureBuildGitignoreRuntimeEntries(buildDir, templateEntries, result, log) {
+  const gitignorePath = path.join(buildDir, ".gitignore");
+  let existing = "";
+  try {
+    existing = fs.readFileSync(gitignorePath, "utf-8");
+  } catch {
+    return;
+  }
+  const missing = missingRuntimeEntries(existing, templateEntries);
+  if (missing.length === 0) return;
+  const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  fs.appendFileSync(gitignorePath, `${prefix}${missing.join("\n")}
+`);
+  result.actions.repaired.push(gitignorePath);
+  log(`Updated runtime ignore entries: ${gitignorePath}`);
+}
+function removeRuntimeStubExclude(excludePath, result, log) {
+  const stubLine = `/${GITIGNORE_REL_PATH}`;
+  try {
+    if (!fs.existsSync(excludePath)) return;
+    const lines = fs.readFileSync(excludePath, "utf-8").split("\n");
+    const kept = lines.filter((line) => line.replace(/\r$/, "").trim() !== stubLine);
+    if (kept.length === lines.length) return;
+    fs.writeFileSync(excludePath, kept.join("\n"));
+    result.gitExcludeNotices = [
+      ...result.gitExcludeNotices ?? [],
+      `Removed the runtime-only ${stubLine} entry from ${excludePath}`
+    ];
+    log(`Updated git info exclude: ${excludePath}`);
+  } catch (error) {
+    result.gitExcludeNotices = [
+      ...result.gitExcludeNotices ?? [],
+      `Warning: could not update ${excludePath}: ${error instanceof Error ? error.message : String(error)}`
+    ];
+  }
+}
+async function reconcileBuildGitExclude(options) {
+  const { repoRoot, buildDir, tier, templateEntries, state, result, log } = options;
+  const requestedTier = options.requestedTier ?? tier;
+  const runtimeCreatedStub = requestedTier === "runtime" && options.stubCreatedHere === true;
+  if (!state.excludePath) return;
+  const wanted = [];
+  if (state.gitignoreTracked) {
+    let content = "";
+    try {
+      content = fs.readFileSync(path.join(buildDir, ".gitignore"), "utf-8");
+    } catch {
+    }
+    for (const entry of missingRuntimeEntries(content, templateEntries)) {
+      const line = toExcludeLine(entry);
+      if (line) wanted.push(line);
+      else {
+        result.gitExcludeNotices = [
+          ...result.gitExcludeNotices ?? [],
+          `Warning: skipped negated Build runtime entry "${entry}"; it cannot be written to info/exclude`
+        ];
+      }
+    }
+  } else if ((tier === "runtime" || runtimeCreatedStub) && fs.existsSync(path.join(buildDir, ".gitignore"))) {
+    wanted.push(`/${GITIGNORE_REL_PATH}`);
+  }
+  if (requestedTier === "full") removeRuntimeStubExclude(state.excludePath, result, log);
+  if (wanted.length === 0) return;
+  try {
+    const existing = fs.existsSync(state.excludePath) ? fs.readFileSync(state.excludePath, "utf-8") : "";
+    const present = new Set(existing.split(/\r?\n/).map((line) => line.trim()));
+    const missing = wanted.filter((line) => !present.has(line));
+    if (missing.length === 0) return;
+    await ensureWorktreeGitExclude(repoRoot, missing);
+    const after = fs.readFileSync(state.excludePath, "utf-8");
+    const written = new Set(after.split(/\r?\n/).map((line) => line.trim()));
+    if (!missing.every((line) => written.has(line))) {
+      throw new Error("exclude file did not accept the new lines");
+    }
+    result.gitExcludeNotices = [
+      ...result.gitExcludeNotices ?? [],
+      `Added ${missing.length} Build runtime ${missing.length === 1 ? "entry" : "entries"} to ${state.excludePath}`
+    ];
+    log(`Updated git info exclude: ${state.excludePath}`);
+  } catch (error) {
+    result.gitExcludeNotices = [
+      ...result.gitExcludeNotices ?? [],
+      `Warning: could not update ${state.excludePath}: ${error instanceof Error ? error.message : String(error)}`
+    ];
+  }
+}
+
+// src/bootstrap/init-lock-signals.ts
+import * as lockfile from "proper-lockfile";
+var RELEASE_SIGNALS = ["SIGINT", "SIGTERM"];
+var externalShutdownOwner = false;
+function declareExternalShutdownOwner() {
+  externalShutdownOwner = true;
+}
+function hasShutdownOwner() {
+  return externalShutdownOwner || signalCoordinator.isShuttingDown;
+}
+function registerInitLockSignalRelease(lockPath, raise = (signal) => process.kill(process.pid, signal)) {
+  const handlers = /* @__PURE__ */ new Map();
+  const dispose = () => {
+    for (const [signal, handler] of handlers) {
+      process.removeListener(signal, handler);
+    }
+    handlers.clear();
+  };
+  for (const signal of RELEASE_SIGNALS) {
+    const handler = () => {
+      try {
+        lockfile.unlockSync(lockPath);
+      } catch {
+      }
+      dispose();
+      if (!hasShutdownOwner()) {
+        raise(signal);
+      }
+    };
+    handlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  return dispose;
+}
+
+// src/bootstrap/initialization-types.ts
+var RuntimeRequirements = {
+  /**
+   * Required directories, all relative to the `.build-project/` directory.
+   *
+   * `telemetry/` is deliberately absent: telemetry databases, JSONL logs and run
+   * state (`telemetry/state`) all resolve under the Build data root, and
+   * pre-creating repo-local copies here is what gave a fresh checkout an empty
+   * `.build-project/telemetry/db/validations.db` before its first competition. Writers
+   * create their own directories on first use.
+   */
+  directories: ["artifacts", "config", "cache", "worktrees", "state"],
+  /**
+   * Required database file names.
+   *
+   * File names only, not paths: the containing directory comes from
+   * `TelemetryPathResolver.resolveDbDir`, so bootstrap creates and health-checks
+   * the same files the writers use.
+   */
+  databases: ["variants.db", "validations.db"],
+  /** Required configuration files (created from embedded templates if missing) */
+  configFiles: [".gitignore"],
+  /** State marker file */
+  stateFile: "state/init.json",
+  /** Initialization lock file path (for cross-process safety) */
+  lockFile: "state/.init.lock"
+};
+var FullRequirements = {
+  /** Additional directories for full tier */
+  directories: [
+    // Note: all paths are relative to the `.build-project/` directory.
+    "templates",
+    "planning",
+    "reasoning"
+  ],
+  /** Optional configuration files for full setup */
+  optionalConfig: ["config/user.yaml"]
+};
+
+// src/bootstrap/template-personas.ts
+function isAgentPersonaTemplate(relPath) {
+  const normalized = relPath.split("\\").join("/");
+  return normalized.startsWith("agents/") && normalized !== "agents/README.md";
+}
+
+// src/bootstrap/ensure-initialized.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+function resolveRepoRootForBuildDir(cwd, options = {}) {
+  const { honorBuildRepo = true } = options;
+  if (honorBuildRepo && hasExplicitBuildRoot()) {
+    const explicitRoot = resolveRepoRootOverride();
+    if (explicitRoot) {
+      return explicitRoot;
+    }
+  }
+  const startDir = honorBuildRepo ? resolveBuildRepoStartDir(cwd) : cwd;
+  try {
+    const result = execGitSync(["rev-parse", "--show-toplevel"], { cwd: startDir });
+    const stdout = result.exitCode === 0 ? result.stdout.trim() : "";
+    if (stdout) return stdout;
+  } catch {
+  }
+  let currentDir = path2.resolve(startDir);
+  while (true) {
+    const gitDir = path2.join(currentDir, ".git");
+    if (fs2.existsSync(gitDir)) return currentDir;
+    const parentDir = path2.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return path2.resolve(startDir);
+}
+var PACKAGE_ROOT = findTemplatePackageRoot(__dirname) ?? path2.resolve(__dirname, "..");
+var TEMPLATE_BUILD_DIR = path2.join(PACKAGE_ROOT, "templates", ".build-project");
+var PACK_SAFE_TEMPLATE_SOURCES = {
+  ".gitignore": "gitignore.template"
+};
+var BUILD_GITIGNORE_RUNTIME_ENTRY_FALLBACK = [
+  "runs/",
+  "blocker-answers/",
+  "merge-apply/",
+  "config/project-context.json",
+  "provider-history/",
+  "prompts/",
+  "planning/indexes/",
+  "/plans/",
+  // Transient intent context-injection telemetry (see gitignore.template).
+  "logs/injection/"
+];
+function readBuildGitignoreTemplateEntries() {
+  const templatePath = path2.join(TEMPLATE_BUILD_DIR, templateSourceRelPath(".gitignore"));
+  try {
+    return fs2.readFileSync(templatePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  } catch {
+    return [...BUILD_GITIGNORE_RUNTIME_ENTRY_FALLBACK];
+  }
+}
+function toPosixRelPath(relPath) {
+  return relPath.split(path2.sep).join("/");
+}
+function templateSourceRelPath(destRelPath) {
+  return PACK_SAFE_TEMPLATE_SOURCES[toPosixRelPath(destRelPath)] ?? destRelPath;
+}
+function templateDestRelPath(sourceRelPath) {
+  const normalized = toPosixRelPath(sourceRelPath);
+  for (const [dest, source] of Object.entries(PACK_SAFE_TEMPLATE_SOURCES)) {
+    if (source === normalized) return dest;
+  }
+  return sourceRelPath;
+}
+var LOCK_TIMEOUT_MS = 1e4;
+var LOCK_OPTIONS = {
+  stale: 3e4,
+  // Consider lock stale after 30 seconds
+  retries: {
+    retries: 50,
+    minTimeout: 100,
+    maxTimeout: 1e3,
+    maxRetryTime: LOCK_TIMEOUT_MS
+  }
+};
+function getProjectInitializationLockPath(repoRoot) {
+  return path2.join(getProjectDataDir(path2.resolve(repoRoot)), "initialization.lock");
+}
+var heldProjectInitializationLocks = new AsyncLocalStorage();
+async function withProjectInitializationLock(repoRoot, fn) {
+  const lockPath = getProjectInitializationLockPath(repoRoot);
+  const heldLocks = heldProjectInitializationLocks.getStore();
+  if (heldLocks?.has(lockPath)) return fn();
+  return withInitLock(
+    lockPath,
+    () => heldProjectInitializationLocks.run(/* @__PURE__ */ new Set([...heldLocks ?? [], lockPath]), fn)
+  );
+}
+async function ensureBuildInitialized(options = {}) {
+  const repoRoot = resolveRepoRootForBuildDir(options.cwd ?? process.cwd());
+  return withProjectInitializationLock(
+    repoRoot,
+    () => ensureBuildInitializedLocked({ ...options, cwd: repoRoot })
+  );
+}
+async function ensureBuildInitializedLocked(options) {
+  const startTime = Date.now();
+  const {
+    cwd = process.cwd(),
+    tier = "runtime",
+    verbose = false,
+    repair = false,
+    allowDegraded = true,
+    fullTemplateExcludes = [],
+    agentPersonas = false
+  } = options;
+  const repoRoot = resolveRepoRootForBuildDir(cwd);
+  const buildDir = path2.join(repoRoot, ".build-project");
+  const stateFilePath = path2.join(buildDir, RuntimeRequirements.stateFile);
+  const result = {
+    status: "ok",
+    tier,
+    actions: { created: [], repaired: [], skipped: [] },
+    warnings: [],
+    errors: [],
+    nextSteps: [],
+    telemetryMode: "database",
+    initDurationMs: 0
+  };
+  const log = (message) => {
+    if (verbose) {
+      console.log(`[Init] ${message}`);
+    }
+  };
+  if (!repair) {
+    const fastState = readInitializationState(stateFilePath);
+    const dbDir = resolveTelemetryDbDir(buildDir);
+    const databasesOpenable = areDatabasesOpenable(dbDir);
+    const ignoreState = await inspectBuildIgnore(repoRoot);
+    const hasGitignoreStub = ignoreState.gitignoreTracked || fs2.existsSync(path2.join(buildDir, ".gitignore"));
+    const hasRuntimeGitignoreEntries = hasBuildGitignoreRuntimeEntries(
+      buildDir,
+      readBuildGitignoreTemplateEntries(),
+      ignoreState
+    );
+    if (tier === "runtime" && fastState && fastState.schemaVersion === SCHEMA_VERSION && databasesOpenable && hasGitignoreStub && hasRuntimeGitignoreEntries && isTierSufficient(fastState.tier, tier)) {
+      await reconcileBuildGitExclude({
+        repoRoot,
+        buildDir,
+        tier: maxTier(fastState.tier, tier),
+        requestedTier: tier,
+        templateEntries: readBuildGitignoreTemplateEntries(),
+        state: ignoreState,
+        result,
+        log
+      });
+      if (result.status === "ok" || allowDegraded && result.status === "degraded") {
+        await warnIfDataMigrationPending(buildDir, result);
+        if (result.actions.created.length > 0 || result.actions.repaired.length > 0) {
+          try {
+            await writeStateMarker(buildDir, tier, result, log, true, {
+              materialChanges: true,
+              schemaNeedsHealing: false
+            });
+          } catch {
+          }
+        }
+        result.schemaVersion = fastState.schemaVersion;
+        result.nextSteps = generateNextSteps(result);
+        result.initDurationMs = Date.now() - startTime;
+        return finalizeInitializationResult(result, allowDegraded);
+      }
+    }
+  }
+  try {
+    log("Ensuring base directory exists");
+    await ensureBaseDirectory(buildDir, result, log);
+    const lockResult = await (async () => {
+      log("Checking required directories");
+      await ensureDirectories(buildDir, tier, result, log, allowDegraded);
+      await ensureExternalDataDirectories(repoRoot, buildDir, result, log);
+      log("Initializing databases");
+      await initializeDatabases(buildDir, result, log, allowDegraded);
+      log("Checking configuration stubs");
+      const ignoreState = await inspectBuildIgnore(repoRoot);
+      await ensureConfigStubs(
+        buildDir,
+        tier,
+        result,
+        log,
+        fullTemplateExcludes,
+        agentPersonas,
+        ignoreState
+      );
+      const existingState = readInitializationState(stateFilePath);
+      const effectiveTier = maxTier(existingState?.tier ?? tier, tier);
+      await reconcileBuildGitExclude({
+        repoRoot,
+        buildDir,
+        tier: effectiveTier,
+        requestedTier: tier,
+        stubCreatedHere: result.actions.created.includes(path2.join(buildDir, ".gitignore")),
+        templateEntries: readBuildGitignoreTemplateEntries(),
+        state: ignoreState,
+        result,
+        log
+      });
+      log("Writing state marker");
+      const schemaNeedsHealing = typeof existingState?.schemaVersion === "number" && typeof result.schemaVersion === "number" && existingState.schemaVersion < result.schemaVersion;
+      const materialChangesBeforeState = result.actions.created.length > 0 || result.actions.repaired.length > 0;
+      const shouldUpdateState = repair || schemaNeedsHealing || materialChangesBeforeState;
+      await writeStateMarker(buildDir, tier, result, log, shouldUpdateState, {
+        materialChanges: materialChangesBeforeState,
+        schemaNeedsHealing
+      });
+      return result;
+    })();
+    Object.assign(result, lockResult);
+  } catch (error) {
+    const errorCode = determineErrorCode(error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    result.status = "failed";
+    result.errors.push({
+      code: errorCode,
+      message: errorMessage,
+      cause: error
+    });
+    if (errorCode === "DB_LOCKED" /* DB_LOCKED */) {
+      result.nextSteps.push(
+        "Wait for other Build processes to complete",
+        "Check for a stale project initialization lock in the Build data directory",
+        `If issue persists, inspect ${getProjectInitializationLockPath(repoRoot)}`
+      );
+    }
+  }
+  result.initDurationMs = Date.now() - startTime;
+  if (result.nextSteps.length === 0) {
+    result.nextSteps = generateNextSteps(result);
+  }
+  log(`Initialization complete: ${result.status} (${result.initDurationMs}ms)`);
+  return finalizeInitializationResult(result, allowDegraded);
+}
+async function withInitLock(lockPath, fn, lockOptions = LOCK_OPTIONS) {
+  const lockDir = path2.dirname(lockPath);
+  if (!fs2.existsSync(lockDir)) {
+    fs2.mkdirSync(lockDir, { recursive: true });
+  }
+  if (!fs2.existsSync(lockPath)) {
+    fs2.writeFileSync(lockPath, "");
+  }
+  let release;
+  let disposeSignalRelease;
+  try {
+    try {
+      release = await lockfile2.lock(lockPath, lockOptions);
+    } catch (error) {
+      if (error.code === "ELOCKED") {
+        throw new Error(
+          `Lock acquisition timeout after ${LOCK_TIMEOUT_MS}ms. Another Build process may be initializing. If none is running, remove ${lockPath}.lock; a lock older than ${LOCK_OPTIONS.stale / 1e3} seconds is reclaimed automatically.`,
+          { cause: error }
+        );
+      }
+      throw error;
+    }
+    disposeSignalRelease = registerInitLockSignalRelease(lockPath);
+    return await fn();
+  } finally {
+    disposeSignalRelease?.();
+    if (release) {
+      try {
+        await release();
+      } catch (error) {
+        console.warn(
+          "[Init] Failed to release lock:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
+  }
+}
+async function ensureBaseDirectory(buildDir, result, log) {
+  try {
+    if (!fs2.existsSync(buildDir)) {
+      fs2.mkdirSync(buildDir, { recursive: true });
+      result.actions.created.push(buildDir);
+      log(`Created: ${buildDir}`);
+    } else {
+      result.actions.skipped.push(buildDir);
+    }
+  } catch (error) {
+    const errorCode = determineErrorCode(error);
+    result.status = "failed";
+    result.errors.push({
+      code: errorCode,
+      message: `Failed to create base directory: ${error instanceof Error ? error.message : String(error)}`,
+      cause: error,
+      path: buildDir
+    });
+    throw error;
+  }
+}
+async function ensureDirectories(buildDir, tier, result, log, allowDegraded = true) {
+  const directories = [...RuntimeRequirements.directories];
+  if (tier === "full") {
+    directories.push(...FullRequirements.directories);
+  }
+  for (const dir of directories) {
+    const fullPath = path2.join(buildDir, dir);
+    try {
+      if (!fs2.existsSync(fullPath)) {
+        fs2.mkdirSync(fullPath, { recursive: true });
+        result.actions.created.push(fullPath);
+        log(`Created: ${fullPath}`);
+      } else {
+        result.actions.skipped.push(fullPath);
+      }
+    } catch (error) {
+      const errorCode = determineErrorCode(error);
+      result.warnings.push(
+        `Failed to create directory ${fullPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      if (dir.includes("telemetry") || dir.includes("config") || dir.includes("cache") || dir.includes("state") || dir.includes("worktrees")) {
+        result.errors.push({
+          code: errorCode,
+          message: `Failed to create critical directory: ${fullPath}`,
+          cause: error,
+          path: fullPath
+        });
+        if (allowDegraded) {
+          result.status = "degraded";
+        } else {
+          result.status = "failed";
+          throw error instanceof Error ? error : new Error(String(error));
+        }
+      }
+    }
+  }
+}
+async function ensureExternalDataDirectories(repoRoot, buildDir, result, log) {
+  const globalTelemetryDir = getGlobalTelemetryDir();
+  const projectDataDir = getProjectDataDir(repoRoot);
+  const externalDirs = [
+    globalTelemetryDir,
+    path2.join(globalTelemetryDir, "db"),
+    path2.join(globalTelemetryDir, "logs"),
+    projectDataDir,
+    path2.join(projectDataDir, "state"),
+    path2.join(projectDataDir, "provider-history"),
+    path2.join(projectDataDir, "labs"),
+    path2.join(projectDataDir, "backups"),
+    path2.join(projectDataDir, "lifecycle"),
+    path2.join(projectDataDir, "cache")
+  ];
+  for (const dir of externalDirs) {
+    try {
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+        result.actions.created.push(dir);
+        log(`Created external data dir: ${dir}`);
+      }
+    } catch (error) {
+      result.warnings.push(
+        `Failed to create external data directory ${dir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  await warnIfDataMigrationPending(buildDir, result);
+}
+async function warnIfDataMigrationPending(buildDir, result) {
+  if (isDataMigrationComplete(buildDir)) {
+    return;
+  }
+  try {
+    if (!await hasMigratableRepoLocalData(buildDir)) {
+      return;
+    }
+  } catch {
+    return;
+  }
+  result.warnings.push(
+    "Legacy telemetry data detected in .build-project/. Run `build data migrate preview` then `build data migrate execute` to externalize non-reproducible data."
+  );
+}
+async function initializeDatabases(buildDir, result, log, allowDegraded) {
+  const dbDir = resolveTelemetryDbDir(buildDir);
+  try {
+    if (!fs2.existsSync(dbDir)) {
+      fs2.mkdirSync(dbDir, { recursive: true });
+      result.actions.created.push(dbDir);
+    }
+    const progressReporter = (message) => log(message);
+    const db = new TelemetryDatabase(dbDir, progressReporter);
+    log("Initializing database schema");
+    db.init();
+    const health = db.getHealth();
+    log(`Database health: ${JSON.stringify(health)}`);
+    if (!health.available) {
+      throw new Error(health.lastInitError || "Database initialization failed");
+    }
+    const variantsDb = db.getVariantsDb();
+    if (variantsDb) {
+      const currentVersion = checkSchemaVersion(variantsDb);
+      result.schemaVersion = currentVersion;
+      if (currentVersion !== SCHEMA_VERSION) {
+        result.warnings.push(
+          `Schema version mismatch: expected ${SCHEMA_VERSION}, got ${currentVersion}`
+        );
+      } else {
+        log(`Schema version: ${currentVersion}`);
+      }
+    }
+    db.close();
+    result.telemetryMode = "database";
+  } catch (error) {
+    const errorCode = determineErrorCode(error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Database initialization failed: ${errorMessage}`);
+    result.errors.push({
+      code: errorCode,
+      message: `Database initialization failed: ${errorMessage}`,
+      cause: error,
+      path: dbDir
+    });
+    if (allowDegraded) {
+      result.status = "degraded";
+      result.telemetryMode = "jsonl-only";
+      result.warnings.push("Operating in JSONL-only mode (database unavailable)");
+      log("Entering degraded mode (JSONL-only)");
+    } else {
+      result.status = "failed";
+      throw error;
+    }
+  }
+}
+async function ensureConfigStubs(buildDir, tier, result, log, fullTemplateExcludes = [], agentPersonas = false, ignoreState = { gitignoreTracked: false }) {
+  for (const relPath of RuntimeRequirements.configFiles) {
+    const destPath = path2.join(buildDir, relPath);
+    if (relPath === ".gitignore" && ignoreState.gitignoreTracked) {
+      result.actions.skipped.push(destPath);
+      continue;
+    }
+    if (fs2.existsSync(destPath)) {
+      result.actions.skipped.push(destPath);
+      if (relPath === ".gitignore") {
+        ensureBuildGitignoreRuntimeEntries(
+          buildDir,
+          readBuildGitignoreTemplateEntries(),
+          result,
+          log
+        );
+      }
+      continue;
+    }
+    const sourcePath = path2.join(TEMPLATE_BUILD_DIR, templateSourceRelPath(relPath));
+    if (!fs2.existsSync(sourcePath)) {
+      const message = `Missing embedded template: ${sourcePath}`;
+      result.warnings.push(message);
+      continue;
+    }
+    try {
+      fs2.mkdirSync(path2.dirname(destPath), { recursive: true });
+      fs2.copyFileSync(sourcePath, destPath);
+      if (relPath === ".gitignore") {
+        ensureBuildGitignoreRuntimeEntries(
+          buildDir,
+          readBuildGitignoreTemplateEntries(),
+          result,
+          log
+        );
+      }
+      result.actions.created.push(destPath);
+      log(`Created: ${destPath}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      result.warnings.push(`Failed to copy template ${relPath}: ${errorMessage}`);
+    }
+  }
+  if (tier === "full") {
+    const excludes = [.../* @__PURE__ */ new Set([...fullTemplateExcludes, "config/providers.yaml", "task-types"])];
+    excludes.push("config/build.config.jsonc");
+    await ensureTemplateTree(buildDir, result, log, excludes, agentPersonas, ignoreState);
+  }
+}
+async function ensureTemplateTree(buildDir, result, log, fullTemplateExcludes = [], agentPersonas = false, ignoreState = { gitignoreTracked: false }) {
+  if (!fs2.existsSync(TEMPLATE_BUILD_DIR)) {
+    const message = `Templates directory not found: ${TEMPLATE_BUILD_DIR}`;
+    result.status = "failed";
+    result.errors.push({
+      code: "TEMPLATE_COPY_FAILED" /* TEMPLATE_COPY_FAILED */,
+      message,
+      path: TEMPLATE_BUILD_DIR
+    });
+    throw new Error(message);
+  }
+  const copyMissing = (sourcePath, relPath) => {
+    if (isExcludedTemplatePath(relPath, fullTemplateExcludes)) {
+      return;
+    }
+    const destPath = path2.join(buildDir, relPath);
+    if (fs2.existsSync(destPath) || relPath === ".gitignore" && ignoreState.gitignoreTracked) {
+      result.actions.skipped.push(destPath);
+      return;
+    }
+    fs2.mkdirSync(path2.dirname(destPath), { recursive: true });
+    fs2.copyFileSync(sourcePath, destPath);
+    result.actions.created.push(destPath);
+    log(`Created: ${destPath}`);
+  };
+  const walk = (dir, relBase) => {
+    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+      const entrySourcePath = path2.join(dir, entry.name);
+      const entryRelPath = relBase ? path2.join(relBase, entry.name) : entry.name;
+      if (isExcludedTemplatePath(entryRelPath, fullTemplateExcludes)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        const destDir = path2.join(buildDir, entryRelPath);
+        if (!fs2.existsSync(destDir)) {
+          fs2.mkdirSync(destDir, { recursive: true });
+          result.actions.created.push(destDir);
+          log(`Created: ${destDir}`);
+        } else {
+          result.actions.skipped.push(destDir);
+        }
+        walk(entrySourcePath, entryRelPath);
+        continue;
+      }
+      if (entry.isFile() && (agentPersonas || !isAgentPersonaTemplate(entryRelPath))) {
+        copyMissing(entrySourcePath, templateDestRelPath(entryRelPath));
+      }
+    }
+  };
+  try {
+    walk(TEMPLATE_BUILD_DIR, "");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    result.status = "failed";
+    result.errors.push({
+      code: "TEMPLATE_COPY_FAILED" /* TEMPLATE_COPY_FAILED */,
+      message: `Failed to copy templates: ${errorMessage}`,
+      cause: error,
+      path: TEMPLATE_BUILD_DIR
+    });
+    throw error;
+  }
+}
+function isExcludedTemplatePath(relPath, excludedPrefixes) {
+  if (excludedPrefixes.length === 0) return false;
+  const normalizedRelPath = path2.normalize(relPath);
+  return excludedPrefixes.some((prefix) => {
+    const normalizedPrefix = path2.normalize(prefix);
+    return normalizedRelPath === normalizedPrefix || normalizedRelPath.startsWith(normalizedPrefix + path2.sep);
+  });
+}
+async function writeStateMarker(buildDir, tier, result, log, shouldUpdate, context = { materialChanges: false, schemaNeedsHealing: false }) {
+  const stateFile = path2.join(buildDir, RuntimeRequirements.stateFile);
+  try {
+    const existingState = readInitializationState(stateFile);
+    const stateFileExists = fs2.existsSync(stateFile);
+    if (stateFileExists && !shouldUpdate) {
+      result.actions.skipped.push(stateFile);
+      return;
+    }
+    const version = readPackageVersion();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const effectiveTier = maxTier(existingState?.tier ?? tier, tier);
+    const state = {
+      version,
+      tier: effectiveTier,
+      initializedAt: existingState?.initializedAt ?? now,
+      lastCheckedAt: now,
+      schemaVersion: result.schemaVersion ?? existingState?.schemaVersion ?? SCHEMA_VERSION,
+      repairHistory: result.actions.repaired.length > 0 ? [
+        ...existingState?.repairHistory ?? [],
+        {
+          timestamp: now,
+          repairs: result.actions.repaired
+        }
+      ] : existingState?.repairHistory
+    };
+    fs2.mkdirSync(path2.dirname(stateFile), { recursive: true });
+    fs2.writeFileSync(stateFile, `${JSON.stringify(state, null, 2)}
+`);
+    if (!stateFileExists) {
+      result.actions.created.push(stateFile);
+    } else if (context.materialChanges || context.schemaNeedsHealing) {
+      result.actions.repaired.push(stateFile);
+    }
+    log(`Updated state marker: ${stateFile}`);
+  } catch (error) {
+    result.warnings.push(
+      `Failed to write state marker: ${error instanceof Error ? error.message : String(error)}`
+    );
+    log(
+      `Warning: Could not write state marker: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function readPackageVersion() {
+  try {
+    const pkgPath = path2.join(PACKAGE_ROOT, "package.json");
+    if (!fs2.existsSync(pkgPath)) return "0.0.0";
+    const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+    return typeof pkg.version === "string" && pkg.version.trim() ? pkg.version.trim() : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function readInitializationTier(cwd) {
+  const tier = readInitializationState(
+    path2.join(cwd, ".build-project", "state", "init.json")
+  )?.tier;
+  return tier === "runtime" || tier === "full" ? tier : void 0;
+}
+function readInitializationState(stateFilePath) {
+  try {
+    if (!fs2.existsSync(stateFilePath)) return null;
+    const raw = fs2.readFileSync(stateFilePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function tierRank(tier) {
+  return tier === "full" ? 2 : 1;
+}
+function isTierSufficient(actual, required) {
+  return tierRank(actual) >= tierRank(required);
+}
+function maxTier(a, b) {
+  return tierRank(a) >= tierRank(b) ? a : b;
+}
+function resolveTelemetryDbDir(buildDir) {
+  try {
+    return TelemetryPathResolver.getInstance().resolveDbDir(buildDir);
+  } catch {
+    return path2.join(buildDir, "telemetry", "db");
+  }
+}
+function areDatabasesOpenable(dbDir) {
+  for (const fileName of RuntimeRequirements.databases) {
+    const dbPath = path2.join(dbDir, fileName);
+    if (!fs2.existsSync(dbPath)) return false;
+    let db;
+    try {
+      db = new Database(dbPath, { readonly: true, fileMustExist: true });
+      db.prepare("SELECT 1").get();
+    } catch {
+      return false;
+    } finally {
+      try {
+        db?.close();
+      } catch {
+      }
+    }
+  }
+  return true;
+}
+function finalizeInitializationResult(result, allowDegraded) {
+  if (!allowDegraded && result.status === "degraded") {
+    result.status = "failed";
+    if (result.errors.length === 0) {
+      result.errors.push({
+        code: "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        message: "Initialization completed in degraded mode but allowDegraded=false"
+      });
+    }
+    if (result.nextSteps.length === 0 || result.nextSteps[0]?.includes("degraded")) {
+      result.nextSteps = generateNextSteps(result);
+    }
+  }
+  return result;
+}
+function determineErrorCode(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error);
+  if (message.includes("locked") || message.includes("busy")) {
+    return "DB_LOCKED" /* DB_LOCKED */;
+  }
+  if (message.includes("corrupt") || message.includes("malformed") || message.includes("integrity")) {
+    return "DB_CORRUPT" /* DB_CORRUPT */;
+  }
+  if (message.includes("permission") || message.includes("eacces") || message.includes("eperm")) {
+    return "PERMISSION_DENIED" /* PERMISSION_DENIED */;
+  }
+  if (message.includes("migration")) {
+    return "MIGRATION_FAILED" /* MIGRATION_FAILED */;
+  }
+  if (message.includes("enospc") || message.includes("disk space")) {
+    return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+  }
+  if (message.includes("timeout") || message.includes("lock acquisition")) {
+    return "DB_LOCKED" /* DB_LOCKED */;
+  }
+  return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+}
+function generateNextSteps(result) {
+  const steps = [];
+  if (result.status === "ok") {
+    steps.push("Build is ready to use");
+    return steps;
+  }
+  if (result.status === "degraded") {
+    steps.push(
+      "Build is running in degraded mode (JSONL-only telemetry)",
+      "Check database errors above for details"
+    );
+    const hasDbError = result.errors.some(
+      (e) => e.code === "DB_CORRUPT" /* DB_CORRUPT */ || e.code === "DB_LOCKED" /* DB_LOCKED */
+    );
+    if (hasDbError) {
+      steps.push(
+        'Run "build doctor" to print the resolved telemetry database directory, then remove it and restart',
+        "If issue persists, check file permissions and disk space"
+      );
+    }
+  }
+  if (result.status === "failed") {
+    steps.push("Initialization failed - Build cannot run");
+    const hasPermissionError = result.errors.some(
+      (e) => e.code === "PERMISSION_DENIED" /* PERMISSION_DENIED */
+    );
+    if (hasPermissionError) {
+      const hostSandboxHint = hostSandboxEpermHint(result.errors);
+      steps.push(
+        ...hostSandboxHint ? [hostSandboxHint] : [
+          "Check file permissions for .build-project directory",
+          "Ensure you have write access to the project directory"
+        ]
+      );
+    }
+    const hasCorruptError = result.errors.some((e) => e.code === "DB_CORRUPT" /* DB_CORRUPT */);
+    if (hasCorruptError) {
+      steps.push(
+        "Database appears corrupted",
+        'Run "build doctor" to print the resolved telemetry database directory, then remove it and restart',
+        'If you need to preserve data, run "build backup" first'
+      );
+    }
+    const hasMigrationError = result.errors.some((e) => e.code === "MIGRATION_FAILED" /* MIGRATION_FAILED */);
+    if (hasMigrationError) {
+      steps.push(
+        "Schema migration failed",
+        "Check that Node.js version is 24.x",
+        'Run "build doctor" to print the resolved telemetry database directory, then remove it to reset schema'
+      );
+    }
+  }
+  return steps;
+}
+
+export {
+  hostSandboxEpermHint,
+  hostSandboxHintForError,
+  inspectBuildIgnore,
+  declareExternalShutdownOwner,
+  RuntimeRequirements,
+  resolveRepoRootForBuildDir,
+  withProjectInitializationLock,
+  ensureBuildInitialized,
+  withInitLock,
+  readInitializationTier
+};
+//# sourceMappingURL=chunk-UB7LQITD.js.map