@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-AISTV5XU.js

@@ -0,0 +1,226 @@
+// src/utils/planning-validation.ts
+import { z } from "zod";
+var TaskIdSchema = z.string().min(1, "Task ID cannot be empty").max(100, "Task ID too long (max 100 characters)").regex(
+  /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/,
+  "Task ID contains invalid characters. Only alphanumeric, dots, hyphens, and underscores allowed"
+).refine((id) => {
+  if (id.includes("..") || id.includes("/") || id.includes("\\")) {
+    return false;
+  }
+  if (id.includes("\0")) {
+    return false;
+  }
+  return true;
+}, "Task ID contains dangerous characters");
+var SprintNameSchema = z.string().min(1, "Sprint name cannot be empty").max(50, "Sprint name too long (max 50 characters)").regex(/^[a-zA-Z0-9]/, "Sprint name must start with an alphanumeric character").refine(
+  (name) => !name.includes("..") && !name.includes("/") && !name.includes("\\") && !Array.from(name).some((character) => {
+    const codePoint = character.charCodeAt(0);
+    return codePoint <= 31 || codePoint === 127;
+  }),
+  "Sprint name contains invalid characters"
+);
+var PrioritySchema = z.enum(["P0", "P1", "P2", "P3"]).describe("Priority must be P0 (critical), P1 (high), P2 (medium), or P3 (low)");
+var SeveritySchema = z.enum(["critical", "high", "medium", "low"]).describe("Severity must be: critical, high, medium, or low");
+var EffortSchema = z.enum(["low", "medium", "high"]).describe("Effort must be: low, medium, or high");
+var TaskStatusSchema = z.enum(["todo", "in_progress", "review", "done", "blocked"]).describe("Status must be: todo, in_progress, review, done, or blocked");
+var BacklogStatusSchema = z.enum(["inbox", "reviewed", "archived", "done"]).describe("Status must be: inbox, reviewed, archived, or done");
+var StoryPointsSchema = z.number().int("Story points must be an integer").min(1, "Story points must be at least 1").max(100, "Story points cannot exceed 100").refine((val) => {
+  const fibonacci = [1, 2, 3, 5, 8, 13, 21, 34, 55, 89];
+  return fibonacci.includes(val) || val <= 100;
+}, "Story points should follow Fibonacci sequence or be reasonable values");
+var ComplexitySchema = z.number().min(0, "Complexity cannot be negative").max(1, "Complexity cannot exceed 1.0").refine((val) => !Number.isNaN(val), "Complexity must be a valid number");
+var EstimatedHoursSchema = z.number().positive("Estimated hours must be positive").max(200, "Estimated hours cannot exceed 200 (consider breaking down the task)");
+var ExpectedRuntimeMinutesSchema = z.number().positive("Expected runtime minutes must be positive").max(1440, "Expected runtime cannot exceed 1440 minutes (24h); consider breaking down the item");
+var DateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").refine((date) => {
+  const match = date.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) return false;
+  const year = Number.parseInt(match[1] ?? "", 10);
+  const month = Number.parseInt(match[2] ?? "", 10);
+  const day = Number.parseInt(match[3] ?? "", 10);
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) return false;
+  const parsed = new Date(Date.UTC(year, month - 1, day));
+  if (Number.isNaN(parsed.getTime())) return false;
+  if (parsed.getUTCFullYear() !== year) return false;
+  if (parsed.getUTCMonth() !== month - 1) return false;
+  if (parsed.getUTCDate() !== day) return false;
+  return true;
+}, "Invalid date");
+var DomainSchema = z.enum([
+  "general",
+  "architecture",
+  "database",
+  "performance",
+  "testing",
+  "dependencies",
+  "security",
+  "infrastructure",
+  "ui",
+  "api"
+]).describe(
+  "Invalid domain. Must be one of: general, architecture, database, performance, testing, dependencies, security, infrastructure, ui, api"
+);
+var ImpactScoreSchema = z.number().min(1, "Impact score must be at least 1").max(10, "Impact score cannot exceed 10").int("Impact score must be an integer");
+var SafeTaskDescriptionSchema = z.string().min(1, "Description cannot be empty").max(5e3, "Description too long (max 5000 characters)").transform((desc) => desc.trim()).refine((desc) => {
+  if (desc.includes("\0")) {
+    return false;
+  }
+  const dangerousPatterns = /(\$\(.*\)|`.*`|;.*&|&&|\|\|)/;
+  if (dangerousPatterns.test(desc)) {
+    return false;
+  }
+  return true;
+}, "Description contains potentially dangerous characters");
+var CheckpointPathSchema = z.string().min(1, "Checkpoint path cannot be empty").refine((path) => {
+  if (!path.endsWith(".json")) {
+    return false;
+  }
+  if (path.includes("..")) {
+    return false;
+  }
+  if (path.startsWith("/") && !path.startsWith(process.cwd())) {
+    return false;
+  }
+  if (path.includes("\0")) {
+    return false;
+  }
+  return true;
+}, "Invalid checkpoint file path");
+var CheckpointResumePathSchema = z.string().min(1, "Checkpoint path cannot be empty").refine((path) => {
+  if (!path.endsWith(".json")) {
+    return false;
+  }
+  if (path.includes("..")) {
+    return false;
+  }
+  if (path.includes("\0")) {
+    return false;
+  }
+  return true;
+}, "Invalid checkpoint file path");
+var PlanningQueryTypeSchema = z.enum(["backlog", "debt", "sprint", "task", "parking"]).describe("Query type must be: backlog, debt, sprint, task, or parking");
+var OutputFormatSchema = z.enum(["table", "json", "markdown", "yaml"]).describe("Output format must be: table, json, markdown, or yaml");
+var SchedulingOptionSchema = z.enum(["immediate", "current-sprint", "next-sprint", "backlog"]).describe("Scheduling option must be: immediate, current-sprint, next-sprint, or backlog");
+var AgentCountSchema = z.number().int("Agent count must be an integer").min(1, "At least one agent is required").max(10, "Maximum 10 agents allowed for safety");
+var BacklogAddInputSchema = z.object({
+  title: z.string().min(3, "Title must be at least 3 characters").max(200, "Title too long (max 200 characters)").transform((t) => t.trim()).refine((t) => t.length >= 3, "Title cannot be blank or whitespace-only"),
+  desc: z.string().max(5e3).optional(),
+  body: z.string().optional(),
+  bodyFile: z.string().optional(),
+  priority: PrioritySchema.optional(),
+  type: z.string().max(50).optional(),
+  workType: z.string().max(50).optional(),
+  tags: z.array(z.string().min(1).max(50)).max(20).optional(),
+  status: z.enum(["inbox", "reviewed"]).optional(),
+  complexity: z.number().min(0).max(1).optional(),
+  domain: DomainSchema.optional(),
+  expectedRuntime: ExpectedRuntimeMinutesSchema.optional(),
+  force: z.boolean().optional(),
+  sync: z.boolean().optional()
+});
+var BacklogOptionsSchema = z.object({
+  desc: z.string().optional(),
+  body: z.string().optional(),
+  // New: Full markdown body content
+  type: z.string().optional(),
+  // New: CLI --type option
+  tags: z.array(z.string()).optional(),
+  // New: CLI --tags option
+  complexity: ComplexitySchema.optional(),
+  domain: DomainSchema.optional(),
+  priority: PrioritySchema.optional(),
+  reason: z.string().max(500).optional(),
+  reconsider: DateSchema.optional(),
+  title: z.string().max(200).optional(),
+  status: BacklogStatusSchema.optional(),
+  // Updated: includes new statuses
+  approve: z.boolean().optional()
+}).strict();
+var TaskOptionsSchema = z.object({
+  sprint: SprintNameSchema.optional(),
+  priority: PrioritySchema.optional(),
+  status: TaskStatusSchema.optional(),
+  on: TaskIdSchema.optional(),
+  // for dependencies
+  force: z.boolean().optional(),
+  estimate: EstimatedHoursSchema.optional(),
+  expectedRuntime: ExpectedRuntimeMinutesSchema.optional(),
+  split: z.boolean().optional()
+}).strict();
+var SprintOptionsSchema = z.object({
+  name: SprintNameSchema.optional(),
+  start: DateSchema.optional(),
+  end: DateSchema.optional(),
+  goal: z.string().max(500).optional(),
+  hours: EstimatedHoursSchema.optional(),
+  current: z.boolean().optional(),
+  archived: z.boolean().optional(),
+  estimate: EstimatedHoursSchema.optional(),
+  priority: PrioritySchema.optional(),
+  split: z.boolean().optional()
+}).strict();
+var DebtOptionsSchema = z.object({
+  severity: SeveritySchema.optional(),
+  effort: EffortSchema.optional(),
+  impact: ImpactScoreSchema.optional(),
+  blocking: z.boolean().optional(),
+  parallelizable: z.boolean().optional(),
+  domain: DomainSchema.optional(),
+  executeBy: DateSchema.optional(),
+  targetDate: DateSchema.optional(),
+  rootCause: z.string().max(1e3).optional(),
+  hours: EstimatedHoursSchema.optional(),
+  expectedRuntime: ExpectedRuntimeMinutesSchema.optional(),
+  complexity: ComplexitySchema.optional(),
+  priority: z.boolean().optional(),
+  archived: z.boolean().optional()
+}).strict();
+var ParkingOptionsSchema = z.object({
+  reason: z.string().min(1).max(500),
+  reviewDate: DateSchema.optional(),
+  backlogId: TaskIdSchema.optional(),
+  complexity: ComplexitySchema.optional(),
+  hours: EstimatedHoursSchema.optional(),
+  current: z.boolean().optional(),
+  archived: z.boolean().optional(),
+  overdueReview: z.boolean().optional()
+}).strict();
+var PlanningOptionsSchema = z.object({
+  path: CheckpointPathSchema.optional(),
+  fix: z.boolean().optional(),
+  staged: z.boolean().optional(),
+  regenerate: z.boolean().optional(),
+  type: PlanningQueryTypeSchema.optional(),
+  status: z.string().optional(),
+  priority: PrioritySchema.optional(),
+  severity: SeveritySchema.optional(),
+  format: OutputFormatSchema.optional(),
+  json: z.boolean().optional()
+}).strict();
+var MonitorOptionsSchema = z.object({
+  json: z.boolean().optional(),
+  follow: z.boolean().optional(),
+  interval: z.number().min(1).max(300).optional(),
+  detailed: z.boolean().optional()
+}).strict();
+var PlanningCheckpointOptionsSchema = z.object({
+  agents: AgentCountSchema.optional(),
+  output: z.string().optional(),
+  resume: CheckpointResumePathSchema.optional()
+}).strict();
+
+export {
+  TaskIdSchema,
+  SprintNameSchema,
+  PrioritySchema,
+  EstimatedHoursSchema,
+  ExpectedRuntimeMinutesSchema,
+  DateSchema,
+  SafeTaskDescriptionSchema,
+  CheckpointResumePathSchema,
+  BacklogAddInputSchema,
+  BacklogOptionsSchema,
+  DebtOptionsSchema,
+  PlanningOptionsSchema,
+  PlanningCheckpointOptionsSchema
+};
+//# sourceMappingURL=chunk-AISTV5XU.js.map

package/dist/chunk-AJBTKGJZ.js

@@ -0,0 +1,48 @@
+import {
+  checkStorageAvailability,
+  resolvePlanningContextForRoot
+} from "./chunk-BBPIILO2.js";
+
+// src/planning/storage/reader-availability.ts
+var PlanningStorageUnavailableError = class extends Error {
+  reason;
+  constructor(reason) {
+    super(`Planning storage is unavailable: ${reason}`);
+    this.name = "PlanningStorageUnavailableError";
+    this.reason = reason;
+  }
+};
+function planningReadOk(value) {
+  return { kind: "ok", value };
+}
+function isPlanningStorageUnavailable(result) {
+  return result.kind === "unavailable";
+}
+function checkSharedBucketReadability(ctx) {
+  const availability = checkStorageAvailability(ctx);
+  return availability.available ? null : { kind: "unavailable", reason: availability.reason };
+}
+function assertSharedBucketsReadable(ctx) {
+  const unavailable = checkSharedBucketReadability(ctx);
+  if (unavailable) {
+    throw new PlanningStorageUnavailableError(unavailable.reason);
+  }
+}
+function assertBucketWriteAvailable(planningRoot) {
+  assertSharedBucketsReadable(resolvePlanningContextForRoot(planningRoot));
+}
+function unwrapPlanningRead(result) {
+  if (isPlanningStorageUnavailable(result)) {
+    throw new PlanningStorageUnavailableError(result.reason);
+  }
+  return result.value;
+}
+
+export {
+  planningReadOk,
+  checkSharedBucketReadability,
+  assertSharedBucketsReadable,
+  assertBucketWriteAvailable,
+  unwrapPlanningRead
+};
+//# sourceMappingURL=chunk-AJBTKGJZ.js.map

package/dist/chunk-AJJNW7XT.js

@@ -0,0 +1,248 @@
+import {
+  TaskIdSchema
+} from "./chunk-AISTV5XU.js";
+import {
+  resolveOptionalGitHubRepositoryFromRemote
+} from "./chunk-BDPYFAB4.js";
+import {
+  findBacklogItem
+} from "./chunk-NKLPMBNV.js";
+import {
+  extractBacklogItemTrailerIds,
+  loadBacklogExecutionProvenance
+} from "./chunk-3WY5TU2O.js";
+import {
+  getBucketPathByKind
+} from "./chunk-V3KLVK7B.js";
+import {
+  atomicWriteJson
+} from "./chunk-RFDVSI4N.js";
+import {
+  resolveBuildRoot
+} from "./chunk-CHA2HDE5.js";
+import {
+  envWithoutAmbientGitRepository
+} from "./chunk-XDM65LBX.js";
+
+// src/planning/backlog-trailer-closeout.ts
+import { existsSync } from "fs";
+import { access, readFile } from "fs/promises";
+import path from "path";
+var REVERT_PATTERN = /This reverts commit ([0-9a-f]{7,40})/gi;
+function matchesRevertTarget(targets, oid) {
+  const full = oid?.toLowerCase();
+  return full !== void 0 && targets.some((target) => full.startsWith(target));
+}
+function analyzeTrailers(newestFirst) {
+  const revertTargets = [];
+  const entries = newestFirst.map((commit) => {
+    const message = `${commit.messageHeadline ?? ""}
+${commit.messageBody ?? ""}`;
+    const reverted = matchesRevertTarget(revertTargets, commit.oid);
+    const targets = [...message.matchAll(REVERT_PATTERN)].map((match) => match[1].toLowerCase());
+    if (!reverted) revertTargets.push(...targets);
+    const isRevert = targets.length > 0 && message.trimStart().startsWith('Revert "');
+    const ids = isRevert ? [] : extractBacklogItemTrailerIds(message);
+    return { commit, ids, reverted };
+  });
+  return { entries, revertTargets };
+}
+function isRevertedCommit(revertTargets, oid) {
+  return matchesRevertTarget(revertTargets, oid);
+}
+function collectTrailerItemIds(commits) {
+  const { entries } = analyzeTrailers([...commits].reverse());
+  const pick = (reverted) => entries.filter((entry) => entry.reverted === reverted).reverse().flatMap((entry) => entry.ids);
+  const declared = [...new Set(pick(false))];
+  return { declared, reverted: [...new Set(pick(true))].filter((id) => !declared.includes(id)) };
+}
+async function triageTrailerItems(projectRoot, itemIds, landing) {
+  const triage = { eligible: [], skipped: [] };
+  const backlogDir = getBucketPathByKind("backlog", projectRoot);
+  for (const itemId of itemIds) {
+    const skip = (reason) => triage.skipped.push({ itemId, reason });
+    if (!TaskIdSchema.safeParse(itemId).success) {
+      skip("not a valid backlog item id");
+      continue;
+    }
+    const item = await findBacklogItem(backlogDir, itemId);
+    if (!item) {
+      skip("unknown backlog item");
+      continue;
+    }
+    if (item.yaml.status === "archived" || item.yaml.status === "done" || item.filePath.replace(/\\/g, "/").includes("/archive/")) {
+      skip("already archived");
+      continue;
+    }
+    const record = await loadBacklogExecutionProvenance(projectRoot, itemId, {
+      cleanupTerminalLocks: false
+    });
+    const tracked = record?.prNumber;
+    if (tracked !== null && tracked !== void 0 && tracked !== landing.prNumber && !landing.batchMemberPrs?.includes(tracked)) {
+      skip(`execution provenance tracks PR #${tracked}`);
+      continue;
+    }
+    triage.eligible.push(itemId);
+  }
+  return triage;
+}
+function trailerReconcileBaselinePath(projectRoot) {
+  const root = path.resolve(projectRoot);
+  const sharedRoot = existsSync(path.join(root, ".git")) ? resolveBuildRoot(root) : root;
+  return path.join(sharedRoot, ".build-project", "state", "backlog-trailer-reconcile.json");
+}
+async function readTrailerReconcileBaseline(projectRoot) {
+  try {
+    const parsed = JSON.parse(await readFile(trailerReconcileBaselinePath(projectRoot), "utf8"));
+    const baseline = parsed.baseline;
+    return typeof baseline === "string" && /^[0-9a-f]{40}$/i.test(baseline) ? baseline : null;
+  } catch {
+    return null;
+  }
+}
+async function writeTrailerReconcileBaseline(projectRoot, baseline) {
+  await atomicWriteJson(
+    trailerReconcileBaselinePath(projectRoot),
+    { baseline, recordedAt: (/* @__PURE__ */ new Date()).toISOString() },
+    { pretty: true, ensureDir: true }
+  );
+}
+async function listLandedTrailerCandidates(runner, projectRoot, defaultBranch, baseline) {
+  const log = await runner(
+    "git",
+    [
+      "log",
+      `${baseline}..origin/${defaultBranch}`,
+      "--grep=Build-Backlog-Item:",
+      "--grep=This reverts commit",
+      "--format=%H%x1f%B%x1e"
+    ],
+    { cwd: projectRoot }
+  );
+  const backlogDir = getBucketPathByKind("backlog", projectRoot);
+  const commits = String(log.stdout).split("").map((entry) => entry.trim().split("")).filter(([oid]) => oid).map(([oid, body = ""]) => ({ oid, messageBody: body }));
+  const { entries, revertTargets } = analyzeTrailers(commits);
+  const seen = /* @__PURE__ */ new Map();
+  for (const { commit, ids, reverted } of entries) {
+    for (const itemId of ids) {
+      const prior = seen.get(itemId);
+      if (!prior || prior.reverted && !reverted) {
+        seen.set(itemId, { commit: commit.oid, reverted });
+      }
+    }
+  }
+  const candidates = [];
+  for (const [itemId, found] of seen) {
+    if (!TaskIdSchema.safeParse(itemId).success) continue;
+    const active = await access(path.join(backlogDir, `${itemId}.md`)).then(
+      () => true,
+      () => false
+    );
+    if (!active) continue;
+    if (await loadBacklogExecutionProvenance(projectRoot, itemId, { cleanupTerminalLocks: false })) {
+      continue;
+    }
+    candidates.push({ itemId, ...found });
+  }
+  candidates.sort((a, b) => a.itemId.localeCompare(b.itemId));
+  return { candidates, revertTargets };
+}
+
+// src/planning/backlog-finalize-evidence.ts
+async function fetchGitHubPrView(runner, projectRoot, prNumber) {
+  const repository = await resolveOptionalGitHubRepositoryFromRemote(projectRoot, "origin");
+  if (!repository) throw new Error("The receipt repository could not be established from origin.");
+  const prView = await runner(
+    "gh",
+    [
+      "pr",
+      "view",
+      String(prNumber),
+      "--repo",
+      `github.com/${repository}`,
+      "--json",
+      "state,mergedAt,mergeCommit,commits"
+    ],
+    { cwd: projectRoot, env: envWithoutAmbientGitRepository(process.env), extendEnv: false }
+  );
+  return JSON.parse(prView.stdout);
+}
+async function fetchMergedPrNumberForCommit(runner, projectRoot, commit, baseBranch) {
+  const repository = await resolveOptionalGitHubRepositoryFromRemote(projectRoot, "origin");
+  if (!repository) throw new Error("The receipt repository could not be established from origin.");
+  const pulls = await runner("gh", ["api", `repos/${repository}/commits/${commit}/pulls`], {
+    cwd: projectRoot,
+    env: envWithoutAmbientGitRepository(process.env),
+    extendEnv: false
+  });
+  const parsed = JSON.parse(String(pulls.stdout));
+  return parsed.find((pr) => pr.merged_at && pr.base?.ref === baseBranch)?.number ?? null;
+}
+async function collectAutoFinalizeMergeEvidence(runner, projectRoot, prNumber, mergeCommit, defaultBranch, backlogItemId, recordedLinkedPrs = []) {
+  const remoteDefault = `origin/${defaultBranch}`;
+  let validCommit = false;
+  let mergeCommitOnRemoteDefault = false;
+  let prMerged = false;
+  let mergeCommitMatchesPr = false;
+  let backlogItemMatchesPr = backlogItemId === void 0;
+  let resolvedMergeCommit = mergeCommit;
+  try {
+    const resolved = await runner("git", ["rev-parse", "--verify", `${mergeCommit}^{commit}`], {
+      cwd: projectRoot
+    });
+    resolvedMergeCommit = resolved.stdout.trim();
+    validCommit = true;
+  } catch {
+    return {
+      validCommit,
+      mergeCommitOnRemoteDefault,
+      prMerged,
+      mergeCommitMatchesPr,
+      backlogItemMatchesPr
+    };
+  }
+  try {
+    await runner("git", ["merge-base", "--is-ancestor", resolvedMergeCommit, remoteDefault], {
+      cwd: projectRoot
+    });
+    mergeCommitOnRemoteDefault = true;
+  } catch {
+  }
+  try {
+    const parsed = await fetchGitHubPrView(runner, projectRoot, prNumber);
+    prMerged = parsed.state === "MERGED" || Boolean(parsed.mergedAt);
+    const prMergeCommit = parsed.mergeCommit?.oid;
+    if (prMergeCommit) {
+      mergeCommitMatchesPr = prMergeCommit.toLowerCase() === resolvedMergeCommit.toLowerCase();
+    } else {
+      mergeCommitMatchesPr = prMerged;
+    }
+    if (backlogItemId !== void 0) {
+      const recordedLinkMatchesPr = recordedLinkedPrs.some(
+        (linked) => linked !== null && linked !== void 0 && Number(linked) === prNumber
+      );
+      backlogItemMatchesPr = recordedLinkMatchesPr || collectTrailerItemIds(parsed.commits ?? []).declared.includes(backlogItemId);
+    }
+  } catch {
+  }
+  return {
+    validCommit,
+    mergeCommitOnRemoteDefault,
+    prMerged,
+    mergeCommitMatchesPr,
+    backlogItemMatchesPr
+  };
+}
+
+export {
+  isRevertedCommit,
+  collectTrailerItemIds,
+  triageTrailerItems,
+  readTrailerReconcileBaseline,
+  writeTrailerReconcileBaseline,
+  listLandedTrailerCandidates,
+  fetchGitHubPrView,
+  fetchMergedPrNumberForCommit,
+  collectAutoFinalizeMergeEvidence
+};
+//# sourceMappingURL=chunk-AJJNW7XT.js.map

package/dist/chunk-AJN5Y5YZ.js

@@ -0,0 +1,160 @@
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  projectBuildDirAliasesUserHome,
+  projectConfigAliasesUserConfig
+} from "./chunk-35J4NE6S.js";
+import {
+  getProjectDataDir,
+  getStableRepoIdentity
+} from "./chunk-56WPYDJH.js";
+import {
+  BUILD_TEST_ISOLATED_HOME,
+  emitWarning,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/config/project-runtime-paths.ts
+import fs from "fs";
+import path from "path";
+function repoRootFromBuildDir(buildDir) {
+  const resolved = path.resolve(buildDir);
+  return path.basename(resolved) === ".build-project" ? path.dirname(resolved) : resolved;
+}
+function resolveCheckoutRoot(buildDir) {
+  const root = repoRootFromBuildDir(buildDir);
+  try {
+    return fs.realpathSync(root);
+  } catch {
+    return root;
+  }
+}
+function getRepoDataMigrationMarkerPath(buildDir) {
+  return path.join(
+    repoRootFromBuildDir(buildDir),
+    ".build-project",
+    "state",
+    "data-migration.json"
+  );
+}
+function getSharedDataMigrationMarkerPath(buildDir) {
+  const repoRoot = repoRootFromBuildDir(buildDir);
+  return path.join(getProjectDataDir(repoRoot), "state", "data-migration.json");
+}
+function readMarker(markerPath) {
+  try {
+    const parsed = JSON.parse(
+      fs.readFileSync(markerPath, "utf8")
+    );
+    if (parsed.version === 1 && typeof parsed.migratedAt === "string" && typeof parsed.repoRoot === "string" && typeof parsed.projectId === "string" && typeof parsed.globalTelemetryDir === "string" && typeof parsed.projectDataDir === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function isSameDirectory(left, right) {
+  const resolvedLeft = path.resolve(left);
+  const resolvedRight = path.resolve(right);
+  if (resolvedLeft === resolvedRight) return true;
+  try {
+    return fs.realpathSync(resolvedLeft) === fs.realpathSync(resolvedRight);
+  } catch {
+    return false;
+  }
+}
+function readProjectDataMigrationMarker(buildDir) {
+  const repoRoot = repoRootFromBuildDir(buildDir);
+  const expectedProjectId = getStableRepoIdentity(repoRoot);
+  const expectedProjectDataDir = path.resolve(getProjectDataDir(repoRoot));
+  const shared = readMarker(getSharedDataMigrationMarkerPath(buildDir));
+  if (shared?.projectId === expectedProjectId && isSameDirectory(shared.projectDataDir, expectedProjectDataDir)) {
+    return shared;
+  }
+  const local = readMarker(getRepoDataMigrationMarkerPath(buildDir));
+  if (local?.projectId === expectedProjectId && isSameDirectory(local.projectDataDir, expectedProjectDataDir)) {
+    return local;
+  }
+  return null;
+}
+async function assertDataMigrationAtWorkTreeTopLevel(buildDir) {
+  const repoRoot = repoRootFromBuildDir(buildDir);
+  if (projectConfigAliasesUserConfig(repoRoot) || projectBuildDirAliasesUserHome(repoRoot)) {
+    throw new Error(
+      "Refusing project data migration in your user Build home. Choose a separate project directory."
+    );
+  }
+  if (!fs.existsSync(repoRoot)) return;
+  const result = await execGit(["rev-parse", "--path-format=absolute", "--show-toplevel"], {
+    cwd: repoRoot
+  });
+  const topLevel = result.exitCode === 0 ? result.stdout.trim() : "";
+  if (topLevel && !isSameDirectory(topLevel, repoRoot)) {
+    throw new Error(
+      `Refusing data migration for ${repoRoot}: it is not the git work-tree top level (${topLevel}). Run from ${topLevel}.`
+    );
+  }
+}
+function readStaleDataMigrationMarker(buildDir) {
+  if (readProjectDataMigrationMarker(buildDir)) return null;
+  return readMarker(getSharedDataMigrationMarkerPath(buildDir)) ?? readMarker(getRepoDataMigrationMarkerPath(buildDir));
+}
+var warnedStaleMarkers = /* @__PURE__ */ new Set();
+function warnStaleMarkerOnce(buildDir) {
+  const repoRoot = repoRootFromBuildDir(buildDir);
+  if (warnedStaleMarkers.has(repoRoot)) return;
+  const stale = readMarker(getSharedDataMigrationMarkerPath(buildDir)) ?? readMarker(getRepoDataMigrationMarkerPath(buildDir));
+  if (!stale) return;
+  const underTestHarness = Boolean(readEnv(BUILD_TEST_ISOLATED_HOME).value);
+  warnedStaleMarkers.add(repoRoot);
+  emitWarning(
+    "CFG-001",
+    { taskId: "project-runtime-paths", subsystem: "config", executionPhase: "setup" },
+    {
+      severity: "WARN" /* WARN */,
+      message: `Data migration marker records ${stale.projectDataDir}, but this environment expects ${getProjectDataDir(repoRoot)}; using ${path.join(repoRoot, ".build-project")} for runtime state.`,
+      metadata: { operation: "resolveProjectRuntimeDir", recordedDir: stale.projectDataDir },
+      skipConsole: underTestHarness
+    }
+  );
+}
+function resolveProjectRuntimeDir(buildDir, category) {
+  const marker = readProjectDataMigrationMarker(buildDir);
+  if (marker) return path.join(marker.projectDataDir, category);
+  warnStaleMarkerOnce(buildDir);
+  return path.join(repoRootFromBuildDir(buildDir), ".build-project", category);
+}
+function resolveLabsRoot(buildDir) {
+  return path.basename(path.resolve(buildDir)) === ".build-project" ? resolveProjectRuntimeDir(buildDir, "labs") : path.join(buildDir, "labs");
+}
+function resolveRunStateDir(buildDir) {
+  return path.basename(path.resolve(buildDir)) === ".build-project" ? path.join(getProjectDataDir(repoRootFromBuildDir(buildDir)), "telemetry", "state") : path.join(buildDir, "telemetry", "state");
+}
+function resolveRunStateReadDirs(buildDir) {
+  const current = resolveRunStateDir(buildDir);
+  const legacy = path.join(buildDir, "telemetry", "state");
+  return legacy !== current && fs.existsSync(legacy) ? [current, legacy] : [current];
+}
+function readDirsForStateRoot(buildDir, stateRoot) {
+  return stateRoot === resolveRunStateDir(buildDir) ? resolveRunStateReadDirs(buildDir) : [stateRoot];
+}
+function firstDirWithFile(dirs, fileName) {
+  return dirs.find((dir) => fs.existsSync(path.join(dir, fileName))) ?? dirs[0] ?? "";
+}
+
+export {
+  resolveCheckoutRoot,
+  getRepoDataMigrationMarkerPath,
+  getSharedDataMigrationMarkerPath,
+  readProjectDataMigrationMarker,
+  assertDataMigrationAtWorkTreeTopLevel,
+  readStaleDataMigrationMarker,
+  resolveProjectRuntimeDir,
+  resolveLabsRoot,
+  resolveRunStateDir,
+  resolveRunStateReadDirs,
+  readDirsForStateRoot,
+  firstDirWithFile
+};
+//# sourceMappingURL=chunk-AJN5Y5YZ.js.map