@dev-loops/core 1.0.3 → 1.0.4-pre.1

package/src/loop/copilot-loop-state.mjs

@@ -198,6 +198,7 @@ export function buildSnapshotFromPrFacts({
   failureDetails = [],
   excludedFailureDetails,
   copilotBodyFeedbackUnresolved = false,
+  copilotPriorHeadBodyFeedbackUnresolved = false,
 }) {
   const prState = typeof prData?.state === "string" ? prData.state.toUpperCase() : "OPEN";
   const prMerged = prState === "MERGED";
@@ -228,6 +229,7 @@ export function buildSnapshotFromPrFacts({
     failureDetails,
     excludedFailureDetails: excludedFailureDetails ?? rollupDerivation.excludedFailureDetails,
     copilotBodyFeedbackUnresolved,
+    copilotPriorHeadBodyFeedbackUnresolved,
   });
 }
 
@@ -298,6 +300,10 @@ export function normalizeSnapshot(raw) {
     failureDetails: Array.isArray(raw.failureDetails) ? raw.failureDetails : [],
     excludedFailureDetails: Array.isArray(raw.excludedFailureDetails) ? raw.excludedFailureDetails : [],
     copilotBodyFeedbackUnresolved: Boolean(raw.copilotBodyFeedbackUnresolved),
+    // A body-only changes-recommended/unrecognized latest Copilot review on an
+    // earlier head with no trusted disposition record. Consumed only at the
+    // round cap, where no fresh Copilot review can supersede it.
+    copilotPriorHeadBodyFeedbackUnresolved: Boolean(raw.copilotPriorHeadBodyFeedbackUnresolved),
   };
 }
 
@@ -357,7 +363,8 @@ export function applyConfirmedReviewRequest(snapshot, reviewRequestStatus) {
  *   nextAction: string,
  *   autoRerequestEligible: boolean,
  *   sameHeadCleanConverged: boolean,
- *   roundCapCleanEligible: boolean
+ *   roundCapCleanEligible: boolean,
+ *   roundCapReopenEligible: boolean
  * }}
  */
 export function interpretLoopState(snapshot, refinementConfig) {
@@ -402,12 +409,18 @@ export function interpretLoopState(snapshot, refinementConfig) {
   const maxRounds = refinementConfig?.maxCopilotRounds;
   const reviewInFlight = s.copilotReviewRequestStatus === "requested"
     || s.copilotReviewRequestStatus === "already-requested";
+  // Clean at the cap except for an earlier-head body-only finding. That finding
+  // blocks the clean fallback, but a significant post-convergence change still
+  // opens a new Copilot cycle, whose review supersedes it.
+  let roundCapBlockedOnlyByPriorHeadBody = false;
   if (isCopilotRoundCapReached({ copilotReviewRoundCount: s.copilotReviewRoundCount, maxCopilotRounds: maxRounds })
       && state !== STATE.NO_PR && state !== STATE.DONE
       && state !== STATE.PR_DRAFT && state !== STATE.REVIEW_REQUEST_UNAVAILABLE
       && state !== STATE.BLOCKED_NEEDS_USER_DECISION) {
     const ciClean = s.ciStatus === "success" || s.ciStatus === "crediblyGreen" || !preApprovalRequireCi;
-    const cleanThreads = s.unresolvedThreadCount === 0 && !s.copilotBodyFeedbackUnresolved;
+    const cleanCurrentHead = s.unresolvedThreadCount === 0 && !s.copilotBodyFeedbackUnresolved;
+    const cleanThreads = cleanCurrentHead && !s.copilotPriorHeadBodyFeedbackUnresolved;
+    roundCapBlockedOnlyByPriorHeadBody = cleanCurrentHead && ciClean && !cleanThreads && !reviewInFlight;
     if (cleanThreads && ciClean) {
       state = STATE.ROUND_CAP_CLEAN_FALLBACK;
     } else if (!reviewInFlight) {
@@ -483,6 +496,9 @@ export function interpretLoopState(snapshot, refinementConfig) {
   }
 
   const roundCapCleanEligible = state === STATE.ROUND_CAP_CLEAN_FALLBACK;
+  // Cap states where a significant post-convergence change reopens a Copilot cycle.
+  const roundCapReopenEligible = roundCapCleanEligible
+    || (state === STATE.ROUND_CAP_REACHED && roundCapBlockedOnlyByPriorHeadBody);
 
   return {
     state,
@@ -491,6 +507,26 @@ export function interpretLoopState(snapshot, refinementConfig) {
     autoRerequestEligible,
     sameHeadCleanConverged,
     roundCapCleanEligible,
+    roundCapReopenEligible,
+  };
+}
+
+/**
+ * Reopen a Copilot cycle at the round cap after a significant post-convergence
+ * change landed on a newer head (see `roundCapReopenEligible`).
+ *
+ * @param {object} interpretation - interpretLoopState() output
+ * @returns {object} the interpretation routed to READY_TO_REREQUEST_REVIEW
+ */
+export function reopenRoundCapCycle(interpretation) {
+  return {
+    ...interpretation,
+    state: STATE.READY_TO_REREQUEST_REVIEW,
+    nextAction: NEXT_ACTIONS[STATE.READY_TO_REREQUEST_REVIEW],
+    allowedTransitions: [...TRANSITIONS[STATE.READY_TO_REREQUEST_REVIEW]],
+    autoRerequestEligible: true,
+    roundCapCleanEligible: false,
+    roundCapReopenEligible: false,
   };
 }
 

package/src/loop/finding-cluster.mjs

@@ -10,7 +10,7 @@
  * array/objects.
  */
 
-import { resolveFindingFile } from "./gate-fanin.mjs";
+import { normalizeSeverity, resolveFindingFile } from "./gate-fanin.mjs";
 
 // NUL separates the three key components so a value inside one component
 // (e.g. a recommendation that happens to contain a colon or digits matching
@@ -257,21 +257,40 @@ export function dedupeActListByCluster(actFindings, clusters, allFindings) {
 }
 
 /**
- * A "clean" verdict is invalid the moment any finding was acted on — an
- * acted finding is, by definition, unresolved work. Throws a clear Error on
- * `overallVerdict === "clean" && actCount > 0`; returns `overallVerdict`
- * unchanged otherwise.
+ * A "clean" ledger severity verdict means no finding at a BLOCKING severity
+ * remains open. It is invalid only when a finding at a blocking severity was
+ * acted on — that is unresolved blocking work, so the round cannot be clean.
+ * The ledger's severity verdict may stay clean with NON-BLOCKING act findings
+ * (a medium in the fix window, a low the fixer triages). The posted review
+ * verdict is composed with the act list (ADR 0089), so such a round posts
+ * findings_present until its act items are fixed.
+ *
+ * Throws a clear Error on `overallVerdict === "clean"` with any act finding at a
+ * blocking severity; returns `overallVerdict` unchanged otherwise.
  *
  * @param {unknown} overallVerdict
- * @param {number} actCount — non-negative integer; fails closed otherwise.
+ * @param {Array<{severity?: unknown}>} actFindings — the round's act-disposed findings.
+ * @param {string[]} [blockingSeverities] — the gate's blocking severities (default ["high"]).
  * @returns {unknown} `overallVerdict`, unchanged.
  */
-export function assertCleanImpliesNoAct(overallVerdict, actCount) {
-  if (!Number.isInteger(actCount) || actCount < 0) {
-    throw new TypeError("assertCleanImpliesNoAct requires actCount to be a non-negative integer");
+export function assertCleanImpliesNoBlockingAct(overallVerdict, actFindings, blockingSeverities) {
+  if (!Array.isArray(actFindings)) {
+    throw new TypeError("assertCleanImpliesNoBlockingAct requires actFindings to be an array");
   }
-  if (overallVerdict === "clean" && actCount > 0) {
-    throw new Error("clean verdict is invalid with a nonzero act count: any acted finding prevents clean");
+  if (overallVerdict !== "clean") return overallVerdict;
+  const blocking = new Set(
+    (Array.isArray(blockingSeverities) && blockingSeverities.length > 0 ? blockingSeverities : ["high"]).map((s) =>
+      normalizeSeverity(s),
+    ),
+  );
+  const offending = actFindings.filter((f) => blocking.has(normalizeSeverity(f?.severity)));
+  if (offending.length > 0) {
+    const severities = [...new Set(offending.map((f) => normalizeSeverity(f?.severity)))].join(", ");
+    throw new Error(
+      `clean verdict is invalid with ${offending.length} acted finding(s) at a blocking severity (${severities}): ` +
+        `a blocking-severity finding acted on this round cannot be clean. The ledger's severity verdict may be clean with ` +
+        `non-blocking act findings; the posted review verdict is composed with the act list (ADR 0089).`,
+    );
   }
   return overallVerdict;
 }

package/src/loop/gate-carry-forward.mjs

@@ -177,10 +177,19 @@ export function angleReviewSurface(angle, { alwaysRerun } = {}) {
  * @param {AngleReviewSurface} [input.angleSurface] — the angle's declared surface;
  *   derived from {@link angleReviewSurface} when omitted.
  * @param {string[]} input.changedFiles — repo-relative paths changed between head
- *   A and head B (the delta, NOT the full PR diff against base).
+ *   A and head B (the delta, NOT the full PR diff against base). For a base-move
+ *   re-gate the caller passes the MAIN-RELATIVE incremental delta: files changed
+ *   since head A whose head-B content is genuinely PR-own (differs from
+ *   origin/main), NOT the raw two-dot A..B delta — so an integrate-only base-move
+ *   that only replays already-merged main commits contributes an empty delta.
  * @param {string} input.prevVerdict — the angle's verdict at head A. "clean" and
  *   "findings_present" are carry-forward-eligible; anything else (e.g.
  *   "blocked", missing) is not.
+ * @param {boolean} [input.deltaComplete=false] — the caller PROVES `changedFiles`
+ *   is the complete, successfully-computed delta (git succeeded and, for a
+ *   base-move, the main-relative reduction ran). Only then does an EMPTY delta
+ *   mean "nothing PR-own changed" and carry forward; without the proof an empty
+ *   delta is indistinguishable from an unavailable one and still fails closed.
  * @returns {{ carryForward: boolean, reason: string }}
  */
 
@@ -207,7 +216,7 @@ export function isDevLoopConfigSourcePath(filePath) {
   return DEV_LOOP_CONFIG_SOURCE_RE.test(filePath.trim().replace(/\\/g, "/"));
 }
 
-export function resolveAngleCarryForward({ angle, angleSurface, changedFiles, prevVerdict }) {
+export function resolveAngleCarryForward({ angle, angleSurface, changedFiles, prevVerdict, deltaComplete = false }) {
   if (!CARRY_FORWARD_ELIGIBLE_VERDICTS.has(prevVerdict)) {
     return {
       carryForward: false,
@@ -221,7 +230,16 @@ export function resolveAngleCarryForward({ angle, angleSurface, changedFiles, pr
   if (surface.kind === "unknown") {
     return { carryForward: false, reason: "angle has no declared review surface (fail-closed)" };
   }
-  if (!Array.isArray(changedFiles) || changedFiles.length === 0) {
+  if (!Array.isArray(changedFiles)) {
+    return { carryForward: false, reason: "delta is unavailable (fail-closed)" };
+  }
+  // A PROVEN-complete empty delta (deltaComplete) means the main-relative
+  // reduction found NO PR-own change since the prior reviewed head — an
+  // integrate-only base-move that only replays already-merged main commits.
+  // That carries forward: the zero-file loop below proves the surface untouched.
+  // Without that proof an empty delta is indistinguishable from an unavailable
+  // one, so it still fails closed.
+  if (changedFiles.length === 0 && !deltaComplete) {
     return { carryForward: false, reason: "delta is empty or unavailable (fail-closed)" };
   }
   for (const file of changedFiles) {
@@ -287,12 +305,22 @@ const COPILOT_REVIEW_SURFACE_KINDS = new Set(["code", "test", "config", "ci"]);
  * re-runs, since classifyFile is path-based). Any code/test/config/CI file, an unclassifiable
  * file, or an empty/unavailable delta -> re-run (fresh blocking round required).
  *
+ * `deltaComplete` mirrors {@link resolveAngleCarryForward}: when the caller PROVES
+ * `changedFiles` is the complete main-relative reduction, an EMPTY delta means an
+ * integrate-only base-move touched no Copilot surface and the convergence carries
+ * forward. Without the proof an empty delta still fails closed.
+ *
  * @param {object} input
  * @param {string[]} input.changedFiles — delta since the converged head
+ * @param {boolean} [input.deltaComplete=false] — proof the empty case is a real
+ *   "nothing PR-own changed", not an unavailable delta
  * @returns {{ carryForward: boolean, reason: string }}
  */
-export function resolveConvergenceCarryForward({ changedFiles }) {
-  if (!Array.isArray(changedFiles) || changedFiles.length === 0) {
+export function resolveConvergenceCarryForward({ changedFiles, deltaComplete = false }) {
+  if (!Array.isArray(changedFiles)) {
+    return { carryForward: false, reason: "delta is unavailable (fail-closed)" };
+  }
+  if (changedFiles.length === 0 && !deltaComplete) {
     return { carryForward: false, reason: "delta is empty or unavailable (fail-closed)" };
   }
   for (const file of changedFiles) {
@@ -304,5 +332,10 @@ export function resolveConvergenceCarryForward({ changedFiles }) {
       return { carryForward: false, reason: `delta touches Copilot's review surface (${kind}): ${file}` };
     }
   }
-  return { carryForward: true, reason: "delta is a pure doc/prose bump, provably outside Copilot's review surface" };
+  return {
+    carryForward: true,
+    reason: changedFiles.length === 0
+      ? "no PR-own change since the converged head (integrate-only base-move), provably outside Copilot's review surface"
+      : "delta is a pure doc/prose bump, provably outside Copilot's review surface",
+  };
 }

package/src/loop/gate-fanin.mjs

@@ -828,6 +828,7 @@ export function consolidateFanin({ angleResults, blockCleanOnFindingSeverities }
           disposition: deriveDisposition(severity, { isBlocking, locatable: hasLocatableShape(f) }),
         };
         if (typeof f.file === "string" && f.file.trim().length > 0) entry.file = f.file.trim();
+        if (Array.isArray(f.files)) entry.files = f.files.filter((file) => typeof file === "string" && file.trim().length > 0).map((file) => file.trim());
         if (typeof f.line === "number" && Number.isFinite(f.line)) entry.line = f.line;
         if (typeof f.recommendation === "string" && f.recommendation.trim().length > 0) {
           entry.recommendation = f.recommendation.trim();
@@ -871,6 +872,38 @@ export function consolidateFanin({ angleResults, blockCleanOnFindingSeverities }
  */
 export const JUDGE_DISPOSITIONS = Object.freeze(["act", "defer", "reject"]);
 
+/**
+ * The `scopeDrift.verdict` vocabulary — the single shared source. The validator
+ * below consumes it directly, and a divergence-guard test asserts the judge
+ * persona surface (`agents/judge.agent.md`) documents exactly this set, so the
+ * producer and enforcer cannot silently drift apart.
+ */
+export const SCOPE_DRIFT_VERDICTS = Object.freeze(["within_scope", "drift_detected"]);
+
+/**
+ * Aliases a persona-following judge reaches for, normalized to the canonical
+ * vocabulary before validation. `none` is the intuitive no-drift spelling; it
+ * maps to `within_scope` so a semantically-correct verdict passes with no
+ * resend or hand-edit, disposition and rationale byte-intact.
+ */
+export const SCOPE_DRIFT_VERDICT_ALIASES = Object.freeze({ none: "within_scope" });
+
+/**
+ * Normalize a `scopeDrift.verdict` alias to its canonical value. Canonical and
+ * unknown values pass through untouched; validation rejects unknowns.
+ * @param {unknown} verdict
+ * @returns {unknown}
+ */
+export function normalizeScopeDriftVerdict(verdict) {
+  // Only a primitive string spelling normalizes. `hasOwnProperty.call` coerces
+  // its key argument, so without this guard a boxed `new String("none")` or an
+  // object whose `toString()` returns `"none"` would alias to `within_scope` —
+  // a fail-open contradicting the validator's non-string-fails-closed contract.
+  return typeof verdict === "string" && Object.prototype.hasOwnProperty.call(SCOPE_DRIFT_VERDICT_ALIASES, verdict)
+    ? SCOPE_DRIFT_VERDICT_ALIASES[verdict]
+    : verdict;
+}
+
 /**
  * Validate a judge verdict artifact shape (the `judge` agent's only write).
  * Pure; throws on a malformed verdict rather than enriching findings with
@@ -901,8 +934,9 @@ export function validateJudgeVerdict(verdict) {
     throw new Error("judge verdict.scopeDrift must be an object");
   }
   const sd = /** @type {Record<string, unknown>} */ (v.scopeDrift);
-  if (sd.verdict !== "within_scope" && sd.verdict !== "drift_detected") {
-    throw new Error("judge verdict.scopeDrift.verdict must be 'within_scope' or 'drift_detected'");
+  const normalizedVerdict = normalizeScopeDriftVerdict(sd.verdict);
+  if (!SCOPE_DRIFT_VERDICTS.includes(/** @type {string} */ (normalizedVerdict))) {
+    throw new Error(`judge verdict.scopeDrift.verdict must be one of: ${SCOPE_DRIFT_VERDICTS.join(", ")}`);
   }
   if (typeof sd.rationale !== "string" || sd.rationale.trim().length === 0) {
     throw new Error("judge verdict.scopeDrift.rationale must be a non-empty string");
@@ -949,7 +983,7 @@ export function validateJudgeVerdict(verdict) {
       }
     }
   }
-  return { headSha: v.headSha, scopeDrift: v.scopeDrift, dispositions: v.dispositions };
+  return { headSha: v.headSha, scopeDrift: { ...sd, verdict: normalizedVerdict }, dispositions: v.dispositions };
 }
 
 /**
@@ -1012,6 +1046,27 @@ export function applyJudgeDispositions(findings, judgeVerdict) {
   return { findings: enriched, scopeDrift: validated.scopeDrift };
 }
 
+/**
+ * The judge's act list: the findings this PR must still fix. Pure.
+ * @param {unknown} findings
+ * @returns {Array<object>}
+ */
+export function listOpenActItems(findings) {
+  return (Array.isArray(findings) ? findings : []).filter((f) => f && f.judgeDisposition === "act");
+}
+
+/**
+ * Compose a round's review verdict with the judge act list (ADR 0089): a
+ * non-empty act list keeps a `clean` severity verdict from `clean`. Never
+ * lowers a verdict; the blockCleanOnFindingSeverities floor already applied.
+ * @param {"clean"|"findings_present"|"blocked"} overallVerdict
+ * @param {unknown} findings
+ * @returns {"clean"|"findings_present"|"blocked"}
+ */
+export function composeReviewVerdict(overallVerdict, findings) {
+  return overallVerdict === "clean" && listOpenActItems(findings).length > 0 ? "findings_present" : overallVerdict;
+}
+
 /**
  * Map consolidated findings into the `--findings` JSON shape consumed by
  * scripts/github/write-gate-findings-log.mjs (severity, angle, summary,

package/src/loop/issue-refinement-artifact.mjs

@@ -949,14 +949,95 @@ function sectionHasBody(section) {
   return false;
 }
 
+// A top-level list marker line (any GFM/CommonMark family: `-`/`*`/`+`,
+// ordered `N.`/`N)`, optional leading blockquote `>` runs) with NO checkbox.
+// `validatePrBodySpec`-local: unlike `parseChecklistItems` (whose
+// `checked: null` state fires ONLY for the bare-dash form — see its
+// docstring), this recognizes every marker family, so a mixed AC/DoD section
+// (`- [ ] works` next to `* plain`) cannot escape detection just because the
+// plain line used a non-dash marker. No leading-space match before the
+// marker/blockquote keeps this top-level only: an indented continuation
+// (`  - detail`) is sub-content and is not matched. The negative lookahead
+// excludes a real checkbox line so `- [ ] works` is never double-counted; the
+// lookahead treats end-of-line as a checkbox terminator too (`(?:\s|$)`), so
+// an empty checkbox placeholder (`- [ ]`/`- [x]`, no trailing text) is
+// excluded rather than mis-caught as a plain bullet — `parseChecklistItems`
+// already documents empty placeholders as skipped, and this scan must not
+// contradict that.
+const TOP_LEVEL_NON_CHECKBOX_BULLET_PATTERN = /^(?:>\s*)*(?:[-*+]|\d+[.)])\s+(?!\[[ xX]\](?:\s|$))(.+?)\s*$/u;
+
+// A spaced Markdown thematic break (`* * *`, `- - -`) also matches
+// `TOP_LEVEL_NON_CHECKBOX_BULLET_PATTERN` (marker, whitespace, more marker
+// text) but is a divider, not a bullet — `parseChecklistItems` never treats
+// it as an item, so counting it here would reject a legitimate AC/DoD
+// section over a divider line. `***`/`---` (no spaces) already fail the
+// bullet pattern's `\s+` requirement, so only the spaced form needs this
+// guard. Same-marker-only via the backreference, and only `-`/`*`/`_` per
+// the CommonMark thematic-break rule (3+ of the SAME char, optional spaces,
+// nothing else) — `+` is NOT a valid thematic-break marker, so `+ + +`
+// stays correctly counted as a real (single-item) plain bullet.
+const THEMATIC_BREAK_RE = /^([-*_])(?:[ \t]*\1){2,}[ \t]*$/u;
+
+/**
+ * Scan a flattened section body for top-level non-checkbox bullet lines
+ * (`TOP_LEVEL_NON_CHECKBOX_BULLET_PATTERN`). Fence-skipped via the shared
+ * `stepFence` so a fenced fake bullet cannot spoof this check. Thematic-break
+ * divider lines (`THEMATIC_BREAK_RE`) are excluded — see its docstring.
+ */
+function scanTopLevelNonCheckboxBulletLines(text) {
+  if (typeof text !== "string" || text.length === 0) return [];
+  const found = [];
+  let fence = null;
+  for (const line of text.split(/\r?\n/u)) {
+    const step = stepFence(fence, line);
+    fence = step.fence;
+    if (step.insideFence) continue;
+    const match = TOP_LEVEL_NON_CHECKBOX_BULLET_PATTERN.exec(line);
+    if (!match || match[1].trim().length === 0) continue;
+    const strippedLine = line.replace(/^(?:>\s*)*/u, "").trim();
+    if (THEMATIC_BREAK_RE.test(strippedLine)) continue;
+    found.push(match[1].trim());
+  }
+  return found;
+}
+
+/**
+ * Scan every section the completeness block would read (ALL sections matching
+ * `patterns`, deep-flattened past `###` sub-headings via
+ * `findAllSectionsByPatterns` + `flattenSectionDeep` — the same union
+ * `extractPrBodyUncheckedChecklistItems` reads) for top-level plain bullets
+ * of ANY marker (no checkbox). Shares the section-set read with the
+ * completeness block on purpose: a plain bullet invisible to
+ * `validatePrBodySpec`'s own single-section read but visible to the
+ * completeness block (a duplicate AC/DoD heading, or a bullet nested under a
+ * `###` sub-heading) must still reject here, or the two surfaces diverge on
+ * the same checkbox-marker fail-open class this module closes for the simple
+ * single-section case. Local `scanTopLevelNonCheckboxBulletLines` scan, not
+ * `parseChecklistItems`'s `checked: null` state, so a non-dash plain bullet
+ * (`*`/`+`/ordered) is caught too — `parseChecklistItems` and the shared
+ * deterministic pre-approval completeness-block logic it backs (see
+ * acceptance-criteria-verification.md) stay untouched.
+ */
+function scanPlainBullets(sections, patterns) {
+  const matched = findAllSectionsByPatterns(sections, patterns);
+  const items = [];
+  for (let i = 0; i < sections.length; i += 1) {
+    if (!matched.includes(sections[i])) continue;
+    items.push(...scanTopLevelNonCheckboxBulletLines(flattenSectionDeep(sections, i)));
+  }
+  return items;
+}
+
 /**
  * Validate that a PR body carries every invariant required to serve as the
  * lightweight spec-of-record: Objective/why, in-scope, explicit non-goals,
- * testable Acceptance criteria (>=1 checklist item), Definition of done
- * (>=1 checklist item), Open questions/risks, and — unless issue-less mode is
+ * testable Acceptance criteria (>=1 checkbox item), Definition of done
+ * (>=1 checkbox item), Open questions/risks, and — unless issue-less mode is
  * requested — a GitHub closing-keyword issue reference. Reuses the generic
  * markdown logic so there is no parallel validator. Fails closed: every missing
- * invariant is reported under its distinct `missing_*` code. Pure; no I/O.
+ * invariant is reported under its distinct `missing_*` code (plus the two
+ * `*_not_checkboxes` codes for a plain-bullet AC/DoD section — see
+ * `scanPlainBullets`). Pure; no I/O.
  *
  * Issue-less mode (`issueLess: true`): the closing-issue linkage flips from
  * REQUIRED to FORBIDDEN (the PR is the sole artifact), failing closed under
@@ -1044,21 +1125,48 @@ export function validatePrBodySpec({ body = "", expectedIssue = null, issueLess
     }
   }
 
+  // Checkbox markers are REQUIRED (not just any bullet): the completeness
+  // block (extractPrBodyUncheckedChecklistItems) only ever sees checkbox
+  // items, so a plain bullet here would fail-open the completeness check
+  // even though this validator accepted it. The plain-bullet scan reads the
+  // SAME section set the completeness block reads (scanPlainBullets), not
+  // just the first section, so a duplicate heading or a bullet nested under a
+  // `###` sub-heading cannot hide from this check either. The scan runs
+  // INDEPENDENTLY of parseChecklistItems (not gated on it finding items) and
+  // is checked FIRST: an AC/DoD section made entirely of non-dash plain
+  // bullets (`* plain`, `1. plain`) yields zero parsed checkbox items, so
+  // gating the scan on "items found" would misreport that case as
+  // missing_acceptance_criteria/missing_definition_of_done instead of the
+  // distinct *_not_checkboxes code.
   const acSection = findSectionByPatterns(sections, ACCEPTANCE_SECTION_PATTERNS);
-  const acItems = acSection ? extractChecklistItems(acSection.bodyLines.join("\n")) : [];
-  if (acItems.length === 0) {
+  const acParsed = acSection ? parseChecklistItems(acSection.bodyLines.join("\n")) : [];
+  const acItems = acParsed.filter((item) => item.checked !== null).map((item) => item.text);
+  const acPlainBullets = scanPlainBullets(sections, ACCEPTANCE_SECTION_PATTERNS);
+  if (acPlainBullets.length > 0) {
+    errors.push({
+      code: "acceptance_criteria_not_checkboxes",
+      message: `Acceptance criteria must use checkbox markers ('- [ ]'/'- [x]'), not plain bullets (found ${acPlainBullets.length} plain bullet(s)); plain bullets fail-open the completeness block.`,
+    });
+  } else if (acParsed.length === 0) {
     errors.push({
       code: "missing_acceptance_criteria",
-      message: "Missing testable Acceptance criteria (no checklist items found).",
+      message: "Missing testable Acceptance criteria (no checkbox items found).",
     });
   }
 
   const dodSection = findSectionByPatterns(sections, DOD_SECTION_PATTERNS);
-  const dodItems = dodSection ? extractChecklistItems(dodSection.bodyLines.join("\n")) : [];
-  if (dodItems.length === 0) {
+  const dodParsed = dodSection ? parseChecklistItems(dodSection.bodyLines.join("\n")) : [];
+  const dodItems = dodParsed.filter((item) => item.checked !== null).map((item) => item.text);
+  const dodPlainBullets = scanPlainBullets(sections, DOD_SECTION_PATTERNS);
+  if (dodPlainBullets.length > 0) {
+    errors.push({
+      code: "definition_of_done_not_checkboxes",
+      message: `Definition of done must use checkbox markers ('- [ ]'/'- [x]'), not plain bullets (found ${dodPlainBullets.length} plain bullet(s)); plain bullets fail-open the completeness block.`,
+    });
+  } else if (dodParsed.length === 0) {
     errors.push({
       code: "missing_definition_of_done",
-      message: "Missing Definition of done (no checklist items found).",
+      message: "Missing Definition of done (no checkbox items found).",
     });
   }