@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-S6TAFQI5.js

@@ -0,0 +1,2403 @@
+import {
+  estimateRuntime
+} from "./chunk-RNI2GUIF.js";
+import {
+  listActive
+} from "./chunk-Q6Z5UGPL.js";
+import {
+  findBacklogItem,
+  listBacklogItems,
+  validateDebtItem
+} from "./chunk-NKLPMBNV.js";
+import {
+  isBacklogExecutionProvenanceActivelyExecuting,
+  loadBacklogExecutionProvenance
+} from "./chunk-3WY5TU2O.js";
+import {
+  DEFAULT_LEASE_TTL_MS,
+  HumanReviewRequiredError,
+  InvalidTransitionError,
+  LeaseExpiredError,
+  loadSprintCompletedTaskIds
+} from "./chunk-R5EXHMUN.js";
+import {
+  normalizeTaskStatus
+} from "./chunk-NAINGKHF.js";
+import {
+  getArchivedFilePath
+} from "./chunk-US3RT6CY.js";
+import {
+  buildGraphBlockersView,
+  loadWorkGraphContext
+} from "./chunk-PV53ODOT.js";
+import {
+  classifyTaskDependency
+} from "./chunk-NXH3RX7O.js";
+import {
+  keepActivity
+} from "./chunk-J2QCFLUN.js";
+import {
+  getPlanningRoot,
+  withIndexRegeneration
+} from "./chunk-CSXLLEGB.js";
+import {
+  generateIndexes
+} from "./chunk-VAG6GUBR.js";
+import {
+  createWorkItemFile
+} from "./chunk-CIHWPGS5.js";
+import {
+  isExpiryLive
+} from "./chunk-6G57FYBV.js";
+import {
+  assertBucketWriteAvailable,
+  checkSharedBucketReadability,
+  planningReadOk,
+  unwrapPlanningRead
+} from "./chunk-AJBTKGJZ.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketByName,
+  getBucketPathByKind
+} from "./chunk-V3KLVK7B.js";
+import {
+  LocalFileBackend,
+  checkVersion
+} from "./chunk-4US4SYJ4.js";
+import {
+  StaleVersionError
+} from "./chunk-TDSEX5CF.js";
+import {
+  resolvePlanningContextForRoot
+} from "./chunk-BBPIILO2.js";
+import {
+  assertSafePathComponent
+} from "./chunk-S2VQCZO4.js";
+import {
+  generateId
+} from "./chunk-4DJL2VXA.js";
+import {
+  listMarkdownFiles,
+  listMarkdownFilesRecursive,
+  normalizeMarkdownContent,
+  parseMarkdownFile,
+  readMarkdownFile,
+  writeMarkdownFile
+} from "./chunk-352PCJLK.js";
+import {
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/read-models/next.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+import { execa } from "execa";
+
+// src/planning/issue-manager.ts
+import * as path from "path";
+
+// src/planning/issue-fingerprint.ts
+import { createHash } from "crypto";
+function normalizeSnippet(snippet) {
+  return snippet.split("\n").map((line) => line.trim()).filter((line, i, arr) => !(line === "" && arr[i - 1] === "")).join("\n").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+}
+function normalizePath(filepath) {
+  return filepath.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
+}
+function sha256(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+function generateFingerprint(input) {
+  const normalizedSnippet = normalizeSnippet(input.snippet);
+  const normalizedPath = normalizePath(input.path);
+  const snippetHash = sha256(normalizedSnippet);
+  const compositeInput = [input.ruleId, snippetHash, input.symbolName ?? "", normalizedPath].join(
+    "\0"
+  );
+  const compositeHash = sha256(compositeInput);
+  return {
+    ruleId: input.ruleId,
+    snippetHash,
+    symbolName: input.symbolName,
+    path: normalizedPath,
+    compositeHash
+  };
+}
+function matchFingerprint(candidate, existing) {
+  if (candidate.compositeHash === existing.compositeHash) {
+    return "exact";
+  }
+  if (candidate.ruleId === existing.ruleId && candidate.symbolName && existing.symbolName && candidate.symbolName === existing.symbolName) {
+    return "fuzzy";
+  }
+  return "none";
+}
+function findDuplicate(candidate, existingFingerprints) {
+  let bestExact = null;
+  let bestFuzzy = null;
+  for (const existing of existingFingerprints) {
+    const strength = matchFingerprint(candidate, existing.fingerprint);
+    if (strength === "exact") {
+      if (!bestExact || existing.findingId < bestExact.existingFindingId) {
+        bestExact = {
+          strength: "exact",
+          existingFindingId: existing.findingId,
+          fingerprint: existing.fingerprint
+        };
+      }
+      continue;
+    }
+    if (strength === "fuzzy") {
+      const confidence = computeFuzzyConfidence(candidate, existing.fingerprint);
+      const reason = describeFuzzyMatch(candidate, existing.fingerprint);
+      if (!bestFuzzy || confidence > (bestFuzzy.confidence ?? 0) || Math.abs(confidence - (bestFuzzy.confidence ?? 0)) < Number.EPSILON && existing.findingId < bestFuzzy.existingFindingId) {
+        bestFuzzy = {
+          strength: "fuzzy",
+          existingFindingId: existing.findingId,
+          fingerprint: existing.fingerprint,
+          confidence,
+          reason
+        };
+      }
+    }
+  }
+  if (bestExact) return bestExact;
+  return bestFuzzy;
+}
+function computeFuzzyConfidence(candidate, existing) {
+  let confidence = 0.55;
+  if (candidate.snippetHash === existing.snippetHash) confidence += 0.25;
+  if (candidate.path === existing.path) confidence += 0.2;
+  return Math.min(1, confidence);
+}
+function describeFuzzyMatch(candidate, existing) {
+  const details = ["matched ruleId + symbolName"];
+  details.push(
+    candidate.snippetHash === existing.snippetHash ? "same snippet hash" : "different snippet hash"
+  );
+  details.push(candidate.path === existing.path ? "same path" : "different path");
+  return details.join("; ");
+}
+function trackOccurrence(currentCount, now = /* @__PURE__ */ new Date()) {
+  return {
+    lastSeenAt: now.toISOString(),
+    occurrenceCount: currentCount + 1
+  };
+}
+
+// src/planning/issue-state-machine.ts
+var FINDING_TRANSITIONS = {
+  raw: ["open", "closed"],
+  open: ["closed"],
+  closed: []
+};
+var ISSUE_TRANSITIONS = {
+  open: ["claimed", "investigating", "wontfix", "duplicate"],
+  claimed: ["claimed", "resolved", "open", "wontfix", "duplicate", "investigating"],
+  investigating: ["claimed", "open", "resolved", "wontfix", "duplicate"],
+  resolved: [],
+  // terminal
+  wontfix: [],
+  // terminal
+  duplicate: []
+  // terminal
+};
+function requiresHumanActorForIssue(toStatus, category, severity) {
+  if (toStatus === "wontfix" && (category === "security" || severity === "critical")) {
+    return true;
+  }
+  return false;
+}
+function requiresHumanActorForFinding(finding, toStatus) {
+  return finding.status === "raw" && toStatus === "open" && finding.requiresHumanReview;
+}
+function isEffectivelyClaimed(entity, now = /* @__PURE__ */ new Date()) {
+  if (!entity.claimedBy || !entity.expiresAt) return false;
+  return isExpiryLive(entity.expiresAt, now.toISOString());
+}
+function assertClaimTransitionAuthorized(issue, toStatus, actor, now) {
+  const carriesClaim = issue.status === "claimed" || issue.status === "investigating" && issue.claimedBy !== void 0;
+  if (!carriesClaim || toStatus === "claimed") return;
+  if (issue.claimedBy !== actor.actorId) {
+    throw new InvalidTransitionError(
+      issue.id,
+      issue.status,
+      toStatus,
+      `Only the claimant ${issue.claimedBy ?? "unknown"} can transition an owned issue`
+    );
+  }
+  if (!isEffectivelyClaimed(issue, now)) {
+    throw new LeaseExpiredError(issue.id, issue.expiresAt ?? "unknown");
+  }
+}
+function transitionFinding(input) {
+  const { finding, toStatus, actor, expectedVersion, closedReason, fixCommit, deferredNote } = input;
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const nowISO = now.toISOString();
+  checkVersion(finding.id, finding.version, expectedVersion);
+  const allowed = FINDING_TRANSITIONS[finding.status];
+  if (!allowed.includes(toStatus)) {
+    throw new InvalidTransitionError(finding.id, finding.status, toStatus);
+  }
+  if (requiresHumanActorForFinding(finding, toStatus) && actor.actorType !== "human") {
+    throw new HumanReviewRequiredError(
+      finding.id,
+      `${finding.status} \u2192 ${toStatus}`,
+      finding.category,
+      finding.severity
+    );
+  }
+  if (toStatus === "closed" && !closedReason) {
+    throw new InvalidTransitionError(
+      finding.id,
+      finding.status,
+      toStatus,
+      "closedReason is required when closing a finding"
+    );
+  }
+  const updated = {
+    ...finding,
+    status: toStatus,
+    version: finding.version + 1,
+    updatedAt: nowISO
+  };
+  if (toStatus === "closed") {
+    updated.closedReason = closedReason;
+    updated.closedBy = actor;
+    updated.closedAt = nowISO;
+    if (fixCommit) updated.fixCommit = fixCommit;
+    if (deferredNote) updated.deferredNote = deferredNote;
+  }
+  return updated;
+}
+function transitionIssue(input) {
+  const { issue, toStatus, actor, expectedVersion, resolution, leaseTtlMs } = input;
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const nowISO = now.toISOString();
+  checkVersion(issue.id, issue.version, expectedVersion);
+  const allowed = ISSUE_TRANSITIONS[issue.status];
+  if (!allowed.includes(toStatus)) {
+    throw new InvalidTransitionError(issue.id, issue.status, toStatus);
+  }
+  assertClaimTransitionAuthorized(issue, toStatus, actor, now);
+  if (requiresHumanActorForIssue(toStatus, issue.category, issue.severity)) {
+    if (actor.actorType !== "human") {
+      throw new HumanReviewRequiredError(
+        issue.id,
+        `${issue.status} \u2192 ${toStatus}`,
+        issue.category,
+        issue.severity
+      );
+    }
+  }
+  const updated = {
+    ...issue,
+    status: toStatus,
+    version: issue.version + 1,
+    updatedAt: nowISO
+  };
+  switch (toStatus) {
+    case "claimed": {
+      if (isEffectivelyClaimed(issue, now) && issue.claimedBy !== actor.actorId) {
+        throw new InvalidTransitionError(
+          issue.id,
+          issue.status,
+          toStatus,
+          `Already claimed by ${issue.claimedBy}`
+        );
+      }
+      const ttl = getValidLeaseTtlMs(leaseTtlMs, issue.id, issue.status, toStatus);
+      updated.claimedBy = actor.actorId;
+      updated.claimedAt = nowISO;
+      updated.expiresAt = new Date(now.getTime() + ttl).toISOString();
+      break;
+    }
+    case "resolved":
+      if (!resolution) {
+        throw new InvalidTransitionError(
+          issue.id,
+          issue.status,
+          toStatus,
+          "Resolution required when resolving"
+        );
+      }
+      updated.resolution = resolution;
+      updated.resolvedBy = actor;
+      updated.resolvedAt = nowISO;
+      if (input.fixCommit !== void 0) {
+        const fixCommit = input.fixCommit.trim();
+        if (fixCommit.length === 0) {
+          throw new InvalidTransitionError(
+            issue.id,
+            issue.status,
+            toStatus,
+            "fixCommit must be a non-empty string when provided"
+          );
+        }
+        updated.fixCommit = fixCommit;
+      }
+      if (input.fixPr !== void 0) {
+        if (!Number.isInteger(input.fixPr) || input.fixPr <= 0) {
+          throw new InvalidTransitionError(
+            issue.id,
+            issue.status,
+            toStatus,
+            "fixPr must be a positive integer when provided"
+          );
+        }
+        updated.fixPr = input.fixPr;
+      }
+      updated.claimedBy = void 0;
+      updated.claimedAt = void 0;
+      updated.expiresAt = void 0;
+      break;
+    case "open":
+      updated.claimedBy = void 0;
+      updated.claimedAt = void 0;
+      updated.expiresAt = void 0;
+      break;
+    case "investigating":
+      break;
+    case "wontfix":
+    case "duplicate":
+      updated.claimedBy = void 0;
+      updated.claimedAt = void 0;
+      updated.expiresAt = void 0;
+      break;
+  }
+  return updated;
+}
+function promoteFinding(input) {
+  const { finding, issueId, actor, expectedVersion } = input;
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const nowISO = now.toISOString();
+  const updatedFinding = transitionFinding({
+    finding,
+    toStatus: "closed",
+    actor,
+    expectedVersion,
+    now,
+    closedReason: "promoted"
+  });
+  const newIssue = {
+    id: issueId,
+    kind: "issue",
+    title: finding.title,
+    status: "open",
+    version: 1,
+    severity: finding.severity ?? "medium",
+    category: finding.category,
+    findingIds: [finding.id],
+    originProvenance: { ...finding.reportedBy },
+    relatedIssues: [],
+    createdAt: nowISO,
+    updatedAt: nowISO
+  };
+  return { updatedFinding, newIssue };
+}
+function renewLease(input) {
+  const { entity, actor, expectedVersion, leaseTtlMs } = input;
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  checkVersion(entity.id, entity.version, expectedVersion);
+  if (entity.claimedBy !== actor.actorId) {
+    throw new InvalidTransitionError(
+      entity.id,
+      entity.status,
+      entity.status,
+      "Only the claimant can renew the lease"
+    );
+  }
+  if (!isEffectivelyClaimed(entity, now)) {
+    throw new LeaseExpiredError(entity.id, entity.expiresAt ?? "unknown");
+  }
+  const ttl = getValidLeaseTtlMs(leaseTtlMs, entity.id, entity.status, entity.status);
+  return {
+    ...entity,
+    version: entity.version + 1,
+    expiresAt: new Date(now.getTime() + ttl).toISOString(),
+    updatedAt: now.toISOString()
+  };
+}
+function getValidLeaseTtlMs(leaseTtlMs, entityId, fromStatus, toStatus) {
+  const ttl = leaseTtlMs ?? DEFAULT_LEASE_TTL_MS;
+  if (!Number.isFinite(ttl) || ttl <= 0) {
+    throw new InvalidTransitionError(
+      entityId,
+      fromStatus,
+      toStatus,
+      "Lease TTL must be a positive finite number"
+    );
+  }
+  return ttl;
+}
+function matchesSuppression(finding, suppressions, now = /* @__PURE__ */ new Date()) {
+  for (const s of suppressions) {
+    if (s.expiresAt && new Date(s.expiresAt) <= now) continue;
+    const ruleMatch = !s.ruleId || s.ruleId === finding.fingerprint.ruleId;
+    const pathMatch = !s.pathGlob || matchGlob(s.pathGlob, finding.fingerprint.path);
+    if (ruleMatch && pathMatch) return s;
+  }
+  return null;
+}
+function matchGlob(pattern, filepath) {
+  const GLOBSTAR = "\0GLOBSTAR\0";
+  const GLOB = "\0GLOB\0";
+  const QMARK = "\0QMARK\0";
+  const tokenized = pattern.replace(/\*\*/g, GLOBSTAR).replace(/\*/g, GLOB).replace(/\?/g, QMARK);
+  const escaped = tokenized.replace(/[-/\\^$+?.()|[\]{}]/g, "\\$&");
+  const regexStr = escaped.replaceAll(GLOBSTAR, ".*").replaceAll(GLOB, "[^/]*").replaceAll(QMARK, "[^/]");
+  return new RegExp(`^${regexStr}$`).test(filepath);
+}
+function evaluateIngest(finding, suppressions, now = /* @__PURE__ */ new Date()) {
+  const matched = matchesSuppression(finding, suppressions, now);
+  if (matched) {
+    return {
+      status: "closed",
+      requiresHumanReview: false,
+      matchedSuppression: matched,
+      closedReason: "dismissed",
+      closedBy: {
+        actorType: "system",
+        actorId: `suppression:${matched.id}`
+      },
+      closedAt: now.toISOString()
+    };
+  }
+  const needsHuman = finding.category === "security" || finding.severity === "critical";
+  return { status: "raw", requiresHumanReview: needsHuman };
+}
+
+// src/planning/issue-validation.ts
+var DEFAULT_CONSENSUS_CONFIG = {
+  minValidations: 2,
+  confirmedThreshold: 0.67,
+  rejectedThreshold: 0.67,
+  minAverageConfidence: 0.7
+};
+function appendValidation(input) {
+  const { finding, validation, expectedVersion } = input;
+  if (finding.version !== expectedVersion) {
+    throw new StaleVersionError(finding.version, expectedVersion, finding.id);
+  }
+  const updatedValidations = [...finding.validations, validation];
+  const validatorConfidence = updatedValidations.length > 0 ? updatedValidations.reduce((sum, v) => sum + v.confidence, 0) / updatedValidations.length : void 0;
+  return {
+    ...finding,
+    validations: updatedValidations,
+    validatorConfidence,
+    version: finding.version + 1,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function appendObservation(input) {
+  const { finding, observation, expectedVersion } = input;
+  if (finding.version !== expectedVersion) {
+    throw new StaleVersionError(finding.version, expectedVersion, finding.id);
+  }
+  const observations = getObservations(finding);
+  return {
+    ...finding,
+    observations: [...observations, observation],
+    version: finding.version + 1,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function getObservations(finding) {
+  if (Array.isArray(finding.observations) && finding.observations.length > 0) {
+    return finding.observations;
+  }
+  return [
+    createObservation(
+      finding.reportedBy,
+      finding.reporterConfidence,
+      finding.severity,
+      finding.codeLocations,
+      new Date(finding.reportedAt)
+    )
+  ];
+}
+function computeAgreement(finding) {
+  const identities = new Set(
+    getObservations(finding).map((observation) => observationIdentity(observation.reporter))
+  );
+  return identities.size;
+}
+function computeConsensus(finding, config = DEFAULT_CONSENSUS_CONFIG) {
+  const validations = finding.validations;
+  const count = validations.length;
+  if (count < config.minValidations) {
+    return {
+      outcome: "insufficient",
+      validationCount: count,
+      confirmedCount: validations.filter((v) => v.verdict === "confirmed").length,
+      rejectedCount: validations.filter((v) => v.verdict === "rejected").length,
+      uncertainCount: validations.filter((v) => v.verdict === "uncertain").length,
+      averageConfidence: count > 0 ? validations.reduce((s, v) => s + v.confidence, 0) / count : 0,
+      autoTriageRecommended: false
+    };
+  }
+  const confirmedCount = validations.filter((v) => v.verdict === "confirmed").length;
+  const rejectedCount = validations.filter((v) => v.verdict === "rejected").length;
+  const uncertainCount = validations.filter((v) => v.verdict === "uncertain").length;
+  const avgConfidence = validations.reduce((s, v) => s + v.confidence, 0) / count;
+  const confirmedRatio = confirmedCount / count;
+  const rejectedRatio = rejectedCount / count;
+  let outcome;
+  if (confirmedRatio >= config.confirmedThreshold) {
+    outcome = "confirmed";
+  } else if (rejectedRatio >= config.rejectedThreshold) {
+    outcome = "rejected";
+  } else {
+    outcome = "uncertain";
+  }
+  const isGated = finding.category === "security" || finding.severity === "critical";
+  const meetsConfidence = avgConfidence >= config.minAverageConfidence;
+  const autoTriageRecommended = !isGated && meetsConfidence && outcome !== "uncertain";
+  let recommendedStatus;
+  if (autoTriageRecommended) {
+    recommendedStatus = outcome === "confirmed" ? "triaged" : "rejected";
+  }
+  return {
+    outcome,
+    validationCount: count,
+    confirmedCount,
+    rejectedCount,
+    uncertainCount,
+    averageConfidence: avgConfidence,
+    autoTriageRecommended,
+    recommendedStatus
+  };
+}
+function createValidation(validator, verdict, confidence, reasoning, now = /* @__PURE__ */ new Date()) {
+  if (!Number.isFinite(confidence)) {
+    throw new Error(
+      `Validation confidence must be a finite number, received: ${String(confidence)}`
+    );
+  }
+  return {
+    validator,
+    verdict,
+    confidence: Math.max(0, Math.min(1, confidence)),
+    reasoning,
+    validatedAt: now.toISOString()
+  };
+}
+function createObservation(reporter, confidence, severity, codeLocations, now = /* @__PURE__ */ new Date()) {
+  if (!Number.isFinite(confidence)) {
+    throw new Error(
+      `Observation confidence must be a finite number, received: ${String(confidence)}`
+    );
+  }
+  return {
+    reporter,
+    confidence: Math.max(0, Math.min(1, confidence)),
+    ...severity ? { severity } : {},
+    codeLocations,
+    observedAt: Number.isNaN(now.getTime()) ? (/* @__PURE__ */ new Date()).toISOString() : now.toISOString()
+  };
+}
+function observationIdentity(reporter) {
+  return `${reporter.provider}:${reporter.model}:${reporter.harness}`;
+}
+
+// src/planning/issue-manager.ts
+function getCoordBackend(repoRoot) {
+  return new LocalFileBackend(path.join(repoRoot, ".build-project", "planning", "coordination"));
+}
+async function withEntityLock(repoRoot, entityId, fn) {
+  const backend = getCoordBackend(repoRoot);
+  const DELAYS_MS = [0, 100, 200, 400, 800, 1600, 2400, 2500];
+  let handle = null;
+  for (let attempt = 0; attempt < DELAYS_MS.length; attempt++) {
+    const delay = DELAYS_MS[attempt] ?? 0;
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    handle = await backend.acquireLock(entityId);
+    if (handle !== null) break;
+  }
+  if (handle === null) {
+    const lockPath = path.join(
+      repoRoot,
+      ".build-project",
+      "planning",
+      "coordination",
+      "locks",
+      `${entityId.replace(/[/\\]/g, "_")}.lock`
+    );
+    throw new Error(
+      `Could not acquire lock for entity ${entityId} after retries. Lock path: ${lockPath}. Another process may be writing to this entity.`
+    );
+  }
+  try {
+    return await fn();
+  } finally {
+    await backend.releaseLock(handle);
+  }
+}
+var warnedMalformedFindingFiles = /* @__PURE__ */ new Set();
+var warnedMalformedIssueFiles = /* @__PURE__ */ new Set();
+async function createFinding(repoRoot, options) {
+  return withIndexRegeneration(repoRoot, async () => {
+    const now = /* @__PURE__ */ new Date();
+    const nowISO = now.toISOString();
+    const fp = generateFingerprint(options.fingerprint);
+    const observation = createObservation(
+      options.reportedBy,
+      options.reporterConfidence,
+      options.severity,
+      options.codeLocations,
+      now
+    );
+    const ingest = evaluateIngest(
+      { fingerprint: fp, category: options.category, severity: options.severity },
+      options.suppressions ?? [],
+      now
+    );
+    const findingMeta = {
+      kind: "finding",
+      title: options.title,
+      status: ingest.status,
+      version: 1,
+      reportedBy: options.reportedBy,
+      reportedAt: nowISO,
+      observations: [observation],
+      reporterConfidence: options.reporterConfidence,
+      severity: options.severity,
+      category: options.category,
+      fingerprint: fp,
+      codeLocations: options.codeLocations,
+      validations: [],
+      firstSeenAt: nowISO,
+      lastSeenAt: nowISO,
+      occurrenceCount: 1,
+      requiresHumanReview: ingest.requiresHumanReview,
+      detectionRunId: options.detectionRunId,
+      traceId: options.traceId,
+      spanId: options.spanId,
+      createdAt: nowISO,
+      updatedAt: nowISO,
+      closedReason: ingest.closedReason,
+      closedBy: ingest.closedBy,
+      closedAt: ingest.closedAt
+    };
+    const result = await createWorkItemFile({
+      repoRoot,
+      bucket: "finding",
+      title: options.title,
+      description: options.body?.trim() || "",
+      metadata: stripUndefined(findingMeta)
+    });
+    const finding = { ...findingMeta, id: result.id };
+    return {
+      id: result.id,
+      filePath: result.path,
+      finding,
+      suppressed: ingest.status === "closed"
+    };
+  });
+}
+async function readFinding(repoRoot, findingId) {
+  const findingDir = getBucketPathByKind("finding", repoRoot);
+  const safeFindingId = assertSafePathComponent(findingId, "findingId");
+  const filePath = path.join(findingDir, `${safeFindingId}.md`);
+  let finding;
+  let body;
+  try {
+    ({ yaml: finding, body } = await parseMarkdownFile(filePath));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Finding not found: ${findingId}`);
+    }
+    throw error;
+  }
+  return { finding: normalizeFindingForRead(finding), body, filePath };
+}
+async function updateFinding(repoRoot, findingId, expectedVersion, updates, bodyOverride) {
+  return withIndexRegeneration(
+    repoRoot,
+    () => withEntityLock(repoRoot, findingId, async () => {
+      const { finding, body, filePath } = await readFinding(repoRoot, findingId);
+      if (finding.version !== expectedVersion) {
+        throw new StaleVersionError(finding.version, expectedVersion, findingId);
+      }
+      const updated = {
+        ...finding,
+        ...updates,
+        version: finding.version + 1,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const nextBody = typeof bodyOverride === "string" ? bodyOverride : body;
+      await writeMarkdownFile(
+        filePath,
+        stripUndefined(updated),
+        nextBody
+      );
+      return updated;
+    })
+  );
+}
+async function transitionFindingStatus(repoRoot, findingId, input) {
+  return withIndexRegeneration(
+    repoRoot,
+    () => withEntityLock(repoRoot, findingId, async () => {
+      const { finding, body, filePath } = await readFinding(repoRoot, findingId);
+      const updated = transitionFinding({ ...input, finding });
+      await writeMarkdownFile(
+        filePath,
+        stripUndefined(updated),
+        body
+      );
+      return updated;
+    })
+  );
+}
+async function listFindings(repoRoot, statusFilter, closedReasonFilter) {
+  const findingDir = getBucketPathByKind("finding", repoRoot);
+  const files = await listMarkdownFiles(findingDir);
+  const results = [];
+  for (const file of files) {
+    try {
+      const { yaml: finding } = await parseMarkdownFile(file);
+      if (statusFilter && finding.status !== statusFilter) continue;
+      if (closedReasonFilter && finding.closedReason !== closedReasonFilter) continue;
+      results.push({
+        id: finding.id,
+        title: finding.title,
+        status: finding.status,
+        severity: finding.severity,
+        category: finding.category,
+        version: finding.version,
+        closedReason: finding.closedReason
+      });
+    } catch (error) {
+      warnMalformedFile(repoRoot, file, "finding", error, warnedMalformedFindingFiles);
+    }
+  }
+  return results;
+}
+async function readIssue(repoRoot, issueId) {
+  const issueDir = getBucketPathByKind("issue", repoRoot);
+  const safeIssueId = assertSafePathComponent(issueId, "issueId");
+  const filePath = path.join(issueDir, `${safeIssueId}.md`);
+  let issue;
+  let body;
+  try {
+    ({ yaml: issue, body } = await parseMarkdownFile(filePath));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Issue not found: ${issueId}`);
+    }
+    throw error;
+  }
+  return { issue, body, filePath };
+}
+async function transitionIssueStatus(repoRoot, issueId, input) {
+  return withIndexRegeneration(
+    repoRoot,
+    () => withEntityLock(repoRoot, issueId, async () => {
+      const { issue, body, filePath } = await readIssue(repoRoot, issueId);
+      const updated = transitionIssue({ ...input, issue });
+      await writeMarkdownFile(
+        filePath,
+        stripUndefined(updated),
+        body
+      );
+      return updated;
+    })
+  );
+}
+async function listIssues(repoRoot, statusFilter) {
+  const issueDir = getBucketPathByKind("issue", repoRoot);
+  const files = await listMarkdownFiles(issueDir);
+  const results = [];
+  for (const file of files) {
+    try {
+      const { yaml: issue } = await parseMarkdownFile(file);
+      if (statusFilter && issue.status !== statusFilter) continue;
+      results.push({
+        id: issue.id,
+        title: issue.title,
+        status: issue.status,
+        severity: issue.severity,
+        category: issue.category,
+        version: issue.version,
+        claimed: isEffectivelyClaimed(issue),
+        findingIds: issue.findingIds ?? []
+      });
+    } catch (error) {
+      warnMalformedFile(repoRoot, file, "issue", error, warnedMalformedIssueFiles);
+    }
+  }
+  return results;
+}
+var FindingPublishConsentError = class extends Error {
+  constructor(findingId) {
+    super(
+      `Refusing to promote finding ${findingId}: promotion creates a TRACKED issue whose body is copied verbatim from this local-only finding (file paths, code snippets, scanner detail) and is then committed and pushed. Re-run with explicit publish consent (--yes-publish-issue) to cross the local\u2192published boundary.`
+    );
+    this.name = "FindingPublishConsentError";
+  }
+};
+async function promoteFindingToIssue(repoRoot, findingId, actor, options = {}) {
+  if (!options.publishIssue) {
+    throw new FindingPublishConsentError(findingId);
+  }
+  return withIndexRegeneration(
+    repoRoot,
+    () => withEntityLock(repoRoot, findingId, async () => {
+      const { finding, body, filePath } = await readFinding(repoRoot, findingId);
+      const now = /* @__PURE__ */ new Date();
+      const issueId = generateId(now);
+      const { updatedFinding, newIssue } = promoteFinding({
+        finding,
+        issueId,
+        actor,
+        expectedVersion: finding.version,
+        now
+      });
+      await writeMarkdownFile(
+        filePath,
+        stripUndefined(updatedFinding),
+        body
+      );
+      const issueDir = getBucketPathByKind("issue", repoRoot);
+      const issueFilePath = path.join(issueDir, `${issueId}.md`);
+      await writeMarkdownFile(
+        issueFilePath,
+        stripUndefined(newIssue),
+        body
+      );
+      return { finding: updatedFinding, issue: newIssue, issueFilePath };
+    })
+  );
+}
+async function renewEntityLease(repoRoot, entityId, actor, expectedVersion, leaseTtlMs) {
+  return withIndexRegeneration(
+    repoRoot,
+    () => withEntityLock(repoRoot, entityId, async () => {
+      const { issue, body, filePath } = await readIssue(repoRoot, entityId);
+      const updated = renewLease({
+        entity: issue,
+        actor,
+        expectedVersion,
+        leaseTtlMs
+      });
+      await writeMarkdownFile(
+        filePath,
+        stripUndefined(updated),
+        body
+      );
+    })
+  );
+}
+async function validateFinding(repoRoot, findingId, input, consensusConfig) {
+  return withIndexRegeneration(
+    repoRoot,
+    () => withEntityLock(repoRoot, findingId, async () => {
+      const { finding, body, filePath } = await readFinding(repoRoot, findingId);
+      const validation = createValidation(
+        input.validator,
+        input.verdict,
+        input.confidence,
+        input.reasoning
+      );
+      const updated = appendValidation({
+        finding,
+        validation,
+        expectedVersion: input.expectedVersion
+      });
+      await writeMarkdownFile(
+        filePath,
+        stripUndefined(updated),
+        body
+      );
+      const consensus = computeConsensus(updated, consensusConfig);
+      return { finding: updated, consensus };
+    })
+  );
+}
+async function getConsensus(repoRoot, findingId, consensusConfig) {
+  const { finding } = await readFinding(repoRoot, findingId);
+  return computeConsensus(finding, consensusConfig);
+}
+async function spawnTaskFromIssue(repoRoot, issueId, sprintId, actor, expectedVersion, taskOptions = {}) {
+  const { createTask } = await import("./task-manager-LHPBBRRE.js");
+  return withIndexRegeneration(
+    repoRoot,
+    () => withEntityLock(repoRoot, issueId, async () => {
+      const { issue, body, filePath } = await readIssue(repoRoot, issueId);
+      const now = /* @__PURE__ */ new Date();
+      if (issue.spawnedTask) {
+        throw new Error(`Issue ${issueId} already has spawned task: ${issue.spawnedTask}`);
+      }
+      if (issue.status !== "open" && issue.status !== "claimed") {
+        throw new Error(
+          `Cannot spawn task from issue in '${issue.status}' status (must be open or claimed)`
+        );
+      }
+      if (issue.status === "claimed") {
+        if (issue.claimedBy !== actor.actorId) {
+          throw new Error(
+            `Cannot spawn task from claimed issue ${issueId}: only claimant ${issue.claimedBy} can spawn`
+          );
+        }
+        if (!isEffectivelyClaimed(issue, now)) {
+          const expiredAt = issue.expiresAt ?? "unknown";
+          throw new Error(
+            `Cannot spawn task from claimed issue ${issueId}: lease expired at ${expiredAt}`
+          );
+        }
+      }
+      if (issue.version !== expectedVersion) {
+        throw new StaleVersionError(issue.version, expectedVersion, issueId);
+      }
+      const task = await createTask(
+        `[Issue] ${issue.title}`,
+        sprintId,
+        {
+          priority: taskOptions.priority,
+          assignee: taskOptions.assignee,
+          description: taskOptions.description || `Spawned from issue ${issueId} (${issue.category}/${issue.severity})`
+        },
+        repoRoot
+      );
+      const updated = {
+        ...issue,
+        spawnedTask: task.id,
+        spawnedTaskBy: actor,
+        spawnedTaskAt: now.toISOString(),
+        version: issue.version + 1,
+        updatedAt: now.toISOString()
+      };
+      await writeMarkdownFile(
+        filePath,
+        stripUndefined(updated),
+        body
+      );
+      return {
+        taskId: task.id,
+        issueId: issue.id,
+        issueVersion: updated.version
+      };
+    })
+  );
+}
+async function auditMalformedIssueFiles(repoRoot) {
+  const results = [];
+  const buckets = [
+    { kind: "finding", dir: getBucketPathByKind("finding", repoRoot) },
+    { kind: "issue", dir: getBucketPathByKind("issue", repoRoot) }
+  ];
+  for (const bucket of buckets) {
+    const files = await listMarkdownFiles(bucket.dir);
+    for (const file of files) {
+      try {
+        await parseMarkdownFile(file);
+      } catch (error) {
+        results.push({
+          bucket: bucket.kind,
+          filePath: path.relative(repoRoot, file),
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  return results;
+}
+function stripUndefined(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function normalizeFindingForRead(finding) {
+  if (Array.isArray(finding.observations) && finding.observations.length > 0) {
+    return finding;
+  }
+  return {
+    ...finding,
+    observations: getObservations(finding)
+  };
+}
+function warnMalformedFile(repoRoot, filePath, bucket, error, warnedSet) {
+  const relativePath = path.relative(repoRoot, filePath);
+  if (warnedSet.has(relativePath)) return;
+  warnedSet.add(relativePath);
+  emitWarning(
+    "CFG-002",
+    {
+      taskId: "issue-manager",
+      subsystem: "planning",
+      executionPhase: "execution"
+    },
+    {
+      severity: "WARN" /* WARN */,
+      metadata: {
+        operation: "parse-planning-item",
+        bucket,
+        file: relativePath,
+        error: error instanceof Error ? error.message : String(error)
+      }
+    }
+  );
+}
+
+// src/planning/issue-policy.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import yaml from "js-yaml";
+var DEFAULT_ISSUE_POLICY = {
+  consensus: {
+    minValidations: 2,
+    confirmedThreshold: 0.67,
+    rejectedThreshold: 0.67,
+    minAverageConfidence: 0.7
+  },
+  autoPromote: {
+    enabled: true,
+    minPromotionConfidence: 0.8,
+    maxPromotesPerRun: 50,
+    gatedCategories: ["security"],
+    gatedSeverities: ["critical"]
+  },
+  ingest: {
+    maxFindingsPerBatch: 500,
+    maxOccurrencesBeforeReview: 10
+  },
+  severityPriority: {
+    critical: "P0",
+    high: "P1",
+    medium: "P2",
+    low: "P3"
+  },
+  scannerWeights: {}
+};
+function loadIssuePolicy(repoRoot = process.cwd()) {
+  const configPath = path2.join(repoRoot, ".build-project", "config", "issue-policy.yaml");
+  if (!fs.existsSync(configPath)) {
+    return { ...DEFAULT_ISSUE_POLICY };
+  }
+  try {
+    const raw = fs.readFileSync(configPath, "utf8");
+    const parsed = yaml.load(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return { ...DEFAULT_ISSUE_POLICY };
+    }
+    return mergePolicy(DEFAULT_ISSUE_POLICY, parsed);
+  } catch {
+    return { ...DEFAULT_ISSUE_POLICY };
+  }
+}
+function mergePolicy(defaults, overrides) {
+  return {
+    consensus: {
+      ...defaults.consensus,
+      ...overrides.consensus ?? {}
+    },
+    autoPromote: {
+      ...defaults.autoPromote,
+      ...overrides.autoPromote ?? {}
+    },
+    ingest: {
+      ...defaults.ingest,
+      ...overrides.ingest ?? {}
+    },
+    severityPriority: {
+      ...defaults.severityPriority,
+      ...overrides.severityPriority ?? {}
+    },
+    scannerWeights: {
+      ...defaults.scannerWeights,
+      ...overrides.scannerWeights ?? {}
+    }
+  };
+}
+function isCategoryGated(category, policy = DEFAULT_ISSUE_POLICY) {
+  return policy.autoPromote.gatedCategories.includes(category);
+}
+function isSeverityGated(severity, policy = DEFAULT_ISSUE_POLICY) {
+  if (!severity) return false;
+  return policy.autoPromote.gatedSeverities.includes(severity);
+}
+function severityToPriority(severity, policy = DEFAULT_ISSUE_POLICY) {
+  if (!severity) return null;
+  return policy.severityPriority[severity] ?? null;
+}
+function applyWeight(confidence, provider, policy = DEFAULT_ISSUE_POLICY) {
+  if (!Number.isFinite(confidence)) {
+    throw new Error(`Confidence must be a finite number, received: ${String(confidence)}`);
+  }
+  const rawWeight = policy.scannerWeights[provider];
+  const weight = Number.isFinite(rawWeight) && rawWeight >= 0 ? rawWeight : 1;
+  return Math.max(0, Math.min(1, confidence * weight));
+}
+function exceedsBatchBudget(candidateCount, policy = DEFAULT_ISSUE_POLICY) {
+  return candidateCount > policy.ingest.maxFindingsPerBatch;
+}
+
+// src/planning/tech-debt-manager.ts
+import * as fsSync from "fs";
+import * as fs2 from "fs/promises";
+import * as path3 from "path";
+import * as yaml2 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+)?)(?:\s*\/\s*10)?$/);
+    if (numericMatch) {
+      parsed = Number(numericMatch[1]);
+    } 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) {
+  content = normalizeMarkdownContent(content);
+  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 = yaml2.load(match[1] ?? "", { schema: yaml2.JSON_SCHEMA });
+  const body = (match[2] ?? "").trim();
+  return { metadata: normalizeDebtItem(rawMetadata), body, raw: rawMetadata };
+}
+function patchedFrontmatter(raw, before, after) {
+  const patched = { ...raw };
+  for (const [key, value] of Object.entries(after)) {
+    if (value !== before[key]) patched[key] = value;
+  }
+  for (const key of Object.keys(before)) {
+    if (!(key in after)) delete patched[key];
+  }
+  return patched;
+}
+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 fs2.readFile(filePath, "utf8");
+  return parseMarkdownContent(content, filePath);
+}
+async function getDebtItemAsync(itemId) {
+  const basePath = getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  const filePath = path3.join(currentPath, `${itemId}.md`);
+  try {
+    await fs2.access(filePath);
+  } catch {
+    return null;
+  }
+  return parseMarkdownFile2(filePath);
+}
+async function writeMarkdownFile2(filePath, metadata, body) {
+  const yamlStr = yaml2.dump(metadata, { lineWidth: -1 });
+  const content = `---
+${yamlStr}---
+
+${body}`;
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  const handle = await fs2.open(tempPath, "w");
+  try {
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+    await handle.close();
+    await fs2.rename(tempPath, filePath);
+  } catch (error) {
+    try {
+      await handle.close();
+    } catch {
+    }
+    try {
+      await fs2.unlink(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+async function createDebtItemAsync(title, severity, effort, options = {}) {
+  const basePath = getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  assertBucketWriteAvailable(basePath);
+  await fs2.mkdir(currentPath, { recursive: true });
+  const { debtItem, body } = buildDebtItem(title, severity, effort, options);
+  const filePath = path3.join(currentPath, `${debtItem.id}.md`);
+  await writeMarkdownFile2(filePath, debtItem, body);
+  regenerateIndexesAfterCreate(basePath);
+  return debtItem;
+}
+async function updateDebtItemAsync(itemId, fields) {
+  const basePath = getPlanningRoot();
+  const currentPath = getBucketPathByKind("tech-debt", basePath);
+  const filePath = path3.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 = keepActivity(`Tech-debt item ${itemId}`, existingBody, 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 writeMarkdownFile2(filePath, rawUpdated, nextBody);
+    const { metadata: normalizedUpdated } = parseMarkdownContent(
+      `---
+${yaml2.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 = path3.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 = path3.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 = path3.join(currentPath, `${itemId}.md`);
+  try {
+    await fs2.access(filePath);
+  } catch {
+    throw new Error(`Debt item not found: ${itemId}`);
+  }
+  return withIndexRegeneration(basePath, async () => {
+    const { metadata, body, raw } = await parseMarkdownFile2(filePath);
+    const before = { ...metadata };
+    applyDebtSchedule(metadata, when);
+    await writeMarkdownFile2(filePath, patchedFrontmatter(raw, before, 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 = path3.join(currentPath, `${itemId}.md`);
+  try {
+    await fs2.access(currentFile);
+  } catch {
+    throw new Error(`Debt item not found: ${itemId}`);
+  }
+  return withIndexRegeneration(basePath, async () => {
+    const { metadata, body, raw } = await parseMarkdownFile2(currentFile);
+    const before = { ...metadata };
+    markDebtComplete(metadata);
+    const archivedAt = metadata.archivedAt;
+    const archivedFile = getArchivedFilePath(bucket, itemId, archivedAt, basePath);
+    await fs2.mkdir(path3.dirname(archivedFile), { recursive: true });
+    await writeMarkdownFile2(archivedFile, patchedFrontmatter(raw, before, metadata), body);
+    await fs2.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(path3.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 (path3.basename(file).toLowerCase() === "readme.md") {
+        continue;
+      }
+      try {
+        const { metadata } = await parseMarkdownFile2(file);
+        items.push(metadata);
+      } catch (error) {
+        warnDebtReadError(error, path3.relative(basePath, file), "list-all-debt-archived");
+      }
+    }
+  }
+  return items;
+}
+async function listMarkdownFileNames(directory) {
+  let entries;
+  try {
+    entries = await fs2.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 fs2.readdir(directory, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const fullPath = path3.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-duplicate-titles.ts
+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;
+}
+
+// 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 [];
+  }
+}
+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 = getBucketArchivePathByKind("task", rootDir);
+    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,
+            sprintId: typeof frontMatter.sprintId === "string" ? frontMatter.sprintId : void 0,
+            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 {
+      }
+    }
+    const ledgers = /* @__PURE__ */ new Map();
+    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;
+      }
+      if (task.sprintId && !ledgers.has(task.sprintId) && task.dependencies.some((id) => !taskStatuses.has(id))) {
+        ledgers.set(
+          task.sprintId,
+          await loadSprintCompletedTaskIds(task.sprintId, rootDir).catch(() => /* @__PURE__ */ new Set())
+        );
+      }
+      const completed = task.sprintId ? ledgers.get(task.sprintId) : void 0;
+      const hasUnsatisfiedDependency = task.dependencies.some((dependencyId) => {
+        const depStatus = taskStatuses.get(dependencyId);
+        return !classifyTaskDependency(dependencyId, {
+          task: depStatus ?? null,
+          recordedComplete: completed?.has(dependencyId)
+        }).satisfied;
+      });
+      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 = getBucketArchivePathByKind("backlog", rootDir);
+    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 bulletMatch = line.match(/^[-*]\s+(?:\[(?: |x|X)\]\s+)?(.+)$/);
+    if (!bulletMatch) continue;
+    const content = bulletMatch[1]?.trim() ?? "";
+    if (content.length === 0) continue;
+    if (content.includes("<<<") || content.includes(">>>")) continue;
+    criteria.push(content);
+  }
+  return criteria;
+}
+async function queryNextItemsResult(options) {
+  const unavailable = checkSharedBucketReadability(resolvePlanningContextForRoot(options.rootDir));
+  return unavailable ?? planningReadOk(await collectNextItems(options));
+}
+async function queryNextItems(options) {
+  return unwrapPlanningRead(await queryNextItemsResult(options));
+}
+async function collectNextItems(options) {
+  const { rootDir } = options;
+  const backlogDir = getBucketPathByKind("backlog", rootDir);
+  const backlogDirRel = path4.relative(rootDir, backlogDir);
+  const requestedKinds = options.kinds ?? [];
+  const shouldQueryBacklog = requestedKinds.length === 0 || requestedKinds.includes("backlog");
+  const backlogExists = shouldQueryBacklog ? await fs3.stat(backlogDir).then(() => true).catch(() => false) : false;
+  if (!backlogExists && !options.includeFindings && requestedKinds.length === 0) {
+    return [];
+  }
+  const backlogItems = backlogExists ? await listBacklogItems(backlogDir) : [];
+  const inboxItems = backlogItems.filter((item) => item.status === "inbox");
+  const reviewedItems = backlogItems.filter((item) => item.status === "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: path4.join(backlogDirRel, `${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 ? `build 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 = path4.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: path4.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 = path4.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: path4.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 fs3.stat(debtDir).then(() => true).catch(() => false);
+      if (debtExists) {
+        const debtItems = await listAllDebtAsync(false, rootDir);
+        const debtDirRel = path4.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: path4.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 fs3.stat(parkingDir).then(() => true).catch(() => false);
+      if (parkingExists) {
+        const parkingItems = await listActive(parkingDir);
+        const parkingDirRel = path4.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: path4.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 {
+  normalizePath,
+  generateFingerprint,
+  findDuplicate,
+  trackOccurrence,
+  appendObservation,
+  getObservations,
+  computeAgreement,
+  computeConsensus,
+  createObservation,
+  createFinding,
+  readFinding,
+  updateFinding,
+  transitionFindingStatus,
+  listFindings,
+  readIssue,
+  transitionIssueStatus,
+  listIssues,
+  promoteFindingToIssue,
+  renewEntityLease,
+  validateFinding,
+  getConsensus,
+  spawnTaskFromIssue,
+  auditMalformedIssueFiles,
+  loadIssuePolicy,
+  isCategoryGated,
+  isSeverityGated,
+  applyWeight,
+  exceedsBatchBudget,
+  getDebtItemAsync,
+  createDebtItemAsync,
+  updateDebtItemAsync,
+  listByBlockingAsync,
+  listByParallelizableAsync,
+  scheduleDebtAsync,
+  completeDebtAsync,
+  listAllDebtAsync,
+  areNearDuplicates,
+  extractBodyPreview,
+  extractAcceptanceCriteria,
+  queryNextItemsResult,
+  queryNextItems,
+  parseKindOption
+};
+//# sourceMappingURL=chunk-S6TAFQI5.js.map