@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-UAPHFJPN.js

@@ -0,0 +1,673 @@
+import {
+  extractMarkdownSection,
+  findFencedCodeSpans,
+  isInsideFencedCodeSpan
+} from "./chunk-R2TIYG7U.js";
+
+// src/planning/file-hints.ts
+function extractFileHintPaths(body, maxPaths = Infinity) {
+  const paths = [];
+  const fileRegex = /FILE:\s*([^\s\n]+)/g;
+  let match = fileRegex.exec(body);
+  while (match !== null && paths.length < maxPaths) {
+    const filePath = match[1]?.trim();
+    if (filePath && !filePath.startsWith("...") && !filePath.startsWith("<") && filePath.length > 3) {
+      paths.push(filePath);
+    }
+    match = fileRegex.exec(body);
+  }
+  return paths;
+}
+
+// src/planning/task-spec-markers.ts
+var MARKER_PATTERN = /<<<FILL(?::[^>\n]*>>>|>>>|:)/g;
+var SECTION_HEADING_PATTERN = /^#{1,2}\s.*$/gm;
+function hasUnfilledMarkers(content) {
+  if (!content) return true;
+  return liveMarkerOffsets(content).length > 0;
+}
+function unfilledMarkerHeadings(body) {
+  const fencedSpans = findFencedCodeSpans(body);
+  const headings = [...body.matchAll(SECTION_HEADING_PATTERN)].filter(
+    (heading) => !isInsideFencedCodeSpan(fencedSpans, heading.index)
+  );
+  const found = [];
+  for (const offset of liveMarkerOffsets(body)) {
+    const heading = headings.filter((candidate) => candidate.index < offset).at(-1);
+    const line = heading ? heading[0].trim() : "";
+    if (!found.includes(line)) found.push(line);
+  }
+  return found;
+}
+function liveMarkerOffsets(content) {
+  const fencedSpans = findFencedCodeSpans(content);
+  const offsets = [];
+  for (const match of content.matchAll(MARKER_PATTERN)) {
+    const start = match.index;
+    if (isInsideFencedCodeSpan(fencedSpans, start) || !isInlineCodeMarkerMention(content, start, start + match[0].length)) {
+      offsets.push(start);
+    }
+  }
+  return offsets;
+}
+function countAdjacentBackticks(content, start, direction) {
+  let count = 0;
+  let index = direction === -1 ? start - 1 : start;
+  while (index >= 0 && index < content.length && content[index] === "`") {
+    count++;
+    index += direction;
+  }
+  return count;
+}
+function isInlineCodeMarkerMention(content, start, end) {
+  const openingTicks = countAdjacentBackticks(content, start, -1);
+  if (openingTicks === 0) return false;
+  const closingTicks = countAdjacentBackticks(content, end, 1);
+  if (closingTicks !== openingTicks) return false;
+  const lineStart = content.lastIndexOf("\n", start - 1) + 1;
+  const lineEndIndex = content.indexOf("\n", end);
+  const lineEnd = lineEndIndex === -1 ? content.length : lineEndIndex;
+  const openerStart = start - openingTicks;
+  const closerEnd = end + closingTicks;
+  return openerStart >= lineStart && closerEnd <= lineEnd;
+}
+
+// src/planning/task-spec-validator.ts
+import * as fs from "fs";
+import * as path from "path";
+function boundTypeFromIntent(intent) {
+  switch (intent?.activity) {
+    case "debugging":
+      return "bug";
+    case "architecture":
+      return "adr";
+    case "research":
+      return "research";
+    default:
+      return void 0;
+  }
+}
+var TASK_TYPE_FIELDS = {
+  dev: {
+    required: ["files_to_modify", "acceptance_criteria", "verification"],
+    optional: ["non_goals", "test_plan"]
+  },
+  adr: {
+    required: ["context", "decision", "alternatives", "consequences"],
+    optional: []
+  },
+  research: {
+    required: ["research_questions", "deliverable"],
+    optional: []
+  },
+  bug: {
+    required: ["repro_steps", "expected_actual", "actual_behavior"],
+    optional: ["files_to_modify", "verification"]
+  }
+};
+var SECTION_PATTERNS = [
+  {
+    field: "files_to_modify",
+    pattern: /^#{1,2}\s*(?:Files?\s+to\s+Modify|Scope\s*\/\s*Surfaces?\s+Affect(?:ed)?(?:\s*\(Optional\))?)/im
+  },
+  {
+    field: "acceptance_criteria",
+    pattern: /^#{1,2}\s*Acceptance\s+Criteria/im
+  },
+  { field: "verification", pattern: /^#{1,2}\s*How\s+to\s+Verify/im },
+  { field: "non_goals", pattern: /^#{1,2}\s*Non-?goals?/im },
+  { field: "test_plan", pattern: /^#{1,2}\s*Test\s+Plan/im },
+  { field: "context", pattern: /^#{1,2}\s*Context/im },
+  { field: "decision", pattern: /^#{1,2}\s*Decision/im },
+  { field: "alternatives", pattern: /^#{1,2}\s*Alternatives?\s+Considered/im },
+  { field: "consequences", pattern: /^#{1,2}\s*Consequences?/im },
+  { field: "research_questions", pattern: /^#{1,2}\s*Research\s+Questions?/im },
+  { field: "deliverable", pattern: /^#{1,2}\s*Deliverables?/im },
+  { field: "repro_steps", pattern: /^#{1,2}\s*Reproduction\s+Steps/im },
+  { field: "expected_actual", pattern: /^\*\*Expected:\*\*/im },
+  { field: "actual_behavior", pattern: /^\*\*Actual:\*\*/im }
+];
+function detectTaskType(enhancements) {
+  if (enhancements.some((e) => e.kind === "adr")) return "adr";
+  if (enhancements.some((e) => e.kind === "research")) return "research";
+  if (enhancements.some((e) => e.kind === "reproducibility")) return "bug";
+  return "dev";
+}
+function enhancementsCarryBoundType(enhancements) {
+  return enhancements.some(
+    (e) => e.kind === "adr" || e.kind === "research" || e.kind === "reproducibility"
+  );
+}
+function boundTypeFromEnhancementKinds(enhancements) {
+  if (enhancements.some((e) => e.kind === "adr")) return "adr";
+  if (enhancements.some((e) => e.kind === "research")) return "research";
+  if (enhancements.some((e) => e.kind === "reproducibility")) return "bug";
+  return void 0;
+}
+function isBoundType(value) {
+  return value === "adr" || value === "research" || value === "bug";
+}
+function getBoundType(source, body) {
+  if (isBoundType(source.boundType)) {
+    return source.boundType;
+  }
+  const setEnhancements = source.enhancementSet?.enhancements;
+  if (Array.isArray(setEnhancements)) {
+    const fromSet = boundTypeFromEnhancementKinds(setEnhancements);
+    if (fromSet) return fromSet;
+  }
+  if (Array.isArray(source.enhancements)) {
+    const fromFlat = boundTypeFromEnhancementKinds(source.enhancements);
+    if (fromFlat) return fromFlat;
+  }
+  const fromIntent = boundTypeFromIntent(source.enhancementSet?.intent);
+  if (fromIntent) return fromIntent;
+  if (typeof body === "string") {
+    const inferred = inferTaskTypeFromBody(body);
+    if (inferred && inferred !== "dev") return inferred;
+  }
+  return void 0;
+}
+function evaluateTaskType(body, taskType) {
+  const fields = TASK_TYPE_FIELDS[taskType];
+  const missing = [];
+  const filled = [];
+  const optionalFilled = [];
+  let presentSections = 0;
+  for (const field of fields.required) {
+    const content = extractSectionContent(body, field);
+    if (content !== null) presentSections++;
+    if (hasUnfilledMarkers(content) || !hasMeaningfulContent(content)) {
+      missing.push(field);
+    } else {
+      filled.push(field);
+    }
+  }
+  for (const field of fields.optional) {
+    const content = extractSectionContent(body, field);
+    if (!hasUnfilledMarkers(content) && hasMeaningfulContent(content)) {
+      optionalFilled.push(field);
+    }
+  }
+  const totalRequired = fields.required.length;
+  return {
+    taskType,
+    missing,
+    filled,
+    optionalFilled,
+    complete: missing.length === 0,
+    score: totalRequired > 0 ? filled.length / totalRequired : 1,
+    presentSections
+  };
+}
+function inferTaskTypeFromBody(body) {
+  const evaluations = Object.keys(TASK_TYPE_FIELDS).map(
+    (taskType) => evaluateTaskType(body, taskType)
+  );
+  const ranked = [...evaluations].sort((a, b) => {
+    if (b.filled.length !== a.filled.length) return b.filled.length - a.filled.length;
+    if (b.presentSections !== a.presentSections) return b.presentSections - a.presentSections;
+    if (b.score !== a.score) return b.score - a.score;
+    return 0;
+  });
+  const top = ranked[0];
+  const runnerUp = ranked[1];
+  if (!top) return null;
+  const strongSignal = top.complete || top.presentSections >= 2 || top.filled.length >= 2;
+  if (!strongSignal) return null;
+  if (runnerUp && runnerUp.filled.length === top.filled.length && runnerUp.presentSections === top.presentSections && Math.abs(runnerUp.score - top.score) < 1e-4) {
+    return null;
+  }
+  return top.taskType;
+}
+function resolveTaskTypeForValidation(body, enhancements) {
+  const enhancementTaskType = detectTaskType(enhancements);
+  const bodyTaskType = inferTaskTypeFromBody(body);
+  if (!bodyTaskType) {
+    return {
+      taskType: enhancementTaskType,
+      taskTypeSource: "enhancements",
+      enhancementTaskType
+    };
+  }
+  if (bodyTaskType === enhancementTaskType) {
+    return {
+      taskType: bodyTaskType,
+      taskTypeSource: "body",
+      bodyTaskType,
+      enhancementTaskType
+    };
+  }
+  if (enhancementsCarryBoundType(enhancements)) {
+    return {
+      taskType: enhancementTaskType,
+      taskTypeSource: "enhancements",
+      bodyTaskType,
+      enhancementTaskType
+    };
+  }
+  return {
+    taskType: bodyTaskType,
+    taskTypeSource: "body",
+    bodyTaskType,
+    enhancementTaskType
+  };
+}
+function extractSectionContent(body, field) {
+  const pattern = SECTION_PATTERNS.find((p) => p.field === field);
+  if (!pattern) return null;
+  return extractMarkdownSection(body, pattern.pattern, /^#{1,2}\s/m)?.trim() ?? null;
+}
+function classifyUnfilledMarkers(body, taskType, missing) {
+  const fields = TASK_TYPE_FIELDS[taskType];
+  const unfilledOptional = [];
+  const strayMarkerSections = [];
+  for (const heading of unfilledMarkerHeadings(body)) {
+    const field = [...fields.required, ...fields.optional].find(
+      (candidate) => SECTION_PATTERNS.find((p) => p.field === candidate)?.pattern.test(heading)
+    );
+    if (field && missing.includes(field)) continue;
+    const askable = field && fields.optional.includes(field);
+    if (askable && hasUnfilledMarkers(extractSectionContent(body, field))) {
+      if (!unfilledOptional.includes(field)) unfilledOptional.push(field);
+    } else strayMarkerSections.push(heading.replace(/^#+\s*/, "") || "(no heading)");
+  }
+  return { unfilledOptional, strayMarkerSections };
+}
+function hasMeaningfulContent(content) {
+  if (!content) return false;
+  const withoutMarkers = content.replace(/<<<FILL[^>]*>>>/g, "").trim();
+  const hasLength = withoutMarkers.length >= 10;
+  const hasRealContent = !/^(?:FILE:\s*src\/\.\.\.|[-*]\s*$)/m.test(withoutMarkers);
+  return hasLength && hasRealContent;
+}
+function validateTaskSpec(body, enhancements) {
+  const resolved = resolveTaskTypeForValidation(body, enhancements);
+  const evaluation = evaluateTaskType(body, resolved.taskType);
+  const markers = classifyUnfilledMarkers(body, resolved.taskType, evaluation.missing);
+  const { unfilledOptional, strayMarkerSections } = markers;
+  const markerFree = unfilledOptional.length === 0 && strayMarkerSections.length === 0;
+  return {
+    complete: evaluation.missing.length === 0 && markerFree,
+    missing: evaluation.missing,
+    ...unfilledOptional.length > 0 ? { unfilledOptional } : {},
+    ...strayMarkerSections.length > 0 ? { strayMarkerSections } : {},
+    filled: evaluation.filled,
+    optionalFilled: evaluation.optionalFilled,
+    score: evaluation.score,
+    taskType: resolved.taskType,
+    taskTypeSource: resolved.taskTypeSource,
+    bodyTaskType: resolved.bodyTaskType,
+    enhancementTaskType: resolved.enhancementTaskType
+  };
+}
+var FIELD_DISPLAY_NAMES = {
+  files_to_modify: "Scope / Surfaces Affected",
+  acceptance_criteria: "Acceptance Criteria",
+  verification: "How to Verify",
+  non_goals: "Non-goals",
+  test_plan: "Test Plan",
+  context: "Context",
+  decision: "Decision",
+  alternatives: "Alternatives Considered",
+  consequences: "Consequences",
+  research_questions: "Research Questions",
+  deliverable: "Deliverable",
+  repro_steps: "Reproduction Steps",
+  expected_actual: "Expected/Actual",
+  actual_behavior: "Actual Behavior"
+};
+function completenessCounts(completeness) {
+  const filled = completeness.filled.length;
+  return { filled, total: filled + incompleteSectionNames(completeness).length };
+}
+function completenessPercent(completeness) {
+  if (completeness.complete) return 100;
+  const { filled, total } = completenessCounts(completeness);
+  return total > 0 ? Math.min(99, Math.round(filled / total * 100)) : 0;
+}
+function incompleteSectionNames(completeness) {
+  return [
+    ...completeness.missing.map((f) => FIELD_DISPLAY_NAMES[f]),
+    ...(completeness.unfilledOptional ?? []).map((f) => FIELD_DISPLAY_NAMES[f]),
+    ...completeness.strayMarkerSections ?? []
+  ];
+}
+var GUIDANCE_TIER_NAMES = {
+  0: "silent",
+  1: "informational",
+  2: "suggestive",
+  3: "insistent",
+  4: "emphatic"
+};
+function calculateGuidanceTier(completeness) {
+  const { taskType, score } = completeness;
+  switch (taskType) {
+    case "research":
+      return score < 0.5 ? 1 : 0;
+    case "adr":
+      return score < 0.5 ? 2 : 1;
+    case "dev":
+      if (score < 0.3) return 4;
+      if (score < 0.6) return 3;
+      return 2;
+    // suggestive
+    case "bug":
+      return score < 0.4 ? 3 : 2;
+    default:
+      return 1;
+  }
+}
+function buildValidationVerdict(completeness, qualitySignals, refineHint = null) {
+  if (!completeness.complete) {
+    const blocking = incompleteSectionNames(completeness);
+    const advisories2 = qualitySignals.filter((s) => s.severity === "warning" || s.severity === "info").map((s) => s.message);
+    const markersOnly = completeness.missing.length === 0 ? { markersOnly: true } : {};
+    const optionalWithMarkers = (completeness.unfilledOptional ?? []).map(
+      (f) => FIELD_DISPLAY_NAMES[f]
+    );
+    return {
+      kind: "error",
+      blocking,
+      advisories: advisories2,
+      refineHint,
+      ...markersOnly,
+      ...optionalWithMarkers.length > 0 ? { optionalWithMarkers } : {}
+    };
+  }
+  const advisories = qualitySignals.map((s) => s.message);
+  const hasBlockingAdvisory = qualitySignals.some((s) => s.severity === "warning");
+  const kind = hasBlockingAdvisory ? "warning" : "ok";
+  return { kind, blocking: [], advisories, refineHint };
+}
+function renderValidationVerdict(verdict) {
+  const lines = [];
+  if (verdict.kind === "ok") {
+    lines.push("OK: Spec complete");
+  } else if (verdict.kind === "warning") {
+    lines.push("Warning: Spec complete with advisory notes");
+    for (const advisory of verdict.advisories) {
+      lines.push(`  - ${advisory}`);
+    }
+  } else {
+    lines.push(
+      verdict.markersOnly ? "Error: Spec incomplete \u2014 unfilled <<<FILL>>> markers" : "Error: Spec incomplete \u2014 missing required fields"
+    );
+    for (const field of verdict.blocking) {
+      lines.push(
+        verdict.optionalWithMarkers?.includes(field) ? `  - ${field} (optional section; fill its <<<FILL>>> marker or delete the section)` : `  - ${field} (<<<FILL>>> required)`
+      );
+    }
+    if (verdict.advisories.length > 0) {
+      lines.push("Advisory:");
+      for (const advisory of verdict.advisories) {
+        lines.push(`  - ${advisory}`);
+      }
+    }
+  }
+  if (verdict.refineHint) {
+    lines.push(`Run: ${verdict.refineHint}`);
+  }
+  return lines.join("\n");
+}
+function generatePromptInjection(completeness, tier) {
+  if (tier < 3) return null;
+  const percentage = Math.round(completeness.score * 100);
+  const missingNames = completeness.missing.map((f) => FIELD_DISPLAY_NAMES[f]);
+  if (tier === 3) {
+    return `[SPEC: ${percentage}% complete | Missing: ${missingNames.join(", ")}]
+Identify missing field details before implementing.`;
+  }
+  return `[SPEC: ${percentage}% | Missing: ${missingNames.join(", ")}]
+- Clarify the goal and why it matters
+- Define measurable acceptance criteria
+- Identify relevant code surfaces
+- Specify how to verify success`;
+}
+function extractNpmScripts(body) {
+  const scripts = [];
+  const runRegex = /(?:npm|pnpm|bun)\s+run\s+(\w[\w:-]*)/g;
+  let match = runRegex.exec(body);
+  while (match !== null) {
+    const script = match[1];
+    if (script && typeof script === "string" && !["install", "ci", "start", "test", "build"].includes(script)) {
+      scripts.push(script);
+    }
+    match = runRegex.exec(body);
+  }
+  const testShorthand = /(?:npm|pnpm)\s+test\b/g;
+  while (testShorthand.exec(body) !== null) {
+  }
+  const yarnRegex = /\byarn\s+(?:run\s+)?(\w[\w:-]+)/g;
+  let yarnMatch = yarnRegex.exec(body);
+  while (yarnMatch !== null) {
+    const script = yarnMatch[1];
+    if (script && typeof script === "string" && ![
+      "install",
+      "ci",
+      "start",
+      "test",
+      "build",
+      "add",
+      "remove",
+      "run",
+      "link",
+      "unlink"
+    ].includes(script)) {
+      scripts.push(script);
+    }
+    yarnMatch = yarnRegex.exec(body);
+  }
+  return scripts;
+}
+function isAcceptanceCriteriaTooVague(body) {
+  const acceptanceSection = extractSectionContent(body, "acceptance_criteria");
+  if (!acceptanceSection) return false;
+  const genericPatterns = [
+    /tests?\s+pass/i,
+    /no\s+regressions?/i,
+    /works?\s+(?:as\s+)?expected/i,
+    /completes?\s+successfully/i
+  ];
+  let content = acceptanceSection;
+  for (const pattern of genericPatterns) {
+    content = content.replace(pattern, "");
+  }
+  content = content.replace(/<<<FILL[^>]*>>>/g, "");
+  content = content.replace(/- \[ ?\]/g, "").replace(/- \[x\]/gi, "");
+  const meaningfulContent = content.replace(/[\s\-*]/g, "").trim();
+  return meaningfulContent.length < 20;
+}
+function joinMarkdownBullets(section) {
+  const lines = section.split("\n");
+  const bullets = [];
+  for (const raw of lines) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) continue;
+    if (/^(?:[-*]|\d+[.)]) /.test(trimmed)) {
+      bullets.push(trimmed);
+    } else if (bullets.length > 0) {
+      bullets[bullets.length - 1] += ` ${trimmed}`;
+    } else {
+      bullets.push(trimmed);
+    }
+  }
+  return bullets;
+}
+function detectAmbiguousACVerbs(body) {
+  const acceptanceSection = extractSectionContent(body, "acceptance_criteria");
+  if (!acceptanceSection) return [];
+  const ambiguousVerbPattern = /\b(?:treated\s+differently|handled|managed|supports?|preserved|appropriate|correctly|properly|safer|improved|enhanced)\b/i;
+  const concreteOutcomePattern = /\b(?:given|when|then|returns?|emits?|produces?|sets?|throws?|rejects?|resolves?\s+to|must\s+be|must\s+not|should\s+equal|should\s+contain)\b|["'`]|`[^`]+`|\b(?:\d+|===|!==|>=?|<=?)\b|(?:input|output|expected|result)\s*:/i;
+  const bullets = joinMarkdownBullets(acceptanceSection);
+  const flagged = [];
+  for (const bullet of bullets) {
+    if (ambiguousVerbPattern.test(bullet) && !concreteOutcomePattern.test(bullet)) {
+      flagged.push(bullet);
+    }
+  }
+  if (flagged.length === 0) return [];
+  return [
+    {
+      code: "ac_ambiguous_verb",
+      severity: "warning",
+      message: `Acceptance criteria use load-bearing verbs without concrete trigger/outcome (${flagged.length} bullet${flagged.length > 1 ? "s" : ""})`,
+      details: flagged
+    }
+  ];
+}
+function detectMissingScenarioAC(body) {
+  const behaviorIndicators = /\b(?:inherit|fallback|precedence|override|policy|routing|resolution|selection|provenance|dispatch|cascade)\b/i;
+  if (!behaviorIndicators.test(body)) return null;
+  const acceptanceSection = extractSectionContent(body, "acceptance_criteria");
+  if (!acceptanceSection) {
+    return {
+      code: "ac_missing_scenario",
+      severity: "warning",
+      message: "Task discusses behavior or policy but has no acceptance criteria section. For implementation tasks, add at least one scenario-form AC (concrete trigger and outcome); exploratory or design tasks may instead state evaluation dimensions and open questions."
+    };
+  }
+  const scenarioPattern = /\b(?:given|when|then)\b|\bif\b.+\bthen\b|→|->|(?:input|output|expected|result)\s*:/i;
+  const bullets = joinMarkdownBullets(acceptanceSection);
+  const hasScenario = bullets.some((b) => scenarioPattern.test(b));
+  if (hasScenario) return null;
+  return {
+    code: "ac_missing_scenario",
+    severity: "warning",
+    message: "Task discusses behavior or policy but no AC states a concrete trigger and outcome (Given/When/Then, if\u2192then, or input/output pair). Expected for implementation tasks; exploratory or design tasks may instead state evaluation dimensions and open questions."
+  };
+}
+function stripCommandNoise(text) {
+  let cleaned = text;
+  cleaned = cleaned.replace(/`[^`]+`/g, "");
+  cleaned = cleaned.replace(/--?\w[\w-]*[= ]+["'][^"']*["']/g, "");
+  cleaned = cleaned.replace(/https?:\/\/[^\s]+/g, "");
+  cleaned = cleaned.replace(/localhost:\d+[^\s]*/g, "");
+  cleaned = cleaned.replace(/:\d{2,5}\b/g, "");
+  return cleaned;
+}
+function detectVerifyMissingOutcome(body) {
+  const verifySection = extractSectionContent(body, "verification");
+  if (!verifySection) return null;
+  const bullets = joinMarkdownBullets(verifySection);
+  if (bullets.length === 0) return null;
+  const outcomePattern = /\b(?:should|must|expect|confirm|verify\s+that|assert|returns?|produces?|emits?|outputs?)\b|"[^"]+"|'[^']+'|\b\d+\b|(?:===|!==|>=?|<=?)/i;
+  const allOutcomeFree = bullets.every((b) => !outcomePattern.test(stripCommandNoise(b)));
+  if (!allOutcomeFree) return null;
+  return {
+    code: "verify_missing_expected_outcome",
+    severity: "info",
+    message: 'Verify section describes steps to run but does not state expected outcomes; consider adding "should", "must", or explicit values on a separate prose line (run only backticked or fenced commands)'
+  };
+}
+function generateSpecQualitySignals(body, repoRoot, packageJsonScripts) {
+  const signals = [];
+  if (body.length > 0 && hasUnfilledMarkers(body)) {
+    signals.push({
+      code: "placeholders_remaining",
+      message: "Spec contains unfilled <<<FILL>>> placeholders"
+    });
+  }
+  const trimmedBody = body.trim();
+  const isTinyTask = trimmedBody.length < 100;
+  if (!isTinyTask) {
+    const lines = trimmedBody.split("\n");
+    const firstNonEmptyIndex = lines.findIndex((l) => l.trim().length > 0);
+    const firstNonEmptyLine = firstNonEmptyIndex >= 0 ? lines[firstNonEmptyIndex]?.trim() ?? "" : "";
+    const startsWithFileHeading = /^##\s*(?:Files?\s+to\s+Modify|Target\s+Files)\b/i.test(
+      firstNonEmptyLine
+    );
+    const openingBlockLines = [];
+    if (firstNonEmptyIndex >= 0) {
+      for (let i = firstNonEmptyIndex; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim() === "") break;
+        openingBlockLines.push(line.trim());
+      }
+    }
+    const fileLikeLine = /^(?:[-*]\s*)?(?:FILE:\s*)?(?:(?:[a-zA-Z0-9_.-]+\/)+[a-zA-Z0-9_.-]+\.[a-zA-Z0-9]+)(?:\s|$)/;
+    const nonHeadingLines = openingBlockLines.filter((l) => !/^#+\s+/.test(l));
+    const fileLikeLines = nonHeadingLines.filter((l) => fileLikeLine.test(l));
+    const nonFileLines = nonHeadingLines.filter((l) => l.length > 0 && !fileLikeLine.test(l));
+    const looksLikeFileListOnly = startsWithFileHeading || fileLikeLines.length > 0 && nonFileLines.length === 0;
+    if (looksLikeFileListOnly) {
+      signals.push({
+        code: "consider_goal_statement",
+        severity: "info",
+        message: "Spec starts with a file list. Consider leading with the goal/why."
+      });
+    }
+  }
+  if (repoRoot) {
+    const filePaths = extractFileHintPaths(body).slice(0, 5);
+    const nonexistent = [];
+    for (const filePath of filePaths) {
+      const fullPath = path.resolve(repoRoot, filePath);
+      try {
+        if (!fs.existsSync(fullPath)) {
+          nonexistent.push(filePath);
+        }
+      } catch {
+      }
+    }
+    if (nonexistent.length > 0) {
+      signals.push({
+        code: "nonexistent_file_paths",
+        message: `FILE: paths not found in repo: ${nonexistent.join(", ")}`,
+        details: nonexistent
+      });
+    }
+  }
+  if (packageJsonScripts) {
+    const verifySection = extractSectionContent(body, "verification");
+    if (verifySection) {
+      const scriptsUsed = extractNpmScripts(verifySection);
+      const unrecognized = scriptsUsed.filter((s) => !packageJsonScripts.has(s));
+      if (unrecognized.length > 0) {
+        signals.push({
+          code: "verify_command_unrecognized",
+          message: `Verify section uses unknown npm scripts: ${unrecognized.join(", ")}`,
+          details: unrecognized
+        });
+      }
+    }
+  }
+  if (isAcceptanceCriteriaTooVague(body)) {
+    signals.push({
+      code: "acceptance_criteria_too_vague",
+      message: 'Acceptance criteria appear too generic (only "tests pass"/"no regressions")'
+    });
+  }
+  for (const signal of detectAmbiguousACVerbs(body)) {
+    signals.push(signal);
+  }
+  const missingScenario = detectMissingScenarioAC(body);
+  if (missingScenario) {
+    signals.push(missingScenario);
+  }
+  const verifyOutcome = detectVerifyMissingOutcome(body);
+  if (verifyOutcome) {
+    signals.push(verifyOutcome);
+  }
+  return signals;
+}
+
+export {
+  extractFileHintPaths,
+  hasUnfilledMarkers,
+  boundTypeFromIntent,
+  SECTION_PATTERNS,
+  getBoundType,
+  validateTaskSpec,
+  FIELD_DISPLAY_NAMES,
+  completenessCounts,
+  completenessPercent,
+  incompleteSectionNames,
+  GUIDANCE_TIER_NAMES,
+  calculateGuidanceTier,
+  buildValidationVerdict,
+  renderValidationVerdict,
+  generatePromptInjection,
+  generateSpecQualitySignals
+};
+//# sourceMappingURL=chunk-UAPHFJPN.js.map