@poetic-ai/poetic 1.42.0

package/dist/chunk-DSFM56OA.js

@@ -0,0 +1,1203 @@
+import {
+  normalizeRef
+} from "./chunk-UGX7GI37.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketPathByKind,
+  listEnabledBuckets
+} from "./chunk-HOYBYAOA.js";
+import {
+  ensureDirectoryExists,
+  listMarkdownFiles,
+  listMarkdownFilesRecursive,
+  readMarkdownFile
+} from "./chunk-OIS7J26S.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  emitCustomWarning,
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/planning/index-query.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/planning/indexer.ts
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+import * as fs from "fs/promises";
+import * as path from "path";
+var GIT_TERMINAL_PROMPT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
+var DEFAULT_GIT_TIMEOUT_MS = 5e3;
+var warnedStaleIndexes = /* @__PURE__ */ new Set();
+var SAFE_GIT_REMOTE_PATTERN = /^[A-Za-z0-9._-]+$/u;
+var SAFE_GIT_REF_PATTERN = /^[A-Za-z0-9_.~^/@{}-]+$/u;
+var CLEAN_PLANNING_TREE_SIGNATURE = "clean";
+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"}`;
+}
+function isSafeGitRemote(remote) {
+  const trimmed = remote.trim();
+  return trimmed.length > 0 && !trimmed.startsWith("-") && SAFE_GIT_REMOTE_PATTERN.test(trimmed);
+}
+function isSafeGitRef(ref) {
+  const trimmed = ref.trim();
+  return trimmed.length > 0 && !trimmed.startsWith("-") && SAFE_GIT_REF_PATTERN.test(trimmed);
+}
+async function writeIndexJson(indexFile, data) {
+  const content = JSON.stringify(data, null, 2);
+  const tempFile = path.join(
+    path.dirname(indexFile),
+    `.${path.basename(indexFile)}.${process.pid}.${Date.now()}.tmp`
+  );
+  await fs.writeFile(tempFile, content, "utf8");
+  await fs.rename(tempFile, indexFile);
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function parseDirtyStatusPaths(normalizedStatus) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const line of normalizedStatus.split("\n")) {
+    const pathSpec = line.slice(3).trim();
+    if (!pathSpec) {
+      continue;
+    }
+    for (const dirtyPath of pathSpec.split(" -> ")) {
+      const normalizedPath = dirtyPath.replace(/^"|"$/g, "");
+      if (normalizedPath.length > 0 && !path.isAbsolute(normalizedPath) && !normalizedPath.split("/").includes("..")) {
+        paths.add(normalizedPath);
+      }
+    }
+  }
+  return Array.from(paths).sort();
+}
+function hashDirtyPlanningFile(rootDir, dirtyPath) {
+  try {
+    const content = readFileSync(path.join(rootDir, dirtyPath));
+    return createHash("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 getPlanningDirtySignature(rootDir) {
+  return getPlanningDirtySignatureSync(rootDir);
+}
+function getPlanningDirtySignatureSync(rootDir) {
+  let bucketPaths;
+  try {
+    bucketPaths = listEnabledBuckets(rootDir).flatMap((bucket) => [
+      getBucketPathByKind(bucket.name, rootDir),
+      getBucketArchivePathByKind(bucket.name, rootDir)
+    ]);
+  } catch {
+    return null;
+  }
+  const relativePaths = Array.from(
+    new Set(
+      bucketPaths.map((bucketPath) => path.relative(rootDir, bucketPath).replace(/\\/g, "/")).filter((bucketPath) => bucketPath.length > 0 && !bucketPath.startsWith("..")).sort()
+    )
+  );
+  if (relativePaths.length === 0) {
+    return CLEAN_PLANNING_TREE_SIGNATURE;
+  }
+  try {
+    const status = execSync(
+      `git status --porcelain=v1 --untracked-files=all -- ${relativePaths.map(shellQuote).join(" ")}`,
+      {
+        cwd: rootDir,
+        encoding: "utf8",
+        timeout: DEFAULT_GIT_TIMEOUT_MS,
+        env: GIT_TERMINAL_PROMPT_ENV,
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    );
+    const normalizedStatus = status.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 dirtyPaths = parseDirtyStatusPaths(normalizedStatus);
+    const dirtyFileHashes = dirtyPaths.map((dirtyPath) => {
+      const fileHash = hashDirtyPlanningFile(rootDir, dirtyPath);
+      return `${dirtyPath}:${fileHash}`;
+    });
+    return createHash("sha256").update([normalizedStatus, ...dirtyFileHashes].join("\n")).digest("hex");
+  } catch {
+    return null;
+  }
+}
+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) {
+  const indexDir = path.join(rootDir, ".poetic", "planning", "indexes");
+  await ensureDirectoryExists(indexDir);
+  const gitSha = await getGitHeadSha(rootDir) ?? void 0;
+  const planningDirtySignature = await getPlanningDirtySignature(rootDir);
+  await generateRefAliasIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+  await generateBacklogByStatusIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+  await generateBacklogByPriorityIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+  await generateDebtBySeverityIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+  await generateTasksBySprintIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+  await generateBlockersIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+  await generateParkingOverdueIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+  await generateFindingsByStatusIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+  await generateFindingsByFingerprintIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+  await generateIssuesByStatusIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+  await generateIssuesBySeverityIndex(rootDir, indexDir, gitSha, planningDirtySignature);
+}
+async function generateRefAliasIndex(rootDir, indexDir, gitSha, planningDirtySignature) {
+  const refs = {};
+  const aliases = {};
+  const collisions = [];
+  for (const bucket of listEnabledBuckets(rootDir)) {
+    const dirs = [
+      getBucketPathByKind(bucket.name, rootDir),
+      getBucketArchivePathByKind(bucket.name, rootDir)
+    ];
+    for (const dir of dirs) {
+      const isArchive = path.basename(dir.replace(/[/\\]+$/, "")) === "archive";
+      const files = isArchive ? await listMarkdownFilesRecursive(dir) : await listMarkdownFiles(dir);
+      for (const file of files) {
+        if (path.basename(file).toLowerCase() === "readme.md") {
+          continue;
+        }
+        try {
+          const { frontMatter } = await readMarkdownFile(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: path.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 = path.join(indexDir, "ref-alias.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    refs,
+    aliases
+  });
+}
+async function generateBacklogByStatusIndex(rootDir, indexDir, gitSha, planningDirtySignature) {
+  const backlogDirs = [
+    getBucketPathByKind("backlog", rootDir),
+    getBucketArchivePathByKind("backlog", rootDir)
+  ];
+  const index = {
+    inbox: [],
+    reviewed: [],
+    done: [],
+    archived: []
+  };
+  for (const dir of backlogDirs) {
+    const isArchive = path.basename(dir.replace(/[/\\]+$/, "")) === "archive";
+    const files = isArchive ? await listMarkdownFilesRecursive(dir) : await listMarkdownFiles(dir);
+    for (const file of files) {
+      if (path.basename(file).toLowerCase() === "readme.md") {
+        continue;
+      }
+      try {
+        const { frontMatter } = await readMarkdownFile(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: path.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: path.relative(rootDir, file),
+              operation: "parse-backlog-by-status"
+            }
+          }
+        );
+      }
+    }
+  }
+  const indexFile = path.join(indexDir, "backlog-by-status.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateBacklogByPriorityIndex(rootDir, indexDir, gitSha, planningDirtySignature) {
+  const backlogDirs = [
+    getBucketPathByKind("backlog", rootDir),
+    getBucketArchivePathByKind("backlog", rootDir)
+  ];
+  const files = (await Promise.all(
+    backlogDirs.map(async (dir) => {
+      const isArchive = path.basename(dir.replace(/[/\\]+$/, "")) === "archive";
+      return isArchive ? await listMarkdownFilesRecursive(dir) : await listMarkdownFiles(dir);
+    })
+  )).flat();
+  const index = {
+    P0: [],
+    P1: [],
+    P2: [],
+    P3: []
+  };
+  for (const file of files) {
+    if (path.basename(file).toLowerCase() === "readme.md") {
+      continue;
+    }
+    try {
+      const { frontMatter } = await readMarkdownFile(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: path.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: path.relative(rootDir, file),
+            operation: "parse-backlog-by-priority"
+          }
+        }
+      );
+    }
+  }
+  const indexFile = path.join(indexDir, "backlog-by-priority.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateDebtBySeverityIndex(rootDir, indexDir, 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 (path.basename(file).toLowerCase() === "readme.md") {
+      continue;
+    }
+    try {
+      const { frontMatter } = await readMarkdownFile(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: path.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: path.relative(rootDir, file),
+            operation: "parse-debt-by-severity"
+          }
+        }
+      );
+    }
+  }
+  const indexFile = path.join(indexDir, "debt-by-severity.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateTasksBySprintIndex(rootDir, indexDir, gitSha, planningDirtySignature) {
+  const tasksDir = getBucketPathByKind("task", rootDir);
+  const files = await listMarkdownFilesRecursive(tasksDir);
+  const index = {};
+  for (const file of files) {
+    if (path.basename(file).toLowerCase() === "readme.md") {
+      continue;
+    }
+    try {
+      const { frontMatter } = await readMarkdownFile(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: path.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: path.relative(rootDir, file),
+            operation: "parse-tasks-by-sprint"
+          }
+        }
+      );
+    }
+  }
+  const indexFile = path.join(indexDir, "tasks-by-sprint.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateBlockersIndex(rootDir, indexDir, 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 (path.basename(file).toLowerCase() === "readme.md") {
+        continue;
+      }
+      try {
+        const { frontMatter } = await readMarkdownFile(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: path.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: path.relative(rootDir, file),
+              operation: "parse-blockers"
+            }
+          }
+        );
+      }
+    }
+  }
+  const indexFile = path.join(indexDir, "blockers.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    entries
+  });
+}
+async function generateParkingOverdueIndex(rootDir, indexDir, 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 (path.basename(file).toLowerCase() === "readme.md") {
+      continue;
+    }
+    try {
+      const { frontMatter } = await readMarkdownFile(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: path.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: path.relative(rootDir, file),
+            operation: "parse-parking-overdue"
+          }
+        }
+      );
+    }
+  }
+  entries.sort((a, b) => (b.daysOverdue || 0) - (a.daysOverdue || 0));
+  const indexFile = path.join(indexDir, "parking-overdue.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    entries
+  });
+}
+async function readIndex(rootDir, indexName, allowRegeneration = true) {
+  const indexFile = path.join(rootDir, ".poetic", "planning", "indexes", `${indexName}.json`);
+  try {
+    const content = await fs.readFile(indexFile, "utf-8");
+    const index = parseJsonWithContext(content, `planning index: ${indexName}`);
+    const currentSha = await getGitHeadSha(rootDir);
+    const currentDirtySignature = await getPlanningDirtySignature(rootDir);
+    const needsRegeneration = await isIndexStale(rootDir, index, currentSha, currentDirtySignature);
+    if (needsRegeneration && allowRegeneration) {
+      await generateIndexes(rootDir);
+      const { clearIndexCache: clearIndexCache2 } = await import("./index-query-4JEUKA44.js");
+      clearIndexCache2();
+      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 = path.join(rootDir, ".poetic", "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 = path.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 = path.isAbsolute(entry.filePath) ? entry.filePath : path.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 getGitHeadSha(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 'poetic 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: "poetic planning index"
+      }
+    }
+  );
+}
+async function isIndexStale(rootDir, index, currentSha, currentDirtySignature) {
+  const resolvedCurrentSha = currentSha ?? await getGitHeadSha(rootDir);
+  if (!resolvedCurrentSha) {
+    return false;
+  }
+  if (typeof index.lastGitSha !== "string" || index.lastGitSha.length === 0) {
+    return true;
+  }
+  if (resolvedCurrentSha !== index.lastGitSha) {
+    return true;
+  }
+  if (currentDirtySignature === void 0) {
+    currentDirtySignature = await getPlanningDirtySignature(rootDir);
+  }
+  if (currentDirtySignature === null) {
+    return false;
+  }
+  const metadata = index;
+  if (typeof metadata.planningDirtySignature !== "string") {
+    return currentDirtySignature !== CLEAN_PLANNING_TREE_SIGNATURE;
+  }
+  return currentDirtySignature !== metadata.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 = path.isAbsolute(entryFilePath) ? entryFilePath : path.resolve(rootDir, entryFilePath);
+  try {
+    await fs.stat(resolvedPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function generateFindingsByStatusIndex(rootDir, indexDir, 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 readMarkdownFile(file);
+      const status = frontMatter.status || "raw";
+      const entry = {
+        id: frontMatter.id,
+        title: frontMatter.title,
+        status,
+        severity: frontMatter.severity,
+        filePath: path.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 = path.join(indexDir, "findings-by-status.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateFindingsByFingerprintIndex(rootDir, indexDir, 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 readMarkdownFile(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: path.relative(rootDir, file)
+      };
+      if (!index[hash]) index[hash] = [];
+      index[hash]?.push(entry);
+    } catch {
+    }
+  }
+  const indexFile = path.join(indexDir, "findings-by-fingerprint.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateIssuesByStatusIndex(rootDir, indexDir, 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 readMarkdownFile(file);
+      const status = frontMatter.status || "open";
+      const entry = {
+        id: frontMatter.id,
+        title: frontMatter.title,
+        status,
+        severity: frontMatter.severity,
+        filePath: path.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 = path.join(indexDir, "issues-by-status.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+async function generateIssuesBySeverityIndex(rootDir, indexDir, 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 readMarkdownFile(file);
+      const severity = frontMatter.severity || "medium";
+      const entry = {
+        id: frontMatter.id,
+        title: frontMatter.title,
+        status: frontMatter.status || "open",
+        severity,
+        filePath: path.relative(rootDir, file)
+      };
+      const bucket = index[severity];
+      if (bucket) bucket.push(entry);
+    } catch {
+    }
+  }
+  const indexFile = path.join(indexDir, "issues-by-severity.json");
+  await writeIndexJson(indexFile, {
+    ...indexMetadata(gitSha, planningDirtySignature),
+    index
+  });
+}
+
+// src/planning/index-query.ts
+var indexCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 5 * 60 * 1e3;
+var FRESHNESS_SNAPSHOT_TTL = 250;
+var freshnessSnapshotCache = /* @__PURE__ */ new Map();
+function getRepoFreshnessSnapshot(repoRoot) {
+  const now = Date.now();
+  const cached = freshnessSnapshotCache.get(repoRoot);
+  if (cached && now - cached.loadedAt < FRESHNESS_SNAPSHOT_TTL) {
+    return cached.snapshot;
+  }
+  const gitSha = getGitHeadShaSync(repoRoot);
+  const snapshot = {
+    gitSha,
+    planningDirtySignature: gitSha ? getPlanningDirtySignatureSync(repoRoot) : null
+  };
+  freshnessSnapshotCache.set(repoRoot, { snapshot, loadedAt: now });
+  return snapshot;
+}
+function indexExists(indexName, repoRoot = process.cwd()) {
+  const indexPath = path2.join(repoRoot, ".poetic", "planning", "indexes", `${indexName}.json`);
+  return fs2.existsSync(indexPath);
+}
+function isIndexFresh(indexName, repoRoot = process.cwd()) {
+  return isIndexFreshFromMetadata(indexName, repoRoot);
+}
+function isIndexFreshFromMetadata(indexName, repoRoot, cachedData, freshness = getRepoFreshnessSnapshot(repoRoot)) {
+  if (!indexExists(indexName, repoRoot)) return false;
+  try {
+    const indexPath = path2.join(repoRoot, ".poetic", "planning", "indexes", `${indexName}.json`);
+    const index = cachedData ?? JSON.parse(fs2.readFileSync(indexPath, "utf8"));
+    const currentGitSha = freshness.gitSha;
+    if (currentGitSha) {
+      if (index.lastGitSha !== currentGitSha) return false;
+      const currentDirtySignature = freshness.planningDirtySignature;
+      if (currentDirtySignature !== null) {
+        if (typeof index.planningDirtySignature !== "string") {
+          return currentDirtySignature === CLEAN_PLANNING_TREE_SIGNATURE;
+        }
+        return index.planningDirtySignature === currentDirtySignature;
+      }
+    }
+    const indexStat = fs2.statSync(indexPath);
+    const indexMtime = indexStat.mtime.getTime();
+    for (const bucket of listEnabledBuckets(repoRoot)) {
+      const bucketPaths = [
+        getBucketPathByKind(bucket.name, repoRoot),
+        getBucketArchivePathByKind(bucket.name, repoRoot)
+      ];
+      for (const bucketPath of bucketPaths) {
+        if (!fs2.existsSync(bucketPath)) continue;
+        if (fs2.statSync(bucketPath).mtime.getTime() > indexMtime) {
+          return false;
+        }
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function loadIndex(indexName, repoRoot = process.cwd()) {
+  return loadIndexWithFreshness(indexName, repoRoot);
+}
+function loadIndexWithFreshness(indexName, repoRoot, freshness) {
+  const cacheKey = `${repoRoot}:${indexName}`;
+  const cached = indexCache.get(cacheKey);
+  const indexPath = path2.join(repoRoot, ".poetic", "planning", "indexes", `${indexName}.json`);
+  let stat2 = null;
+  try {
+    stat2 = fs2.statSync(indexPath);
+  } catch {
+    stat2 = null;
+  }
+  const cacheFileUnchanged = Boolean(
+    cached && stat2 && stat2.mtimeMs === cached.mtimeMs && stat2.ctimeMs === cached.ctimeMs && stat2.size === cached.size
+  );
+  const indexFresh = isIndexFreshFromMetadata(
+    indexName,
+    repoRoot,
+    cacheFileUnchanged ? cached?.data : void 0,
+    freshness
+  );
+  if (!indexFresh) {
+    indexCache.delete(cacheKey);
+    return null;
+  }
+  if (cached && Date.now() - cached.loadedAt < CACHE_TTL && cacheFileUnchanged) {
+    return cached.data;
+  }
+  indexCache.delete(cacheKey);
+  if (!stat2) {
+    return null;
+  }
+  try {
+    const raw = fs2.readFileSync(indexPath, "utf-8");
+    const data = JSON.parse(raw);
+    const postStat = fs2.statSync(indexPath);
+    indexCache.set(cacheKey, {
+      data,
+      loadedAt: Date.now(),
+      mtimeMs: postStat.mtimeMs,
+      ctimeMs: postStat.ctimeMs,
+      size: postStat.size
+    });
+    return data;
+  } catch {
+    return null;
+  }
+}
+function queryById(id, repoRoot = process.cwd(), includeArchive = false) {
+  const freshness = getRepoFreshnessSnapshot(repoRoot);
+  const refAliasIndex = loadIndexWithFreshness("ref-alias", repoRoot, freshness);
+  if (refAliasIndex) {
+    const normalized = normalizeRef(id);
+    const fromRef = refAliasIndex.refs[normalized];
+    const fromAlias = refAliasIndex.aliases[normalized];
+    const entry = fromRef || fromAlias;
+    if (entry) {
+      if (!includeArchive && entry.filePath.includes("/archive/")) {
+        return null;
+      }
+      return entry;
+    }
+  }
+  const indexes = [
+    "backlog-by-status",
+    "backlog-by-priority",
+    "debt-by-severity",
+    "tasks-by-sprint",
+    "blockers",
+    "parking-overdue"
+  ];
+  for (const indexName of indexes) {
+    const index = loadIndexWithFreshness(
+      indexName,
+      repoRoot,
+      freshness
+    );
+    if (!index || !index.index) continue;
+    for (const entries of Object.values(index.index)) {
+      for (const entry of entries) {
+        if (entry.id === id) {
+          if (!includeArchive && entry.filePath.includes("/archive/")) {
+            continue;
+          }
+          return entry;
+        }
+      }
+    }
+  }
+  return null;
+}
+function queryByRef(ref, repoRoot = process.cwd(), includeArchive = false) {
+  const refAliasIndex = loadIndex("ref-alias", repoRoot);
+  if (!refAliasIndex) return null;
+  const normalized = normalizeRef(ref);
+  const entry = refAliasIndex.refs[normalized];
+  if (!entry) return null;
+  if (!includeArchive && entry.filePath.includes("/archive/")) {
+    return null;
+  }
+  return entry;
+}
+function queryByAlias(alias, repoRoot = process.cwd(), includeArchive = false) {
+  const refAliasIndex = loadIndex("ref-alias", repoRoot);
+  if (!refAliasIndex) return null;
+  const normalized = normalizeRef(alias);
+  const entry = refAliasIndex.aliases[normalized];
+  if (!entry) return null;
+  if (!includeArchive && entry.filePath.includes("/archive/")) {
+    return null;
+  }
+  return entry;
+}
+function getIndexStaleError(indexName) {
+  const indexInfo = indexName ? ` (${indexName})` : "";
+  return `Index is stale or missing${indexInfo}.
+
+Run the following command to regenerate indexes:
+  poetic planning index --regenerate`;
+}
+function clearIndexCache() {
+  indexCache.clear();
+  freshnessSnapshotCache.clear();
+}
+
+export {
+  checkGitDrift,
+  generateIndexes,
+  readIndex,
+  findIndexDesyncEntries,
+  indexExists,
+  isIndexFresh,
+  loadIndex,
+  queryById,
+  queryByRef,
+  queryByAlias,
+  getIndexStaleError,
+  clearIndexCache
+};
+//# sourceMappingURL=chunk-DSFM56OA.js.map