@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-VAG6GUBR.js

@@ -0,0 +1,1162 @@
+import {
+  normalizeRef
+} from "./chunk-P5P2EKGH.js";
+import {
+  assertSharedBucketsReadable
+} from "./chunk-AJBTKGJZ.js";
+import {
+  getBucketArchivePath,
+  getBucketArchivePathByKind,
+  getBucketPath,
+  getBucketPathByKind,
+  getBuckets,
+  listEnabledBuckets
+} from "./chunk-V3KLVK7B.js";
+import {
+  resolvePlanningContextForRoot
+} from "./chunk-BBPIILO2.js";
+import {
+  isSafeGitRef,
+  isSafeGitRemote
+} from "./chunk-D2M2Y5ID.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  parsePorcelainLinePaths
+} from "./chunk-5KQETTNS.js";
+import {
+  ensureDirectoryExists,
+  listMarkdownFiles,
+  listMarkdownFilesRecursive,
+  readMarkdownFile
+} from "./chunk-352PCJLK.js";
+import {
+  SHARED_BUCKET_NAMES,
+  emitCustomWarning,
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+
+// src/planning/indexer.ts
+import { execSync } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { readFileSync } from "fs";
+import * as fs from "fs/promises";
+import * as path3 from "path";
+
+// src/planning/index-front-matter.ts
+function createMemoizedFrontMatterReader() {
+  const reads = /* @__PURE__ */ new Map();
+  return (file) => {
+    let read = reads.get(file);
+    if (!read) {
+      read = readMarkdownFile(file).then(({ frontMatter }) => frontMatter);
+      reads.set(file, read);
+    }
+    return read;
+  };
+}
+
+// src/planning/storage/index-fingerprint.ts
+import { createHash } from "crypto";
+import * as path2 from "path";
+
+// src/planning/storage/bucket-scope.ts
+import { realpathSync } from "fs";
+import * as path from "path";
+var SHARED_BUCKETS = new Set(SHARED_BUCKET_NAMES);
+function isSharedBucketName(name) {
+  return SHARED_BUCKETS.has(name);
+}
+function bucketRootForKind(ctx, kind) {
+  return isSharedBucketName(kind) ? ctx.storageRoot : ctx.projectRoot;
+}
+function findBucketConfig(ctx, kind) {
+  const normalized = kind.toLowerCase().trim();
+  return getBuckets(ctx.projectRoot).find((bucket) => bucket.name === normalized);
+}
+function bucketArchiveRootForContext(ctx, kind) {
+  const bucket = findBucketConfig(ctx, kind);
+  if (!bucket) {
+    throw new Error(`Unknown bucket kind: ${kind}`);
+  }
+  return getBucketArchivePath(bucket, bucketRootForKind(ctx, kind));
+}
+function bucketArchiveRootUnderBucket(ctx, kind, bucketDir) {
+  const bucket = findBucketConfig(ctx, kind);
+  return bucket ? getBucketArchivePath(bucket, bucketRootForKind(ctx, kind)) : path.join(bucketDir, "archive");
+}
+function bucketArchiveRootForProjectRoot(projectRoot, kind, bucketDir) {
+  return bucketArchiveRootUnderBucket(resolvePlanningContextForRoot(projectRoot), kind, bucketDir);
+}
+function groupFor(buckets, root) {
+  let canonicalRoot;
+  try {
+    canonicalRoot = realpathSync.native(root);
+  } catch {
+    return null;
+  }
+  const relativePaths = /* @__PURE__ */ new Set();
+  for (const bucket of buckets) {
+    for (const absolute of [
+      getBucketPath(bucket, canonicalRoot),
+      getBucketArchivePath(bucket, canonicalRoot)
+    ]) {
+      const relative3 = path.relative(canonicalRoot, absolute).replace(/\\/g, "/");
+      if (relative3.length > 0 && !relative3.startsWith("..")) {
+        relativePaths.add(relative3);
+      }
+    }
+  }
+  return { root: canonicalRoot, relativePaths: Array.from(relativePaths).sort() };
+}
+function sharedBucketPathspecs(ctx) {
+  const buckets = getBuckets(ctx.projectRoot).filter((bucket) => isSharedBucketName(bucket.name));
+  return groupFor(buckets, ctx.storageRoot);
+}
+function localBucketPathspecs(ctx) {
+  const buckets = getBuckets(ctx.projectRoot).filter((bucket) => !isSharedBucketName(bucket.name));
+  return groupFor(buckets, ctx.projectRoot);
+}
+
+// src/planning/storage/index-fingerprint.ts
+var CLEAN_PLANNING_TREE_SIGNATURE = "clean";
+function computeBucketLayoutSignature(ctx) {
+  let buckets;
+  try {
+    buckets = getBuckets(ctx.projectRoot);
+  } catch {
+    return null;
+  }
+  const rows = buckets.map(
+    (bucket) => [bucket.name, bucket.path, bucket.archivePath, bucket.archivePublished, bucket.shared].join(
+      "	"
+    )
+  ).sort();
+  return createHash("sha256").update(
+    [
+      `backend:${ctx.backend}`,
+      `branch:${ctx.branch ?? ""}`,
+      `worktree:${ctx.worktree ?? ""}`,
+      ...rows
+    ].join("\n")
+  ).digest("hex");
+}
+function shellQuotePathspec(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function parseDirtyStatusPaths(normalizedStatus) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const line of normalizedStatus.split("\n")) {
+    for (const normalizedPath of parsePorcelainLinePaths(line)) {
+      if (normalizedPath.length > 0 && !path2.isAbsolute(normalizedPath) && !normalizedPath.split("/").includes("..")) {
+        paths.add(normalizedPath);
+      }
+    }
+  }
+  return Array.from(paths).sort();
+}
+function computeGroupDirtySignature(group, probes) {
+  if (group === null) {
+    return null;
+  }
+  if (group.relativePaths.length === 0) {
+    return CLEAN_PLANNING_TREE_SIGNATURE;
+  }
+  const output = probes.status(group.root, group.relativePaths);
+  if (output === null) {
+    return null;
+  }
+  const normalizedStatus = output.split(/\r?\n/u).map((line) => line.trimEnd()).filter((line) => line.length > 0).sort().join("\n");
+  if (normalizedStatus.length === 0) {
+    return CLEAN_PLANNING_TREE_SIGNATURE;
+  }
+  const dirtyFileHashes = parseDirtyStatusPaths(normalizedStatus).map(
+    (dirtyPath) => `${dirtyPath}:${probes.hashFile(group.root, dirtyPath)}`
+  );
+  return createHash("sha256").update([normalizedStatus, ...dirtyFileHashes].join("\n")).digest("hex");
+}
+function composePlanningDirtySignature(shared, local, extra = []) {
+  if (shared === null || local === null) {
+    return null;
+  }
+  if (extra.length === 0 && shared === CLEAN_PLANNING_TREE_SIGNATURE && local === CLEAN_PLANNING_TREE_SIGNATURE) {
+    return CLEAN_PLANNING_TREE_SIGNATURE;
+  }
+  return createHash("sha256").update([`shared:${shared}`, `local:${local}`, ...extra].join("\n")).digest("hex");
+}
+function computePlanningDirtySignature(ctx, probes) {
+  let shared;
+  let local;
+  const extra = [];
+  try {
+    shared = computeGroupDirtySignature(sharedBucketPathspecs(ctx), probes);
+    local = computeGroupDirtySignature(localBucketPathspecs(ctx), probes);
+    if (ctx.backend === "git-branch") {
+      const layout = computeBucketLayoutSignature(ctx);
+      const codeRevision = probes.headRevision?.(ctx.projectRoot) ?? null;
+      if (layout === null || codeRevision === null) return null;
+      extra.push(`layout:${layout}`, `codeRevision:${codeRevision}`);
+    }
+  } catch {
+    return null;
+  }
+  return composePlanningDirtySignature(shared, local, extra);
+}
+function isPlanningIndexStale(inputs) {
+  if (!inputs.currentRevision) {
+    return false;
+  }
+  if (typeof inputs.indexRevision !== "string" || inputs.indexRevision.length === 0) {
+    return true;
+  }
+  if (inputs.currentRevision !== inputs.indexRevision) {
+    return true;
+  }
+  if (inputs.currentDirtySignature === null || inputs.currentDirtySignature === void 0) {
+    return true;
+  }
+  if (typeof inputs.indexDirtySignature !== "string") {
+    return inputs.currentDirtySignature !== CLEAN_PLANNING_TREE_SIGNATURE;
+  }
+  return inputs.currentDirtySignature !== inputs.indexDirtySignature;
+}
+
+// src/planning/indexer.ts
+var GIT_TERMINAL_PROMPT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
+var DEFAULT_GIT_TIMEOUT_MS = 5e3;
+var warnedStaleIndexes = /* @__PURE__ */ new Set();
+function coerceIndexNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return void 0;
+}
+function staleIndexWarningKey(indexName, index) {
+  const metadata = index;
+  return `${indexName}:${index.lastGitSha ?? "unknown"}:${metadata.planningDirtySignature ?? "unknown"}`;
+}
+async function writeIndexJson(indexFile, data) {
+  const content = JSON.stringify(data, null, 2);
+  const tempFile = path3.join(
+    path3.dirname(indexFile),
+    `.${path3.basename(indexFile)}.${process.pid}.${Date.now()}.tmp`
+  );
+  await fs.writeFile(tempFile, content, "utf8");
+  await fs.rename(tempFile, indexFile);
+}
+function hashDirtyPlanningFile(rootDir, dirtyPath) {
+  try {
+    const content = readFileSync(path3.join(rootDir, dirtyPath));
+    return createHash2("sha256").update(content).digest("hex");
+  } catch {
+    return "missing";
+  }
+}
+function indexMetadata(gitSha, planningDirtySignature) {
+  return {
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    lastGitSha: gitSha,
+    ...planningDirtySignature !== null && planningDirtySignature !== void 0 ? { planningDirtySignature } : {}
+  };
+}
+async function getGitHeadSha(rootDir) {
+  return getGitHeadShaSync(rootDir);
+}
+function getGitHeadShaSync(rootDir) {
+  try {
+    const sha = execSync("git rev-parse HEAD", {
+      cwd: rootDir,
+      encoding: "utf8",
+      timeout: DEFAULT_GIT_TIMEOUT_MS,
+      env: GIT_TERMINAL_PROMPT_ENV,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return sha || null;
+  } catch {
+    return null;
+  }
+}
+async function getStorageRevision(rootDir) {
+  return getStorageRevisionSync(rootDir);
+}
+function getStorageRevisionSync(rootDir) {
+  return getGitHeadShaSync(resolvePlanningContextForRoot(rootDir).storageRoot);
+}
+function runPlanningStatusSync(root, relativePaths) {
+  try {
+    return execSync(
+      `git status --porcelain=v1 --untracked-files=all -- ${relativePaths.map(shellQuotePathspec).join(" ")}`,
+      {
+        cwd: root,
+        encoding: "utf8",
+        timeout: DEFAULT_GIT_TIMEOUT_MS,
+        env: GIT_TERMINAL_PROMPT_ENV,
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    );
+  } catch {
+    return null;
+  }
+}
+async function getPlanningDirtySignature(rootDir) {
+  return getPlanningDirtySignatureSync(rootDir);
+}
+function getPlanningDirtySignatureSync(rootDir) {
+  return computePlanningDirtySignature(resolvePlanningContextForRoot(rootDir), {
+    status: runPlanningStatusSync,
+    hashFile: hashDirtyPlanningFile,
+    headRevision: getGitHeadShaSync
+  });
+}
+async function checkGitDrift(rootDir, options = {}) {
+  try {
+    const remote = options.remote ?? "origin";
+    const branch = options.branch ?? "main";
+    const timeoutMs = options.timeoutMs ?? DEFAULT_GIT_TIMEOUT_MS;
+    if (!isSafeGitRemote(remote) || !isSafeGitRef(branch)) {
+      return null;
+    }
+    if (options.fetch) {
+      try {
+        execSync(`git fetch --quiet --no-tags ${remote} ${branch}`, {
+          cwd: rootDir,
+          stdio: "ignore",
+          timeout: timeoutMs,
+          env: GIT_TERMINAL_PROMPT_ENV
+        });
+      } catch {
+      }
+    }
+    const output = execSync(`git rev-list --left-right --count HEAD...${remote}/${branch}`, {
+      cwd: rootDir,
+      encoding: "utf8",
+      timeout: timeoutMs,
+      env: GIT_TERMINAL_PROMPT_ENV,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const [aheadStr, behindStr] = output.split(/\s+/);
+    const ahead = Number.parseInt(aheadStr || "0", 10);
+    const behind = Number.parseInt(behindStr || "0", 10);
+    return { ahead, behind };
+  } catch {
+    return null;
+  }
+}
+async function generateIndexes(rootDir) {
+  assertSharedBucketsReadable(resolvePlanningContextForRoot(rootDir));
+  const indexDir = path3.join(rootDir, ".build-project", "planning", "indexes");
+  await ensureDirectoryExists(indexDir);
+  const gitSha = await getStorageRevision(rootDir) ?? void 0;
+  const planningDirtySignature = await getPlanningDirtySignature(rootDir);
+  const read = createMemoizedFrontMatterReader();
+  await generateRefAliasIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+  await generateBacklogByStatusIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+  await generateBacklogByPriorityIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+  await generateDebtBySeverityIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+  await generateTasksBySprintIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+  await generateBlockersIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+  await generateParkingOverdueIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+  await generateFindingsByStatusIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+  await generateFindingsByFingerprintIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+  await generateIssuesByStatusIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+  await generateIssuesBySeverityIndex(rootDir, indexDir, read, gitSha, planningDirtySignature);
+}
+async function generateRefAliasIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  const refs = {};
+  const aliases = {};
+  const collisions = [];
+  for (const bucket of listEnabledBuckets(rootDir)) {
+    const dirs = [
+      { dir: getBucketPathByKind(bucket.name, rootDir), isArchive: false },
+      { dir: getBucketArchivePathByKind(bucket.name, rootDir), isArchive: true }
+    ];
+    for (const { dir, isArchive } of dirs) {
+      const files = isArchive ? await listMarkdownFilesRecursive(dir) : await listMarkdownFiles(dir);
+      for (const file of files) {
+        if (path3.basename(file).toLowerCase() === "readme.md") {
+          continue;
+        }
+        try {
+          const frontMatter = await read(file);
+          const entry = {
+            id: frontMatter.id,
+            title: frontMatter.title,
+            status: frontMatter.status,
+            filePath: file,
+            priority: frontMatter.priority
+          };
+          if (entry.id) {
+            const normalizedId = normalizeRef(entry.id);
+            if (!refs[normalizedId]) {
+              refs[normalizedId] = entry;
+            }
+            if (!aliases[normalizedId]) {
+              aliases[normalizedId] = entry;
+            }
+          }
+          const ref = frontMatter.ref;
+          if (ref) {
+            const normalized = normalizeRef(ref);
+            const existing = refs[normalized];
+            if (existing && existing.id !== entry.id) {
+              collisions.push({ key: ref, items: [existing.id, entry.id] });
+            } else {
+              refs[normalized] = entry;
+            }
+          }
+          const aliasArray = frontMatter.aliases;
+          if (Array.isArray(aliasArray)) {
+            for (const alias of aliasArray) {
+              if (!alias) continue;
+              const normalized = normalizeRef(alias);
+              const existing = aliases[normalized];
+              if (existing && existing.id !== entry.id) {
+                collisions.push({ key: alias, items: [existing.id, entry.id] });
+              } else {
+                aliases[normalized] = entry;
+              }
+            }
+          }
+        } catch (error) {
+          emitWarning(
+            "CFG-002",
+            {
+              taskId: "indexer",
+              subsystem: "planning",
+              executionPhase: "execution"
+            },
+            {
+              severity: "INFO" /* INFO */,
+              metadata: {
+                error: error instanceof Error ? error.message : String(error),
+                file: path3.relative(rootDir, file),
+                operation: "generate-ref-alias-index"
+              }
+            }
+          );
+        }
+      }
+    }
+  }
+  if (collisions.length > 0) {
+    for (const collision of collisions) {
+      emitWarning(
+        "CFG-002",
+        {
+          taskId: "indexer",
+          subsystem: "planning",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            message: `Ref/alias collision detected: "${collision.key}"`,
+            conflictingItems: collision.items,
+            operation: "generate-ref-alias-index"
+          }
+        }
+      );
+    }
+  }
+  const indexFile = path3.join(indexDir, "ref-alias.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    refs,
+    aliases
+  });
+}
+async function generateBacklogByStatusIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  const backlogDirs = [
+    getBucketPathByKind("backlog", rootDir),
+    getBucketArchivePathByKind("backlog", rootDir)
+  ];
+  const index = {
+    inbox: [],
+    reviewed: [],
+    done: [],
+    archived: []
+  };
+  for (const dir of backlogDirs) {
+    const isArchive = dir === backlogDirs[1];
+    const files = isArchive ? await listMarkdownFilesRecursive(dir) : await listMarkdownFiles(dir);
+    for (const file of files) {
+      if (path3.basename(file).toLowerCase() === "readme.md") {
+        continue;
+      }
+      try {
+        const frontMatter = await read(file);
+        const rawStatus = frontMatter.status || "unknown";
+        const status = rawStatus === "parked" ? "done" : rawStatus;
+        const entry = {
+          id: frontMatter.id,
+          title: frontMatter.title,
+          status,
+          priority: frontMatter.priority,
+          estimatedComplexity: frontMatter.estimatedComplexity,
+          domain: frontMatter.domain,
+          // Declared terminology is OPAQUE: indexed VERBATIM, never normalized.
+          declaredType: frontMatter.declaredType,
+          resolvedTaskTypeId: frontMatter.resolvedTaskTypeId,
+          filePath: path3.relative(rootDir, file)
+        };
+        const statusKey = status;
+        const bucketEntries = index[statusKey];
+        if (bucketEntries) bucketEntries.push(entry);
+      } catch (error) {
+        emitWarning(
+          "WS-003",
+          {
+            taskId: "planning-indexer",
+            subsystem: "planning",
+            executionPhase: "execution"
+          },
+          {
+            severity: "ERROR" /* ERROR */,
+            metadata: {
+              error: error instanceof Error ? error.message : String(error),
+              file: path3.relative(rootDir, file),
+              operation: "parse-backlog-by-status"
+            }
+          }
+        );
+      }
+    }
+  }
+  const indexFile = path3.join(indexDir, "backlog-by-status.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateBacklogByPriorityIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  const backlogDirs = [
+    getBucketPathByKind("backlog", rootDir),
+    getBucketArchivePathByKind("backlog", rootDir)
+  ];
+  const files = (await Promise.all(
+    backlogDirs.map(async (dir) => {
+      const isArchive = dir === backlogDirs[1];
+      return isArchive ? await listMarkdownFilesRecursive(dir) : await listMarkdownFiles(dir);
+    })
+  )).flat();
+  const index = {
+    P0: [],
+    P1: [],
+    P2: [],
+    P3: []
+  };
+  for (const file of files) {
+    if (path3.basename(file).toLowerCase() === "readme.md") {
+      continue;
+    }
+    try {
+      const frontMatter = await read(file);
+      const priority = frontMatter.priority || "P3";
+      const entry = {
+        id: frontMatter.id,
+        title: frontMatter.title,
+        status: frontMatter.status,
+        priority,
+        estimatedComplexity: coerceIndexNumber(frontMatter.estimatedComplexity),
+        estimatedHours: coerceIndexNumber(frontMatter.estimatedHours),
+        expectedRuntimeMinutes: coerceIndexNumber(frontMatter.expectedRuntimeMinutes),
+        filePath: path3.relative(rootDir, file)
+      };
+      const priorityKey = priority;
+      const bucketEntries = index[priorityKey];
+      if (bucketEntries) bucketEntries.push(entry);
+    } catch (error) {
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "planning-indexer",
+          subsystem: "planning",
+          executionPhase: "execution"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            file: path3.relative(rootDir, file),
+            operation: "parse-backlog-by-priority"
+          }
+        }
+      );
+    }
+  }
+  const indexFile = path3.join(indexDir, "backlog-by-priority.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateDebtBySeverityIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  const debtDir = getBucketPathByKind("tech-debt", rootDir);
+  const files = await listMarkdownFiles(debtDir);
+  const index = {
+    critical: [],
+    high: [],
+    medium: [],
+    low: []
+  };
+  for (const file of files) {
+    if (path3.basename(file).toLowerCase() === "readme.md") {
+      continue;
+    }
+    try {
+      const frontMatter = await read(file);
+      const severity = frontMatter.severity || "low";
+      const entry = {
+        id: frontMatter.id,
+        title: frontMatter.title,
+        status: frontMatter.status,
+        severity,
+        effort: frontMatter.effort,
+        blocking: frontMatter.blocking,
+        estimatedComplexity: coerceIndexNumber(frontMatter.estimatedComplexity),
+        estimatedHours: coerceIndexNumber(frontMatter.estimatedHours),
+        expectedRuntimeMinutes: coerceIndexNumber(frontMatter.expectedRuntimeMinutes),
+        filePath: path3.relative(rootDir, file)
+      };
+      const severityKey = severity;
+      const bucketEntries = index[severityKey];
+      if (bucketEntries) bucketEntries.push(entry);
+    } catch (error) {
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "planning-indexer",
+          subsystem: "planning",
+          executionPhase: "execution"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            file: path3.relative(rootDir, file),
+            operation: "parse-debt-by-severity"
+          }
+        }
+      );
+    }
+  }
+  const indexFile = path3.join(indexDir, "debt-by-severity.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateTasksBySprintIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  const tasksDir = getBucketPathByKind("task", rootDir);
+  const files = await listMarkdownFilesRecursive(tasksDir);
+  const index = {};
+  for (const file of files) {
+    if (path3.basename(file).toLowerCase() === "readme.md") {
+      continue;
+    }
+    try {
+      const frontMatter = await read(file);
+      const sprintId = frontMatter.sprintId || frontMatter.originalSprintId || "unassigned";
+      const entry = {
+        id: frontMatter.id,
+        title: frontMatter.title,
+        status: frontMatter.status,
+        priority: frontMatter.priority,
+        complexity: coerceIndexNumber(frontMatter.complexity),
+        estimatedHours: coerceIndexNumber(frontMatter.estimatedHours),
+        expectedRuntimeMinutes: coerceIndexNumber(frontMatter.expectedRuntimeMinutes),
+        dependencies: frontMatter.dependencies,
+        filePath: path3.relative(rootDir, file)
+      };
+      let sprintEntries = index[sprintId];
+      if (!sprintEntries) {
+        sprintEntries = [];
+        index[sprintId] = sprintEntries;
+      }
+      sprintEntries.push(entry);
+    } catch (error) {
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "planning-indexer",
+          subsystem: "planning",
+          executionPhase: "execution"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            file: path3.relative(rootDir, file),
+            operation: "parse-tasks-by-sprint"
+          }
+        }
+      );
+    }
+  }
+  const indexFile = path3.join(indexDir, "tasks-by-sprint.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateBlockersIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  const dirs = [getBucketPathByKind("task", rootDir), getBucketPathByKind("tech-debt", rootDir)];
+  const entries = [];
+  for (const dir of dirs) {
+    const files = await listMarkdownFiles(dir);
+    for (const file of files) {
+      if (path3.basename(file).toLowerCase() === "readme.md") {
+        continue;
+      }
+      try {
+        const frontMatter = await read(file);
+        const hasBlockers = frontMatter.blockers && Array.isArray(frontMatter.blockers) && frontMatter.blockers.length > 0 || frontMatter.status === "blocked";
+        if (hasBlockers) {
+          const entry = {
+            id: frontMatter.id,
+            title: frontMatter.title,
+            status: frontMatter.status,
+            blockers: frontMatter.blockers || [],
+            blockingReason: frontMatter.blockingReason,
+            filePath: path3.relative(rootDir, file)
+          };
+          entries.push(entry);
+        }
+      } catch (error) {
+        emitWarning(
+          "WS-003",
+          {
+            taskId: "planning-indexer",
+            subsystem: "planning",
+            executionPhase: "execution"
+          },
+          {
+            severity: "ERROR" /* ERROR */,
+            metadata: {
+              error: error instanceof Error ? error.message : String(error),
+              file: path3.relative(rootDir, file),
+              operation: "parse-blockers"
+            }
+          }
+        );
+      }
+    }
+  }
+  const indexFile = path3.join(indexDir, "blockers.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    entries
+  });
+}
+async function generateParkingOverdueIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  const parkingDir = getBucketPathByKind("parking-lot", rootDir);
+  const files = await listMarkdownFiles(parkingDir);
+  const entries = [];
+  const now = /* @__PURE__ */ new Date();
+  for (const file of files) {
+    if (path3.basename(file).toLowerCase() === "readme.md") {
+      continue;
+    }
+    try {
+      const frontMatter = await read(file);
+      if (frontMatter.reconsiderDate) {
+        const reconsiderDate = new Date(frontMatter.reconsiderDate);
+        if (reconsiderDate <= now) {
+          const entry = {
+            id: frontMatter.id,
+            title: frontMatter.title,
+            status: frontMatter.status,
+            reconsiderDate: frontMatter.reconsiderDate,
+            deferralReason: frontMatter.deferralReason,
+            daysOverdue: Math.floor(
+              (now.getTime() - reconsiderDate.getTime()) / (1e3 * 60 * 60 * 24)
+            ),
+            filePath: path3.relative(rootDir, file)
+          };
+          entries.push(entry);
+        }
+      }
+    } catch (error) {
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "planning-indexer",
+          subsystem: "planning",
+          executionPhase: "execution"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            file: path3.relative(rootDir, file),
+            operation: "parse-parking-overdue"
+          }
+        }
+      );
+    }
+  }
+  entries.sort((a, b) => (b.daysOverdue || 0) - (a.daysOverdue || 0));
+  const indexFile = path3.join(indexDir, "parking-overdue.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    entries
+  });
+}
+async function readIndex(rootDir, indexName, allowRegeneration = true) {
+  assertSharedBucketsReadable(resolvePlanningContextForRoot(rootDir));
+  const indexFile = path3.join(
+    rootDir,
+    ".build-project",
+    "planning",
+    "indexes",
+    `${indexName}.json`
+  );
+  try {
+    const content = await fs.readFile(indexFile, "utf-8");
+    const index = parseJsonWithContext(content, `planning index: ${indexName}`);
+    const currentSha = await getStorageRevision(rootDir);
+    const currentDirtySignature = await getPlanningDirtySignature(rootDir);
+    const needsRegeneration = await isIndexStale(rootDir, index, currentSha, currentDirtySignature);
+    if (needsRegeneration && allowRegeneration) {
+      await generateIndexes(rootDir);
+      const { clearIndexCache } = await import("./index-query-6NUY4FKX.js");
+      clearIndexCache();
+      warnedStaleIndexes.delete(staleIndexWarningKey(indexName, index));
+      return readIndex(rootDir, indexName, false);
+    }
+    if (needsRegeneration) {
+      await warnIfIndexStale(rootDir, indexName, index, currentSha, currentDirtySignature);
+    }
+    const prunedMissingEntries = await removeMissingEntriesFromIndex(index, rootDir);
+    if (prunedMissingEntries) {
+      await writeIndexJson(indexFile, index);
+    }
+    return index;
+  } catch {
+    return null;
+  }
+}
+async function findIndexDesyncEntries(rootDir) {
+  const indexDir = path3.join(rootDir, ".build-project", "planning", "indexes");
+  const indexFiles = [
+    "ref-alias.json",
+    "backlog-by-status.json",
+    "backlog-by-priority.json",
+    "debt-by-severity.json",
+    "tasks-by-sprint.json",
+    "blockers.json",
+    "parking-overdue.json",
+    "findings-by-status.json",
+    "findings-by-fingerprint.json",
+    "issues-by-status.json",
+    "issues-by-severity.json"
+  ];
+  const missing = [];
+  for (const indexFile of indexFiles) {
+    const indexPath = path3.join(indexDir, indexFile);
+    try {
+      const content = await fs.readFile(indexPath, "utf-8");
+      const indexData = JSON.parse(content);
+      let entries = [];
+      if (indexFile === "ref-alias.json") {
+        const refs = indexData.refs;
+        const aliases = indexData.aliases;
+        entries = [...Object.values(refs ?? {}), ...Object.values(aliases ?? {})];
+      } else if ("index" in indexData && typeof indexData.index === "object" && indexData.index !== null) {
+        const grouped = indexData.index;
+        entries = Object.values(grouped).flat();
+      } else if ("entries" in indexData && Array.isArray(indexData.entries)) {
+        entries = indexData.entries;
+      }
+      for (const entry of entries) {
+        if (!entry.filePath) continue;
+        const fullPath = path3.isAbsolute(entry.filePath) ? entry.filePath : path3.join(rootDir, entry.filePath);
+        try {
+          await fs.access(fullPath);
+        } catch {
+          missing.push({
+            indexFile,
+            id: entry.id || "unknown",
+            title: entry.title || "Unknown",
+            filePath: entry.filePath
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return missing;
+}
+async function warnIfIndexStale(rootDir, indexName, index, currentSha, currentDirtySignature) {
+  if (!await isIndexStale(rootDir, index, currentSha, currentDirtySignature)) {
+    return;
+  }
+  const warnKey = staleIndexWarningKey(indexName, index);
+  if (warnedStaleIndexes.has(warnKey)) {
+    return;
+  }
+  warnedStaleIndexes.add(warnKey);
+  const resolvedCurrentSha = currentSha ?? await getStorageRevision(rootDir);
+  const short = (sha) => sha ? `${sha.slice(0, 7)}\u2026` : "unknown";
+  if (currentDirtySignature === void 0) {
+    currentDirtySignature = await getPlanningDirtySignature(rootDir);
+  }
+  const dirtyMessage = currentDirtySignature && currentDirtySignature !== CLEAN_PLANNING_TREE_SIGNATURE ? "; planning bucket files have uncommitted changes" : "";
+  emitCustomWarning(
+    "WARN" /* WARN */,
+    "configuration" /* CONFIGURATION */,
+    `Planning index "${indexName}" is stale (generated ${index.generated} at ${short(index.lastGitSha)}; HEAD is ${short(resolvedCurrentSha)}${dirtyMessage}). Run 'build planning index' to regenerate.`,
+    {
+      subsystem: "planning",
+      executionPhase: "execution"
+    },
+    {
+      skipConsole: true,
+      metadata: {
+        taskId: "planning-indexer",
+        indexName,
+        generated: index.generated,
+        indexGitSha: index.lastGitSha ?? null,
+        currentGitSha: resolvedCurrentSha ?? null,
+        planningDirty: currentDirtySignature !== null && currentDirtySignature !== void 0 && currentDirtySignature !== CLEAN_PLANNING_TREE_SIGNATURE,
+        operation: "read-index-stale",
+        remediation: "build planning index"
+      }
+    }
+  );
+}
+async function isIndexStale(rootDir, index, currentSha, currentDirtySignature) {
+  const resolvedCurrentSha = currentSha ?? await getStorageRevision(rootDir);
+  const resolvedDirtySignature = currentDirtySignature === void 0 ? await getPlanningDirtySignature(rootDir) : currentDirtySignature;
+  return isPlanningIndexStale({
+    currentRevision: resolvedCurrentSha,
+    indexRevision: index.lastGitSha,
+    currentDirtySignature: resolvedDirtySignature,
+    indexDirtySignature: index.planningDirtySignature
+  });
+}
+async function removeMissingEntriesFromIndex(index, rootDir) {
+  let changed = false;
+  if ("entries" in index && Array.isArray(index.entries)) {
+    const filteredEntries = await filterEntriesByExistingPath(index.entries, rootDir);
+    changed = filteredEntries.length !== index.entries.length;
+    index.entries = filteredEntries;
+    return changed;
+  }
+  if ("index" in index && typeof index.index === "object" && index.index !== null) {
+    for (const group of Object.keys(index.index)) {
+      const entries = Array.isArray(index.index[group]) ? index.index[group] : [];
+      const filteredEntries = await filterEntriesByExistingPath(entries, rootDir);
+      if (filteredEntries.length !== entries.length) {
+        changed = true;
+      }
+      index.index[group] = filteredEntries;
+    }
+  }
+  return changed;
+}
+async function filterEntriesByExistingPath(entries, rootDir) {
+  const filtered = [];
+  for (const entry of entries) {
+    if (!entry.filePath) {
+      filtered.push(entry);
+      continue;
+    }
+    if (await doesFileExist(rootDir, entry.filePath)) {
+      filtered.push(entry);
+    }
+  }
+  return filtered;
+}
+async function doesFileExist(rootDir, entryFilePath) {
+  const resolvedPath = path3.isAbsolute(entryFilePath) ? entryFilePath : path3.resolve(rootDir, entryFilePath);
+  try {
+    await fs.stat(resolvedPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function generateFindingsByStatusIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  let findingDir;
+  try {
+    findingDir = getBucketPathByKind("finding", rootDir);
+  } catch {
+    return;
+  }
+  const index = {
+    raw: [],
+    open: [],
+    closed: []
+  };
+  const files = await listMarkdownFiles(findingDir);
+  for (const file of files) {
+    try {
+      const frontMatter = await read(file);
+      const status = frontMatter.status || "raw";
+      const entry = {
+        id: frontMatter.id,
+        title: frontMatter.title,
+        status,
+        severity: frontMatter.severity,
+        filePath: path3.relative(rootDir, file)
+      };
+      const bucket = index[status];
+      if (bucket) bucket.push(entry);
+    } catch (error) {
+      emitWarning(
+        "IDX-007",
+        { taskId: "indexer", subsystem: "planning", executionPhase: "setup" },
+        {
+          severity: "INFO" /* INFO */,
+          metadata: {
+            file,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }
+      );
+    }
+  }
+  const indexFile = path3.join(indexDir, "findings-by-status.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateFindingsByFingerprintIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  let findingDir;
+  try {
+    findingDir = getBucketPathByKind("finding", rootDir);
+  } catch {
+    return;
+  }
+  const index = {};
+  const files = await listMarkdownFiles(findingDir);
+  for (const file of files) {
+    try {
+      const frontMatter = await read(file);
+      const fp = frontMatter.fingerprint;
+      const hash = fp?.compositeHash;
+      if (!hash) continue;
+      const entry = {
+        id: frontMatter.id,
+        title: frontMatter.title,
+        status: frontMatter.status || "raw",
+        filePath: path3.relative(rootDir, file)
+      };
+      if (!index[hash]) index[hash] = [];
+      index[hash]?.push(entry);
+    } catch {
+    }
+  }
+  const indexFile = path3.join(indexDir, "findings-by-fingerprint.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateIssuesByStatusIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  let issueDir;
+  try {
+    issueDir = getBucketPathByKind("issue", rootDir);
+  } catch {
+    return;
+  }
+  const index = {
+    open: [],
+    claimed: [],
+    resolved: [],
+    wontfix: [],
+    duplicate: []
+  };
+  const files = await listMarkdownFiles(issueDir);
+  for (const file of files) {
+    try {
+      const frontMatter = await read(file);
+      const status = frontMatter.status || "open";
+      const entry = {
+        id: frontMatter.id,
+        title: frontMatter.title,
+        status,
+        severity: frontMatter.severity,
+        filePath: path3.relative(rootDir, file)
+      };
+      const bucket = index[status];
+      if (bucket) bucket.push(entry);
+    } catch (error) {
+      emitWarning(
+        "IDX-008",
+        { taskId: "indexer", subsystem: "planning", executionPhase: "setup" },
+        {
+          severity: "INFO" /* INFO */,
+          metadata: {
+            file,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }
+      );
+    }
+  }
+  const indexFile = path3.join(indexDir, "issues-by-status.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateIssuesBySeverityIndex(rootDir, indexDir, read, gitSha, planningDirtySignature) {
+  let issueDir;
+  try {
+    issueDir = getBucketPathByKind("issue", rootDir);
+  } catch {
+    return;
+  }
+  const index = {
+    critical: [],
+    high: [],
+    medium: [],
+    low: []
+  };
+  const files = await listMarkdownFiles(issueDir);
+  for (const file of files) {
+    try {
+      const frontMatter = await read(file);
+      const severity = frontMatter.severity || "medium";
+      const entry = {
+        id: frontMatter.id,
+        title: frontMatter.title,
+        status: frontMatter.status || "open",
+        severity,
+        filePath: path3.relative(rootDir, file)
+      };
+      const bucket = index[severity];
+      if (bucket) bucket.push(entry);
+    } catch {
+    }
+  }
+  const indexFile = path3.join(indexDir, "issues-by-severity.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+
+export {
+  bucketArchiveRootForContext,
+  bucketArchiveRootForProjectRoot,
+  CLEAN_PLANNING_TREE_SIGNATURE,
+  isPlanningIndexStale,
+  getGitHeadSha,
+  getGitHeadShaSync,
+  getStorageRevision,
+  getStorageRevisionSync,
+  getPlanningDirtySignature,
+  getPlanningDirtySignatureSync,
+  checkGitDrift,
+  generateIndexes,
+  readIndex,
+  findIndexDesyncEntries
+};
+//# sourceMappingURL=chunk-VAG6GUBR.js.map