@poetic-ai/poetic 1.42.0

package/dist/chunk-NRNE225N.js

@@ -0,0 +1,1270 @@
+import {
+  listFindings,
+  listIssues,
+  loadIssuePolicy,
+  severityToPriority
+} from "./chunk-BZU2O43F.js";
+import {
+  estimateRuntime
+} from "./chunk-LDCF2MKN.js";
+import {
+  isBacklogExecutionProvenanceActivelyExecuting,
+  loadBacklogExecutionProvenance
+} from "./chunk-NM6PMYY4.js";
+import {
+  buildGraphBlockersView,
+  loadWorkGraphContext
+} from "./chunk-YVORHQ2S.js";
+import {
+  listActive
+} from "./chunk-O47UOKU3.js";
+import {
+  findBacklogItem,
+  listBacklogItems,
+  validateDebtItem
+} from "./chunk-LH5QY22X.js";
+import {
+  getArchivedFilePath
+} from "./chunk-OYZYO7TV.js";
+import {
+  generateId
+} from "./chunk-VNSYKC25.js";
+import {
+  getPlanningRoot,
+  withIndexRegeneration
+} from "./chunk-OPYFYTWQ.js";
+import {
+  generateIndexes
+} from "./chunk-DSFM56OA.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketByName,
+  getBucketPathByKind
+} from "./chunk-HOYBYAOA.js";
+import {
+  listMarkdownFiles,
+  listMarkdownFilesRecursive,
+  parseMarkdownFile,
+  readMarkdownFile
+} from "./chunk-OIS7J26S.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/read-models/next.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { execa } from "execa";
+
+// src/planning/tech-debt-manager.ts
+import * as fsSync from "fs";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var severityImpactDefaults = {
+  critical: 9,
+  high: 7,
+  medium: 5,
+  low: 3
+};
+var EFFORT_TO_HOURS = {
+  low: 2,
+  medium: 6,
+  high: 12
+};
+var EFFORT_TO_AI_BASE_MINUTES = {
+  low: 5,
+  medium: 20,
+  high: 90
+};
+var EFFORT_TO_COMPLEXITY = {
+  low: 0.3,
+  medium: 0.5,
+  high: 0.7
+};
+function effortToNominalHours(effort) {
+  return EFFORT_TO_HOURS[effort];
+}
+function effortToNominalComplexity(effort) {
+  return EFFORT_TO_COMPLEXITY[effort];
+}
+function resolveDebtRuntimeEstimate(effort, explicitMinutes) {
+  if (typeof explicitMinutes === "number" && Number.isFinite(explicitMinutes)) {
+    if (explicitMinutes <= 0) return {};
+    return {
+      // Clamp to [1, 1440]: sub-minute values persist as a valid minute rather
+      // than rounding to 0, and programmatic callers (createDebtItemAsync /
+      // updateDebtItemAsync are exported) cannot persist values above the
+      // shared ExpectedRuntimeMinutesSchema ceiling that the CLI enforces.
+      expectedRuntimeMinutes: Math.min(1440, Math.max(1, Math.round(explicitMinutes))),
+      runtimeEstimateProvenance: "explicit",
+      runtimeEstimateConfidence: "medium"
+    };
+  }
+  const estimate = estimateRuntime({
+    baseExpectedRuntimeMs: EFFORT_TO_AI_BASE_MINUTES[effort] * 6e4
+  });
+  return {
+    expectedRuntimeMinutes: Math.round(estimate.expectedRuntimeMs / 6e4),
+    runtimeEstimateProvenance: estimate.provenance,
+    runtimeEstimateConfidence: estimate.confidence
+  };
+}
+function coerceDebtRuntimeEstimate(raw) {
+  const result = {};
+  const rawMinutes = raw.expectedRuntimeMinutes;
+  const minutes = typeof rawMinutes === "number" ? rawMinutes : typeof rawMinutes === "string" && rawMinutes.trim() !== "" ? Number(rawMinutes) : void 0;
+  if (typeof minutes === "number" && Number.isFinite(minutes) && minutes > 0) {
+    result.expectedRuntimeMinutes = minutes;
+  }
+  const provenance = raw.runtimeEstimateProvenance;
+  if (provenance === "heuristic" || provenance === "telemetry" || provenance === "blended" || provenance === "explicit") {
+    result.runtimeEstimateProvenance = provenance;
+  }
+  const confidence = raw.runtimeEstimateConfidence;
+  if (confidence === "low" || confidence === "medium" || confidence === "high") {
+    result.runtimeEstimateConfidence = confidence;
+  }
+  return result;
+}
+var legacyImpactLabels = {
+  critical: severityImpactDefaults.critical,
+  high: severityImpactDefaults.high,
+  medium: severityImpactDefaults.medium,
+  low: severityImpactDefaults.low
+};
+function defaultImpactForSeverity(severity) {
+  return severityImpactDefaults[severity ?? "medium"];
+}
+function coerceImpact(value, severity) {
+  let parsed;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    parsed = value;
+  } else if (typeof value === "string") {
+    const trimmed = value.trim().toLowerCase();
+    const numericMatch = trimmed.match(/\d+(?:\.\d+)?/);
+    if (numericMatch) {
+      parsed = Number(numericMatch[0]);
+    } else if (trimmed in legacyImpactLabels) {
+      parsed = legacyImpactLabels[trimmed];
+    }
+  }
+  const impact = parsed ?? defaultImpactForSeverity(severity);
+  return Math.min(10, Math.max(1, Math.round(impact)));
+}
+function normalizeDebtItem(raw) {
+  const severity = raw.severity ?? "medium";
+  const effort = raw.effort ?? "medium";
+  const normalized = {
+    id: raw.id ?? "",
+    kind: "tech-debt",
+    title: raw.title ?? raw.id ?? "Untitled tech debt",
+    domain: raw.domain ?? "architecture",
+    severity,
+    effort,
+    impact: coerceImpact(raw.impact, severity),
+    status: raw.status ?? "pending",
+    estimatedComplexity: raw.estimatedComplexity ?? effortToNominalComplexity(effort),
+    estimatedHours: raw.estimatedHours ?? effortToNominalHours(effort),
+    // AI-era estimate: read-through only — legacy items round-trip byte-clean
+    // with no fabricated AI fields (matches task-manager's honesty pattern).
+    ...coerceDebtRuntimeEstimate(raw),
+    rootCause: raw.rootCause ?? "To be documented",
+    blocking: raw.blocking ?? severity === "critical",
+    parallelizable: raw.parallelizable ?? severity !== "critical",
+    executeBy: raw.executeBy,
+    createdAt: raw.createdAt,
+    updatedAt: raw.updatedAt,
+    createdDate: raw.createdDate,
+    targetCompleteDate: raw.targetCompleteDate,
+    completedAt: raw.completedAt,
+    archivedAt: raw.archivedAt
+  };
+  if (!normalized.createdAt && normalized.createdDate) {
+    normalized.createdAt = `${normalized.createdDate}T00:00:00.000Z`;
+  }
+  return normalized;
+}
+function parseMarkdownContent(content, filePath) {
+  const match = content.match(/^---\n([\s\S]+?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    throw new Error(`Invalid markdown format in ${filePath}: missing YAML front matter`);
+  }
+  const rawMetadata = yaml.load(match[1] ?? "", { schema: yaml.JSON_SCHEMA });
+  const body = (match[2] ?? "").trim();
+  return { metadata: normalizeDebtItem(rawMetadata), body };
+}
+function buildDebtItem(title, severity, effort, options = {}) {
+  const id = generateId(/* @__PURE__ */ new Date());
+  const debtItem = {
+    id,
+    kind: "tech-debt",
+    title,
+    domain: options.domain || "architecture",
+    severity,
+    effort,
+    impact: coerceImpact(options.impact, severity),
+    status: "pending",
+    // Advisory nominal derived from the explicit effort level (see EFFORT_TO_HOURS).
+    estimatedComplexity: options.estimatedComplexity ?? effortToNominalComplexity(effort),
+    estimatedHours: options.estimatedHours ?? effortToNominalHours(effort),
+    // AI-era primary estimate (advisory, [B5]): explicit minutes win, else
+    // effort-derived via the canonical estimator.
+    ...resolveDebtRuntimeEstimate(effort, options.expectedRuntimeMinutes),
+    rootCause: options.rootCause || "To be documented",
+    blocking: options.blocking !== void 0 ? options.blocking : severity === "critical",
+    parallelizable: options.parallelizable !== void 0 ? options.parallelizable : severity !== "critical",
+    executeBy: options.executeBy,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    targetCompleteDate: options.targetCompleteDate
+  };
+  const body = `# ${title}
+
+## Problem
+
+${options.rootCause || "To be documented"}
+
+## Impact
+
+- Severity: ${severity}
+- Estimated effort: ${effort}${debtItem.expectedRuntimeMinutes ? ` (~${debtItem.expectedRuntimeMinutes}m AI est)` : ` (${debtItem.estimatedHours}h)`}
+- Impact score: ${debtItem.impact}/10
+- Blocks production: ${debtItem.blocking ? "Yes" : "No"}
+- Can run in parallel: ${debtItem.parallelizable ? "Yes" : "No"}
+
+## Scheduling Recommendation
+
+${getSchedulingRecommendation(debtItem)}
+
+## Solution
+
+To be documented when assigned.
+
+## Success Criteria
+
+- [ ] Root cause addressed
+- [ ] Tests passing
+- [ ] Documentation updated
+- [ ] No regressions introduced
+`;
+  return { debtItem, body };
+}
+function regenerateIndexesAfterCreate(basePath) {
+  generateIndexes(basePath).catch((error) => {
+    if (error?.code === "ENOENT") return;
+    emitWarning(
+      "CFG-002",
+      {
+        taskId: "tech-debt-manager",
+        subsystem: "planning",
+        executionPhase: "cleanup"
+      },
+      {
+        severity: "INFO" /* INFO */,
+        metadata: {
+          error: error instanceof Error ? error.message : String(error),
+          operation: "regenerate-indexes-after-create"
+        }
+      }
+    );
+  });
+}
+async function parseMarkdownFile2(filePath) {
+  const content = await fs.readFile(filePath, "utf8");
+  return parseMarkdownContent(content, filePath);
+}
+async function getDebtItemAsync(itemId) {
+  const basePath = getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  const filePath = path.join(currentPath, `${itemId}.md`);
+  try {
+    await fs.access(filePath);
+  } catch {
+    return null;
+  }
+  return parseMarkdownFile2(filePath);
+}
+async function writeMarkdownFile(filePath, metadata, body) {
+  const yamlStr = yaml.dump(metadata, { lineWidth: -1 });
+  const content = `---
+${yamlStr}---
+
+${body}`;
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  const handle = await fs.open(tempPath, "w");
+  try {
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+    await handle.close();
+    await fs.rename(tempPath, filePath);
+  } catch (error) {
+    try {
+      await handle.close();
+    } catch {
+    }
+    try {
+      await fs.unlink(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+async function createDebtItemAsync(title, severity, effort, options = {}) {
+  const basePath = getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  await fs.mkdir(currentPath, { recursive: true });
+  const { debtItem, body } = buildDebtItem(title, severity, effort, options);
+  const filePath = path.join(currentPath, `${debtItem.id}.md`);
+  await writeMarkdownFile(filePath, debtItem, body);
+  regenerateIndexesAfterCreate(basePath);
+  return debtItem;
+}
+async function updateDebtItemAsync(itemId, fields) {
+  const basePath = getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  const filePath = path.join(currentPath, `${itemId}.md`);
+  return withIndexRegeneration(basePath, async () => {
+    const loaded = await getDebtItemAsync(itemId);
+    if (!loaded) {
+      throw new Error(`Debt item not found: ${itemId}`);
+    }
+    const { metadata: existing, body: existingBody } = loaded;
+    const { yaml: rawFrontmatter } = await parseMarkdownFile(filePath);
+    const rawUpdated = { ...rawFrontmatter };
+    let changed = false;
+    const applyScalar = (key, value) => {
+      if (value === void 0) return;
+      if (rawUpdated[key] !== value) {
+        rawUpdated[key] = value;
+        changed = true;
+      }
+    };
+    applyScalar("title", fields.title);
+    applyScalar("severity", fields.severity);
+    applyScalar("effort", fields.effort);
+    applyScalar("impact", fields.impact);
+    applyScalar("blocking", fields.blocking);
+    applyScalar("parallelizable", fields.parallelizable);
+    applyScalar("domain", fields.domain);
+    applyScalar("rootCause", fields.rootCause);
+    applyScalar("executeBy", fields.executeBy);
+    applyScalar("targetCompleteDate", fields.targetCompleteDate);
+    applyScalar("estimatedHours", fields.estimatedHours);
+    applyScalar("estimatedComplexity", fields.estimatedComplexity);
+    if (fields.expectedRuntimeMinutes !== void 0) {
+      const explicit = resolveDebtRuntimeEstimate(
+        rawUpdated.effort ?? "medium",
+        fields.expectedRuntimeMinutes
+      );
+      applyScalar("expectedRuntimeMinutes", explicit.expectedRuntimeMinutes);
+      applyScalar("runtimeEstimateProvenance", explicit.runtimeEstimateProvenance);
+      applyScalar("runtimeEstimateConfidence", explicit.runtimeEstimateConfidence);
+    } else if (fields.effort !== void 0 && rawUpdated.runtimeEstimateProvenance !== "explicit" && rawUpdated.runtimeEstimateProvenance !== "telemetry" && rawUpdated.expectedRuntimeMinutes !== void 0) {
+      const rederived = resolveDebtRuntimeEstimate(fields.effort);
+      applyScalar("expectedRuntimeMinutes", rederived.expectedRuntimeMinutes);
+      applyScalar("runtimeEstimateProvenance", rederived.runtimeEstimateProvenance);
+      applyScalar("runtimeEstimateConfidence", rederived.runtimeEstimateConfidence);
+    }
+    if (typeof rawUpdated.expectedRuntimeMinutes === "string") {
+      const repaired = Number(rawUpdated.expectedRuntimeMinutes);
+      if (Number.isFinite(repaired)) {
+        rawUpdated.expectedRuntimeMinutes = repaired;
+        changed = true;
+      }
+    }
+    let nextBody = existingBody;
+    if (fields.body !== void 0 && fields.body !== existingBody) {
+      nextBody = fields.body;
+      changed = true;
+    }
+    if (!changed) {
+      return { item: existing, filePath, changed: false };
+    }
+    rawUpdated.id = itemId;
+    rawUpdated.kind = "tech-debt";
+    rawUpdated.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const validation = validateDebtItem(rawUpdated);
+    if (!validation.valid) {
+      const detail = validation.errors.map((error) => `${error.field}: ${error.message}`).join("; ");
+      throw new Error(`Invalid debt item after update (${itemId}): ${detail}`);
+    }
+    await writeMarkdownFile(filePath, rawUpdated, nextBody);
+    const { metadata: normalizedUpdated } = parseMarkdownContent(
+      `---
+${yaml.dump(rawUpdated, { lineWidth: -1 })}---
+${nextBody}`,
+      filePath
+    );
+    return { item: normalizedUpdated, filePath, changed: true };
+  });
+}
+function getSchedulingRecommendation(item) {
+  if (item.severity === "critical" && item.blocking) {
+    return "Execute immediately - halt sprint if necessary";
+  }
+  if (item.severity === "critical" && !item.blocking) {
+    return "Execute in parallel with current sprint";
+  }
+  if (item.severity === "high" && item.blocking) {
+    return "Add to current sprint - adjust capacity";
+  }
+  if (item.severity === "high" && !item.blocking) {
+    return "Schedule for next sprint";
+  }
+  if (item.severity === "medium") {
+    return "Opportunistic execution when capacity available";
+  }
+  return "Backlog for future sprints";
+}
+async function listByBlockingAsync() {
+  const basePath = getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  const files = await listMarkdownFileNames(currentPath);
+  const debtItems = [];
+  for (const file of files) {
+    const filePath = path.join(currentPath, file);
+    try {
+      const { metadata } = await parseMarkdownFile2(filePath);
+      if (metadata.blocking) {
+        debtItems.push(metadata);
+      }
+    } catch (error) {
+      warnDebtReadError(error, file, "list-blocking-debt");
+    }
+  }
+  return sortBySeverityThenImpact(debtItems);
+}
+async function listByParallelizableAsync() {
+  const basePath = getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  const files = await listMarkdownFileNames(currentPath);
+  const debtItems = [];
+  for (const file of files) {
+    const filePath = path.join(currentPath, file);
+    try {
+      const { metadata } = await parseMarkdownFile2(filePath);
+      if (metadata.parallelizable) {
+        debtItems.push(metadata);
+      }
+    } catch (error) {
+      warnDebtReadError(error, file, "list-parallelizable-debt");
+    }
+  }
+  return sortBySeverityThenHours(debtItems);
+}
+async function scheduleDebtAsync(itemId, when) {
+  const basePath = getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  const filePath = path.join(currentPath, `${itemId}.md`);
+  try {
+    await fs.access(filePath);
+  } catch {
+    throw new Error(`Debt item not found: ${itemId}`);
+  }
+  const { metadata, body } = await parseMarkdownFile2(filePath);
+  applyDebtSchedule(metadata, when);
+  await writeMarkdownFile(filePath, metadata, body);
+  return metadata;
+}
+async function completeDebtAsync(itemId) {
+  const basePath = getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  const bucket = getBucketByName("tech-debt", basePath);
+  if (!bucket) {
+    throw new Error("Bucket not configured: tech-debt");
+  }
+  const currentFile = path.join(currentPath, `${itemId}.md`);
+  try {
+    await fs.access(currentFile);
+  } catch {
+    throw new Error(`Debt item not found: ${itemId}`);
+  }
+  const { metadata, body } = await parseMarkdownFile2(currentFile);
+  markDebtComplete(metadata);
+  const archivedAt = metadata.archivedAt;
+  const archivedFile = getArchivedFilePath(bucket, itemId, archivedAt, basePath);
+  await fs.mkdir(path.dirname(archivedFile), { recursive: true });
+  await writeMarkdownFile(archivedFile, metadata, body);
+  await fs.unlink(currentFile);
+  return metadata;
+}
+async function listAllDebtAsync(includeArchived = false, rootDir) {
+  const basePath = rootDir ?? getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  const archivedPath = getBucketArchivePathByKind("tech-debt", basePath);
+  const items = [];
+  for (const file of await listMarkdownFileNames(currentPath)) {
+    try {
+      const { metadata } = await parseMarkdownFile2(path.join(currentPath, file));
+      items.push(metadata);
+    } catch (error) {
+      warnDebtReadError(error, file, "list-all-debt-current");
+    }
+  }
+  if (includeArchived) {
+    const files = await listMarkdownFilesRecursive2(archivedPath);
+    for (const file of files) {
+      if (path.basename(file).toLowerCase() === "readme.md") {
+        continue;
+      }
+      try {
+        const { metadata } = await parseMarkdownFile2(file);
+        items.push(metadata);
+      } catch (error) {
+        warnDebtReadError(error, path.relative(basePath, file), "list-all-debt-archived");
+      }
+    }
+  }
+  return items;
+}
+async function listMarkdownFileNames(directory) {
+  let entries;
+  try {
+    entries = await fs.readdir(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter(
+    (entry) => entry.isFile() && entry.name.endsWith(".md") && entry.name.toLowerCase() !== "readme.md"
+  ).map((entry) => entry.name);
+}
+async function listMarkdownFilesRecursive2(directory) {
+  const results = [];
+  let entries;
+  try {
+    entries = await fs.readdir(directory, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await listMarkdownFilesRecursive2(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function sortBySeverityThenImpact(items) {
+  return items.sort((a, b) => {
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    const sevCompare = severityOrder[a.severity] - severityOrder[b.severity];
+    return sevCompare !== 0 ? sevCompare : b.impact - a.impact;
+  });
+}
+function sortBySeverityThenHours(items) {
+  const tiebreakMinutes = (item) => item.expectedRuntimeMinutes ?? item.estimatedHours * 60;
+  return items.sort((a, b) => {
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    const sevCompare = severityOrder[a.severity] - severityOrder[b.severity];
+    return sevCompare !== 0 ? sevCompare : tiebreakMinutes(a) - tiebreakMinutes(b);
+  });
+}
+function applyDebtSchedule(metadata, when) {
+  const now = /* @__PURE__ */ new Date();
+  switch (when) {
+    case "immediate":
+      metadata.executeBy = now.toISOString().split("T")[0];
+      metadata.status = "in-progress";
+      break;
+    case "current-sprint": {
+      const currentSprintEnd = new Date(now);
+      currentSprintEnd.setDate(currentSprintEnd.getDate() + 7);
+      metadata.targetCompleteDate = currentSprintEnd.toISOString().split("T")[0];
+      break;
+    }
+    case "next-sprint": {
+      const nextSprintEnd = new Date(now);
+      nextSprintEnd.setDate(nextSprintEnd.getDate() + 14);
+      metadata.targetCompleteDate = nextSprintEnd.toISOString().split("T")[0];
+      break;
+    }
+    case "backlog":
+      delete metadata.executeBy;
+      delete metadata.targetCompleteDate;
+      break;
+  }
+  metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+}
+function markDebtComplete(metadata) {
+  metadata.status = "completed";
+  metadata.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  metadata.archivedAt = (/* @__PURE__ */ new Date()).toISOString();
+  metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+}
+function warnDebtReadError(error, file, operation) {
+  emitWarning(
+    "WS-002G",
+    {
+      taskId: "tech-debt-manager",
+      subsystem: "planning",
+      executionPhase: "execution"
+    },
+    {
+      severity: "WARN" /* WARN */,
+      skipConsole: true,
+      metadata: {
+        error: error instanceof Error ? error.message : String(error),
+        file,
+        operation
+      }
+    }
+  );
+}
+
+// src/core/read-models/next.ts
+async function tryGetGitHeadSha(cwd) {
+  try {
+    const result = await execa("git", ["rev-parse", "HEAD"], { cwd });
+    const sha = result.stdout.trim();
+    return sha.length > 0 ? sha : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var GIT_DIFF_CACHE_TTL_MS = 5 * 60 * 1e3;
+var GIT_DIFF_CACHE_MAX_ENTRIES = 500;
+var gitDiffCache = /* @__PURE__ */ new Map();
+function pruneGitDiffCache(now) {
+  for (const [key, value] of gitDiffCache.entries()) {
+    if (now - value.cachedAt > GIT_DIFF_CACHE_TTL_MS) {
+      gitDiffCache.delete(key);
+    }
+  }
+  if (gitDiffCache.size <= GIT_DIFF_CACHE_MAX_ENTRIES) {
+    return;
+  }
+  const entriesByAge = [...gitDiffCache.entries()].sort((a, b) => a[1].cachedAt - b[1].cachedAt);
+  const overflowCount = gitDiffCache.size - GIT_DIFF_CACHE_MAX_ENTRIES;
+  for (const [key] of entriesByAge.slice(0, overflowCount)) {
+    gitDiffCache.delete(key);
+  }
+}
+async function getChangedFiles(cwd, fromSha, toSha, files) {
+  if (files.length === 0) return [];
+  const sortedFiles = [...files].sort();
+  const cacheKey = `${fromSha}..${toSha}:${sortedFiles.join(",")}`;
+  const now = Date.now();
+  pruneGitDiffCache(now);
+  const cached = gitDiffCache.get(cacheKey);
+  if (cached !== void 0 && now - cached.cachedAt <= GIT_DIFF_CACHE_TTL_MS) {
+    return cached.changedFiles;
+  }
+  try {
+    const result = await execa(
+      "git",
+      ["diff", "--name-only", `${fromSha}..${toSha}`, "--", ...files],
+      {
+        cwd,
+        reject: false
+      }
+    );
+    const changedFiles = result.exitCode === 0 ? result.stdout.split("\n").map((f) => f.trim()).filter((f) => f.length > 0) : [];
+    gitDiffCache.set(cacheKey, { changedFiles, cachedAt: now });
+    pruneGitDiffCache(now);
+    return changedFiles;
+  } catch {
+    return [];
+  }
+}
+function normalizeTitle(title) {
+  return title.normalize("NFD").replace(/[\u0300-\u036f]/g, "").normalize("NFKC").toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+}
+var STOP_WORDS = /* @__PURE__ */ new Set(["the", "and", "for", "with", "from", "that", "this", "then"]);
+var COMMON_VERBS = /* @__PURE__ */ new Set([
+  "add",
+  "fix",
+  "implement",
+  "update",
+  "remove",
+  "delete",
+  "change",
+  "support",
+  "show",
+  "list",
+  "create",
+  "enable",
+  "disable",
+  "allow",
+  "ensure"
+]);
+function areNearDuplicates(title1, title2) {
+  const norm1 = normalizeTitle(title1);
+  const norm2 = normalizeTitle(title2);
+  if (norm1 === norm2) return true;
+  const phrase1 = ` ${norm1} `;
+  const phrase2 = ` ${norm2} `;
+  if (phrase1.includes(phrase2) || phrase2.includes(phrase1)) {
+    const words1 = norm1.split(" ");
+    const words2 = norm2.split(" ");
+    if (Math.min(words1.length, words2.length) >= 3) return true;
+  }
+  const tokens1 = norm1.split(" ").filter((t) => t.length > 2);
+  const tokens2 = norm2.split(" ").filter((t) => t.length > 2);
+  if (tokens1.length === 0 || tokens2.length === 0) return false;
+  const filtered1 = tokens1.filter((t) => !STOP_WORDS.has(t) && !COMMON_VERBS.has(t));
+  const filtered2 = tokens2.filter((t) => !STOP_WORDS.has(t) && !COMMON_VERBS.has(t));
+  if (filtered1.length === 0 || filtered2.length === 0) return false;
+  const set1 = new Set(filtered1);
+  const set2 = new Set(filtered2);
+  const intersection = [...set1].filter((t) => set2.has(t));
+  const smallerSize = Math.min(set1.size, set2.size);
+  const unionSize = (/* @__PURE__ */ new Set([...set1, ...set2])).size;
+  if (smallerSize === 0) return false;
+  const overlapRatio = intersection.length / smallerSize;
+  const jaccardRatio = intersection.length / unionSize;
+  if (smallerSize <= 2) {
+    return overlapRatio >= 0.85 && jaccardRatio >= 0.5;
+  }
+  return overlapRatio >= 0.75 && jaccardRatio >= 0.4;
+}
+function normalizeTaskStatus(rawStatus) {
+  const statusMap = {
+    todo: "todo",
+    in_progress: "in_progress",
+    review: "review",
+    done: "done",
+    blocked: "blocked",
+    cancelled: "cancelled",
+    canceled: "cancelled",
+    pending: "todo",
+    "in-progress": "in_progress",
+    completed: "done",
+    archived: "done"
+  };
+  if (typeof rawStatus !== "string") return "todo";
+  return statusMap[rawStatus] ?? "todo";
+}
+async function getLinkedBacklogEligibility(rootDir) {
+  const linkedCompletedIds = /* @__PURE__ */ new Set();
+  const linkedBlockedIds = /* @__PURE__ */ new Set();
+  const linkedUnsatisfiedDependencyIds = /* @__PURE__ */ new Set();
+  try {
+    const tasksDir = getBucketPathByKind("task", rootDir);
+    const archiveDir = path2.join(tasksDir, "archive");
+    const taskStatuses = /* @__PURE__ */ new Map();
+    const activeTasks = [];
+    const taskFiles = await listMarkdownFiles(tasksDir);
+    for (const file of taskFiles) {
+      try {
+        const { frontMatter } = await readMarkdownFile(file);
+        const taskId = typeof frontMatter.id === "string" ? frontMatter.id : void 0;
+        const status = normalizeTaskStatus(frontMatter.status);
+        if (taskId) {
+          taskStatuses.set(taskId, { status, archived: false });
+        }
+        if (taskId && typeof frontMatter.backlogItemId === "string" && frontMatter.backlogItemId.length > 0) {
+          activeTasks.push({
+            id: taskId,
+            backlogItemId: frontMatter.backlogItemId,
+            status,
+            dependencies: Array.isArray(frontMatter.dependencies) ? frontMatter.dependencies.filter((dep) => typeof dep === "string") : []
+          });
+        }
+      } catch {
+      }
+    }
+    const archivedTaskFiles = await listMarkdownFilesRecursive(archiveDir).catch(() => []);
+    for (const file of archivedTaskFiles) {
+      try {
+        const { frontMatter } = await readMarkdownFile(file);
+        const taskId = typeof frontMatter.id === "string" ? frontMatter.id : void 0;
+        const status = normalizeTaskStatus(frontMatter.status);
+        if (taskId && !taskStatuses.has(taskId)) {
+          taskStatuses.set(taskId, { status, archived: true });
+        }
+        if (typeof frontMatter.backlogItemId === "string" && frontMatter.backlogItemId.length > 0 && (status === "done" || status === "review")) {
+          linkedCompletedIds.add(frontMatter.backlogItemId);
+        }
+      } catch {
+      }
+    }
+    for (const task of activeTasks) {
+      if (task.status === "done" || task.status === "review") {
+        linkedCompletedIds.add(task.backlogItemId);
+        continue;
+      }
+      if (task.status === "blocked") {
+        linkedBlockedIds.add(task.backlogItemId);
+        continue;
+      }
+      if (task.dependencies.length === 0) {
+        continue;
+      }
+      const hasUnsatisfiedDependency = task.dependencies.some((dependencyId) => {
+        const depStatus = taskStatuses.get(dependencyId);
+        if (!depStatus) return true;
+        return depStatus.status !== "done";
+      });
+      if (hasUnsatisfiedDependency) {
+        linkedUnsatisfiedDependencyIds.add(task.backlogItemId);
+      }
+    }
+  } catch {
+  }
+  return {
+    linkedCompletedIds,
+    linkedBlockedIds,
+    linkedUnsatisfiedDependencyIds
+  };
+}
+async function getGraphBlockedBacklogItems(rootDir) {
+  const blocked = /* @__PURE__ */ new Map();
+  try {
+    const context = await loadWorkGraphContext(rootDir);
+    const isSatisfied = (blockerId) => {
+      const blocker = context.itemsById.get(blockerId);
+      if (!blocker) return true;
+      const rawStatus = blocker.frontMatter.status;
+      const status = typeof rawStatus === "string" ? rawStatus : "";
+      return status === "done" || status === "archived" || status === "completed";
+    };
+    for (const [itemId, item] of context.itemsById) {
+      if (item.frontMatter.kind !== "backlog") continue;
+      const view = buildGraphBlockersView(context, itemId);
+      if (!view || view.blockers.length === 0) continue;
+      const unresolved = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const blocker of view.blockers) {
+        if (seen.has(blocker.id)) continue;
+        seen.add(blocker.id);
+        if (!isSatisfied(blocker.id)) {
+          unresolved.push({ id: blocker.id, title: blocker.title });
+        }
+      }
+      if (unresolved.length > 0) {
+        blocked.set(itemId, unresolved);
+      }
+    }
+  } catch {
+  }
+  return blocked;
+}
+async function getArchivedBacklogTitles(rootDir) {
+  const titles = /* @__PURE__ */ new Map();
+  try {
+    const archiveDir = path2.join(getBucketPathByKind("backlog", rootDir), "archive");
+    const files = await listMarkdownFilesRecursive(archiveDir);
+    for (const file of files) {
+      try {
+        const { frontMatter } = await readMarkdownFile(file);
+        if (frontMatter.title && typeof frontMatter.title === "string") {
+          const normalized = normalizeTitle(frontMatter.title);
+          titles.set(normalized, {
+            id: frontMatter.id,
+            title: frontMatter.title
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return titles;
+}
+function extractBodyPreview(body, maxChars = 300) {
+  const withoutTitle = body.replace(/^\s*#[^\n]*\n?/, "").trim();
+  if (withoutTitle.length === 0) return "";
+  const lines = withoutTitle.split(/\r?\n/);
+  while (lines.length > 0) {
+    const firstLine = (lines[0] ?? "").trim();
+    if (firstLine.length === 0 || /^#{1,6}\s+/.test(firstLine)) {
+      lines.shift();
+      continue;
+    }
+    break;
+  }
+  const stripped = lines.join("\n").trim();
+  if (stripped.length === 0) return "";
+  if (stripped.length <= maxChars) return stripped;
+  const truncated = stripped.slice(0, maxChars);
+  const lastSpace = truncated.lastIndexOf(" ");
+  const cutPoint = lastSpace > maxChars * 0.5 ? lastSpace : maxChars;
+  return `${truncated.slice(0, cutPoint)}...`;
+}
+function extractAcceptanceCriteria(body) {
+  const lines = body.split(/\r?\n/);
+  const criteria = [];
+  let inAcceptanceCriteria = false;
+  let inExampleBlock = false;
+  for (const rawLine of lines) {
+    const headingMatch = rawLine.match(/^\s{0,3}#{1,6}\s+(.+?)\s*$/);
+    if (headingMatch) {
+      const heading = headingMatch[1]?.replace(/:\s*$/, "").trim().toLowerCase();
+      if (!inAcceptanceCriteria) {
+        inAcceptanceCriteria = heading === "acceptance criteria";
+        continue;
+      }
+      break;
+    }
+    if (!inAcceptanceCriteria) continue;
+    const line = rawLine.trim();
+    if (line.length === 0) continue;
+    if (/^example\s*:?\s*$/i.test(line)) {
+      inExampleBlock = true;
+      continue;
+    }
+    if (inExampleBlock) continue;
+    const checkboxMatch = line.match(/^- \[(?: |x|X)\]\s+(.+)$/);
+    if (!checkboxMatch) continue;
+    const content = checkboxMatch[1]?.trim() ?? "";
+    if (content.length === 0) continue;
+    if (content.includes("<<<") || content.includes(">>>")) continue;
+    criteria.push(content);
+  }
+  return criteria;
+}
+async function queryNextItems(options) {
+  const { rootDir } = options;
+  const backlogDir = getBucketPathByKind("backlog", rootDir);
+  const requestedKinds = options.kinds ?? [];
+  const shouldQueryBacklog = requestedKinds.length === 0 || requestedKinds.includes("backlog");
+  const backlogExists = shouldQueryBacklog ? await fs2.stat(backlogDir).then(() => true).catch(() => false) : false;
+  if (!backlogExists && !options.includeFindings && requestedKinds.length === 0) {
+    return [];
+  }
+  const inboxItems = backlogExists ? await listBacklogItems(backlogDir, "inbox") : [];
+  const reviewedItems = backlogExists ? await listBacklogItems(backlogDir, "reviewed") : [];
+  const linkedEligibility = backlogExists ? await getLinkedBacklogEligibility(rootDir) : {
+    linkedCompletedIds: /* @__PURE__ */ new Set(),
+    linkedBlockedIds: /* @__PURE__ */ new Set(),
+    linkedUnsatisfiedDependencyIds: /* @__PURE__ */ new Set()
+  };
+  const graphBlockedItems = backlogExists ? await getGraphBlockedBacklogItems(rootDir) : /* @__PURE__ */ new Map();
+  const archivedTitles = backlogExists ? await getArchivedBacklogTitles(rootDir) : /* @__PURE__ */ new Map();
+  const activeProvenanceStatuses = /* @__PURE__ */ new Set([
+    "pr-open",
+    "archive-sync-pending",
+    "delivered-local",
+    "merged",
+    "archived"
+  ]);
+  const provenanceSuppressedIds = /* @__PURE__ */ new Set();
+  const blockedProvenanceReasons = /* @__PURE__ */ new Map();
+  if (backlogExists) {
+    const allCandidateIds = [...inboxItems, ...reviewedItems].map((item) => item.id);
+    await Promise.all(
+      allCandidateIds.map(async (id) => {
+        try {
+          const provenance = await loadBacklogExecutionProvenance(rootDir, id, {
+            cleanupTerminalLocks: false
+          });
+          if (provenance?.status === "executing" && await isBacklogExecutionProvenanceActivelyExecuting(rootDir, provenance)) {
+            provenanceSuppressedIds.add(id);
+          } else if (provenance && activeProvenanceStatuses.has(provenance.status)) {
+            provenanceSuppressedIds.add(id);
+          } else if (provenance?.status === "blocked") {
+            const blockedReason = provenance.errorMessage?.trim();
+            if (blockedReason) {
+              blockedProvenanceReasons.set(id, blockedReason);
+            }
+          }
+        } catch {
+        }
+      })
+    );
+  }
+  const candidates = [];
+  let headSha;
+  const ensureHeadSha = async () => {
+    if (headSha) return headSha;
+    headSha = await tryGetGitHeadSha(rootDir);
+    return headSha;
+  };
+  const processItem = (item, statusLabel) => {
+    if (linkedEligibility.linkedCompletedIds.has(item.id)) {
+      return null;
+    }
+    if (linkedEligibility.linkedBlockedIds.has(item.id)) {
+      return null;
+    }
+    if (linkedEligibility.linkedUnsatisfiedDependencyIds.has(item.id)) {
+      return null;
+    }
+    const openBlockers = graphBlockedItems.get(item.id);
+    if (openBlockers && openBlockers.length > 0 && !options.includeBlocked) {
+      return null;
+    }
+    if (provenanceSuppressedIds.has(item.id)) {
+      return null;
+    }
+    let isDuplicate = false;
+    let duplicateOf;
+    for (const [, archived] of archivedTitles) {
+      if (areNearDuplicates(item.title, archived.title)) {
+        isDuplicate = true;
+        duplicateOf = archived.id;
+        break;
+      }
+    }
+    if (isDuplicate && !options.includeDuplicates) {
+      return null;
+    }
+    const reviewedHeadSha = typeof item.reviewedHeadSha === "string" && item.reviewedHeadSha.length > 0 ? item.reviewedHeadSha : void 0;
+    const reviewedAt = typeof item.reviewedAt === "string" && item.reviewedAt.length > 0 ? item.reviewedAt : void 0;
+    const reviewedFiles = Array.isArray(item.reviewedFiles) && item.reviewedFiles.length > 0 ? item.reviewedFiles : void 0;
+    const blockedReason = blockedProvenanceReasons.get(item.id);
+    const needsRefinement = item.needsRefinement;
+    return {
+      id: item.id,
+      kind: "backlog",
+      title: item.title,
+      priority: item.priority,
+      status: item.status,
+      filePath: path2.join("backlog", `${item.id}.md`),
+      domain: item.domain ?? void 0,
+      complexity: item.complexity ?? void 0,
+      whyIncluded: `${statusLabel} backlog item${item.priority ? ` (${item.priority})` : ""}`,
+      createdAt: item.createdAt ?? void 0,
+      reviewedAt,
+      reviewedHeadSha,
+      reviewedFiles,
+      isDuplicate,
+      duplicateOf,
+      blockedReason,
+      blockedAnswerHint: blockedReason ? `poetic plan backlog execute ${item.id} --answer blockerId=value` : void 0,
+      blockedByOpen: openBlockers && openBlockers.length > 0 ? openBlockers.map((b) => ({ id: b.id, title: b.title })) : void 0,
+      needsRefinement
+    };
+  };
+  for (const item of reviewedItems) {
+    const candidate = processItem(item, "Reviewed");
+    if (candidate) candidates.push(candidate);
+  }
+  for (const item of inboxItems) {
+    const candidate = processItem(item, "Inbox");
+    if (candidate) candidates.push(candidate);
+  }
+  if (options.includeFindings) {
+    const policy = loadIssuePolicy(rootDir);
+    try {
+      const actionableFindings = await listFindings(rootDir, "open");
+      const findingDir = getBucketPathByKind("finding", rootDir);
+      const findingDirRel = path2.relative(rootDir, findingDir);
+      for (const f of actionableFindings) {
+        const priority = severityToPriority(f.severity, policy);
+        candidates.push({
+          id: f.id,
+          kind: "finding",
+          title: f.title,
+          priority,
+          status: f.status,
+          filePath: path2.join(findingDirRel, `${f.id}.md`),
+          whyIncluded: `${f.status} finding (${f.category}${f.severity ? `/${f.severity}` : ""})`
+        });
+      }
+    } catch {
+    }
+    try {
+      const actionableIssues = [
+        ...await listIssues(rootDir, "open"),
+        ...await listIssues(rootDir, "claimed")
+      ];
+      const issueDir = getBucketPathByKind("issue", rootDir);
+      const issueDirRel = path2.relative(rootDir, issueDir);
+      for (const issue of actionableIssues) {
+        const priority = severityToPriority(issue.severity, policy);
+        candidates.push({
+          id: issue.id,
+          kind: "issue",
+          title: issue.title,
+          priority,
+          status: issue.status,
+          filePath: path2.join(issueDirRel, `${issue.id}.md`),
+          whyIncluded: `${issue.status} issue (${issue.category}/${issue.severity})`
+        });
+      }
+    } catch {
+    }
+  }
+  const includeDebt = requestedKinds.includes("debt");
+  const includeParking = requestedKinds.includes("parking");
+  if (includeDebt) {
+    try {
+      const debtDir = getBucketPathByKind("tech-debt", rootDir);
+      const debtExists = await fs2.stat(debtDir).then(() => true).catch(() => false);
+      if (debtExists) {
+        const debtItems = await listAllDebtAsync(false, rootDir);
+        const debtDirRel = path2.relative(rootDir, debtDir);
+        for (const item of debtItems) {
+          if (item.status === "completed") continue;
+          candidates.push({
+            id: item.id,
+            kind: "debt",
+            title: item.title,
+            priority: null,
+            status: item.status,
+            filePath: path2.join(debtDirRel, `${item.id}.md`),
+            domain: item.domain,
+            complexity: item.estimatedComplexity,
+            whyIncluded: `Tech debt (${item.severity}${item.blocking ? ", blocking" : ""})`,
+            createdAt: item.createdAt ?? item.createdDate,
+            severity: item.severity,
+            blocking: item.blocking,
+            effort: item.effort
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  if (includeParking) {
+    try {
+      const parkingDir = getBucketPathByKind("parking-lot", rootDir);
+      const parkingExists = await fs2.stat(parkingDir).then(() => true).catch(() => false);
+      if (parkingExists) {
+        const parkingItems = await listActive(parkingDir);
+        const parkingDirRel = path2.relative(rootDir, parkingDir);
+        const now = /* @__PURE__ */ new Date();
+        for (const item of parkingItems) {
+          const isOverdue = typeof item.reconsiderDate === "string" && item.reconsiderDate.length > 0 ? new Date(item.reconsiderDate) <= now : false;
+          candidates.push({
+            id: item.id,
+            kind: "parking",
+            title: item.title,
+            priority: null,
+            status: item.status,
+            filePath: path2.join(parkingDirRel, `${item.id}.md`),
+            whyIncluded: `Parked item${isOverdue ? " (overdue for reconsideration)" : ""}`,
+            createdAt: item.createdAt,
+            deferralReason: item.deferralReason,
+            reconsiderDate: item.reconsiderDate ?? null,
+            isOverdue
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  const isCrossEntity = requestedKinds.length > 0;
+  const priorityOrder = { P0: 0, P1: 1, P2: 2, P3: 3 };
+  const debtSeverityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  function crossEntityBucket(c) {
+    if (c.kind === "backlog" || c.kind === "task" || c.kind === "finding" || c.kind === "issue") {
+      const p = c.priority ? priorityOrder[c.priority] ?? 4 : 4;
+      return p <= 1 ? 0 : 3;
+    }
+    if (c.kind === "debt") {
+      const sev = c.severity ?? "low";
+      if ((sev === "critical" || sev === "high") && c.blocking) return 1;
+      if (sev === "high") return 2;
+      return 4;
+    }
+    return 5;
+  }
+  candidates.sort((a, b) => {
+    if (isCrossEntity) {
+      const aBucket = crossEntityBucket(a);
+      const bBucket = crossEntityBucket(b);
+      if (aBucket !== bBucket) return aBucket - bBucket;
+      if (aBucket === 5) {
+        const aDate = a.reconsiderDate ?? "9999-12-31";
+        const bDate = b.reconsiderDate ?? "9999-12-31";
+        if (aDate !== bDate) return aDate.localeCompare(bDate);
+        return a.id.localeCompare(b.id);
+      }
+      if (aBucket === 1 || aBucket === 2 || aBucket === 4) {
+        const aSev = debtSeverityOrder[a.severity ?? "low"] ?? 3;
+        const bSev = debtSeverityOrder[b.severity ?? "low"] ?? 3;
+        if (aSev !== bSev) return aSev - bSev;
+        return a.id.localeCompare(b.id);
+      }
+    }
+    const aPriority = a.priority ? priorityOrder[a.priority] ?? 4 : 4;
+    const bPriority = b.priority ? priorityOrder[b.priority] ?? 4 : 4;
+    if (aPriority !== bPriority) return aPriority - bPriority;
+    const statusOrder = { reviewed: 0, inbox: 1 };
+    const aStatus = statusOrder[a.status] ?? 2;
+    const bStatus = statusOrder[b.status] ?? 2;
+    if (aStatus !== bStatus) return aStatus - bStatus;
+    const aCreatedAt = a.createdAt ? Date.parse(a.createdAt) : Number.NaN;
+    const bCreatedAt = b.createdAt ? Date.parse(b.createdAt) : Number.NaN;
+    const aHasCreatedAt = Number.isFinite(aCreatedAt);
+    const bHasCreatedAt = Number.isFinite(bCreatedAt);
+    if (aHasCreatedAt && bHasCreatedAt && aCreatedAt !== bCreatedAt) {
+      return aCreatedAt - bCreatedAt;
+    }
+    if (aHasCreatedAt !== bHasCreatedAt) {
+      return aHasCreatedAt ? -1 : 1;
+    }
+    return a.id.localeCompare(b.id);
+  });
+  const limitedCandidates = options.limit ? candidates.slice(0, options.limit) : candidates;
+  const candidatesWithSha = limitedCandidates.filter((c) => c.reviewedHeadSha);
+  if (candidatesWithSha.length > 0) {
+    const currentHead = await ensureHeadSha();
+    if (currentHead) {
+      for (const candidate of candidatesWithSha) {
+        if (!candidate.reviewedHeadSha) continue;
+        if (candidate.reviewedHeadSha === currentHead) {
+          continue;
+        }
+        if (candidate.reviewedFiles && candidate.reviewedFiles.length > 0) {
+          const changedFiles = await getChangedFiles(
+            rootDir,
+            candidate.reviewedHeadSha,
+            currentHead,
+            candidate.reviewedFiles
+          );
+          if (changedFiles.length > 0) {
+            candidate.isStaleReview = true;
+            candidate.staleReason = "files_changed";
+            candidate.whyIncluded = `${candidate.whyIncluded} (needs re-review: ${changedFiles.length} file(s) changed)`;
+          }
+        } else {
+          candidate.isStaleReview = true;
+          candidate.staleReason = "head_changed";
+          candidate.whyIncluded = `${candidate.whyIncluded} (needs re-review)`;
+        }
+      }
+    }
+  }
+  if (options.context) {
+    for (const candidate of limitedCandidates) {
+      if (candidate.kind !== "backlog") continue;
+      try {
+        const item = await findBacklogItem(backlogDir, candidate.id);
+        if (item?.body) {
+          candidate.bodyPreview = extractBodyPreview(item.body);
+          const criteria = extractAcceptanceCriteria(item.body);
+          if (criteria.length > 0) {
+            candidate.acceptanceCriteria = criteria;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return limitedCandidates;
+}
+function parseKindOption(raw) {
+  if (!raw) return [];
+  const validKinds = /* @__PURE__ */ new Set(["backlog", "debt", "parking", "all"]);
+  const parts = raw.split(",").map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0);
+  const invalidKinds = parts.filter((kind) => !validKinds.has(kind));
+  if (invalidKinds.length > 0) {
+    throw new Error(`Unknown --kind value(s): ${invalidKinds.join(", ")}`);
+  }
+  if (parts.includes("all")) {
+    return ["backlog", "debt", "parking"];
+  }
+  return [...new Set(parts)];
+}
+
+export {
+  getDebtItemAsync,
+  createDebtItemAsync,
+  updateDebtItemAsync,
+  listByBlockingAsync,
+  listByParallelizableAsync,
+  scheduleDebtAsync,
+  completeDebtAsync,
+  listAllDebtAsync,
+  areNearDuplicates,
+  extractBodyPreview,
+  extractAcceptanceCriteria,
+  queryNextItems,
+  parseKindOption
+};
+//# sourceMappingURL=chunk-NRNE225N.js.map