@dev-loops/core 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-loops/core",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
   "engines": {
     "node": ">=24"

package/src/config/config.mjs

@@ -563,17 +563,11 @@ function boardRefConfig(ownerKey) {
     });
 }
 
-const QueueBoardConfig = boardRefConfig("queue.board");
-
 /** Queue mode config */
 const QueueConfig = z.strictObject({
   maxParallel: z.number().int().min(1).max(10).default(3).describe("Maximum queue items worked in parallel."),
   maxAutoFiledIssues: z.number().int().min(0).max(100).default(10).describe("Cap on auto-filed issues per run."),
   reDispatchMaxRetries: z.number().int().min(0).max(10).default(1).describe("Retries when re-dispatching a failed queue item."),
-  // Deprecated: superseded by `tracker.board` (issue #1408, the tracker-agnostic
-  // seam). Kept accepted for back-compat — see resolveTrackerBoard, which reads
-  // `tracker.board` first and falls back to this field with a load-time warning.
-  board: QueueBoardConfig.describe("Deprecated: use tracker.board instead. GitHub Projects board identifier.").optional(),
   archiveOlderThanDays: z.number().int().positive().describe("Archive done board items older than this many days.").optional(),
 });
 
@@ -583,7 +577,7 @@ const QueueConfig = z.strictObject({
  * at `resolveTrackerAdapter` call time, not at config-parse time — the
  * seam/resolver must not preclude a consumer registering an external
  * provider post-1.0 (`plugin`, reserved, not implemented in this pass).
- * `board` supersedes the deprecated `queue.board` (see resolveTrackerBoard).
+ * `board` is the canonical GitHub Projects board identifier (see resolveTrackerBoard).
  *
  * No generic `fieldMappings` (logical-column -> provider-status) key here:
  * the github provider's logical-column -> Status mapping IS the existing,
@@ -598,7 +592,7 @@ const QueueConfig = z.strictObject({
 const TrackerConfig = z.strictObject({
   provider: z.string().trim().min(1).describe("Tracker provider registry key. Built-in: \"github\" (default).").optional(),
   plugin: z.string().trim().min(1).describe("Reserved: module specifier for an external tracker provider plugin (post-1.0, not implemented in this pass).").optional(),
-  board: boardRefConfig("tracker.board").describe("Tracker board identifier; supersedes the deprecated queue.board.").optional(),
+  board: boardRefConfig("tracker.board").describe("Tracker board identifier.").optional(),
 });
 
 /**
@@ -940,13 +934,11 @@ export const BUILT_IN_DEFAULTS = Object.freeze({
     maxParallel: 3,
     maxAutoFiledIssues: 10,
     reDispatchMaxRetries: 1,
-    // queue.board is intentionally absent from defaults — setting it is an
-    // explicit operator opt-in for Projects-based queue ordering.
   }),
   tracker: Object.freeze({
     provider: "github",
     // tracker.board is intentionally absent from defaults — setting it is an
-    // explicit operator opt-in (mirrors queue.board). The logical-column ->
+    // explicit operator opt-in for Projects-based queue ordering. The logical-column ->
     // Status mapping is queue.statusColumns (see TrackerConfig above), not a
     // tracker-owned default.
   }),
@@ -1285,7 +1277,7 @@ export function resolveRoleModel(config, { role, harness, kind } = {}) {
  * @typedef {object} ConfigLoadError
  * @property {string} path - Human-readable file path or layer name
  * @property {string} message - Error description
- * @property {"defaults"|"settings"|"extensionDefaults"|"merged"} layer - Which config layer failed
+ * @property {"extensionDefaults"|"defaults"|"devloops"|"merged"} layer - Which config layer failed
  */
 
 // ============================================================================
@@ -1499,10 +1491,11 @@ function configError(message, code, filePath) {
 }
 
 /**
- * Try to load and merge one config layer (defaults or settings).
+ * Try to load and merge one config layer (extensionDefaults, defaults, or
+ * devloops).
  * @param {Record<string, unknown>} merged - Current merged config
  * @param {string|string[]} basePaths - Config file base path(s) without extension
- * @param {"defaults"|"settings"} layer - Layer name
+ * @param {"extensionDefaults"|"defaults"|"devloops"} layer - Layer name
  * @param {string[]} warnings
  * @param {ConfigLoadError[]} errors
  * @param {{ warnOnMissing?: boolean }} [options]
@@ -1628,7 +1621,7 @@ async function applyLayer(merged, basePaths, layer, warnings, errors, options =
 
 /**
  * Load the dev-loop configuration with full precedence:
- *   settings.(yaml|yml|json) > legacy overrides.(yaml|yml|json) > repo .pi/dev-loop/defaults.(yaml|yml|json) > extension defaults > built-in defaults
+ *   repo .devloops > repo .pi/dev-loop/defaults.(yaml|yml|json) > extension defaults > built-in defaults
  *
  * Never throws for config-related problems.
  * Returns extension defaults (with built-in defaults as the final fallback) even when all repo-local config files are missing or broken.
@@ -1641,7 +1634,6 @@ export async function loadDevLoopConfig(options = {}) {
   const configDir = path.join(repoRoot, ".pi", "dev-loop");
   const defaultsPath = path.join(configDir, "defaults");
   const devloopsPath = path.join(repoRoot, ".devloops");
-  const settingsPaths = [path.join(configDir, "settings"), path.join(configDir, "overrides")];
 
   /** @type {string[]} */
   const warnings = [];
@@ -1678,79 +1670,7 @@ export async function loadDevLoopConfig(options = {}) {
 
   if (primaryExists) {
     // .devloops is the primary override — apply it
-    merged = await applyLayer(merged, devloopsPath, "settings", warnings, errors);
-
-    // Warn if legacy files still exist alongside .devloops (but don't load them —
-    // .devloops is authoritative; legacy must not override it)
-    let legacyAlongside = false;
-    for (const legacyPath of settingsPaths) {
-      for (const ext of [".yaml", ".yml", ".json"]) {
-        try {
-          await readFile(legacyPath + ext, "utf8");
-          legacyAlongside = true;
-          break;
-        } catch (err) {
-          if (err?.code !== "ENOENT") {
-            // File exists but is unreadable — treat as "found" so the
-            // deprecation warning fires (applyLayer is not called for legacy
-            // paths when .devloops is present, so the flag only controls the warning).
-            legacyAlongside = true;
-            break;
-          }
-        }
-      }
-      if (legacyAlongside) break;
-    }
-    if (legacyAlongside) {
-      warnings.push(
-        `Deprecated config path(s) found under .pi/dev-loop/settings.* or .pi/dev-loop/overrides.*. ` +
-        `Migrate to .devloops (or .devloops.yaml/.devloops.yml/.devloops.json) at repo root. ` +
-        `Legacy paths will be removed in a future version.`
-      );
-    }
-  } else {
-    // No .devloops — fall back to legacy .pi/dev-loop/settings.* or overrides.* (deprecated)
-    let legacyFound = false;
-    for (const legacyPath of settingsPaths) {
-      for (const ext of [".yaml", ".yml", ".json"]) {
-        try {
-          await readFile(legacyPath + ext, "utf8");
-          legacyFound = true;
-          break;
-        } catch (err) {
-          if (err?.code !== "ENOENT") {
-            // File exists but is unreadable — treat as "found" so the
-            // deprecation warning fires and applyLayer can surface the error
-            // (legacy applyLayer runs in this branch).
-            legacyFound = true;
-            break;
-          }
-        }
-      }
-      if (legacyFound) break;
-    }
-    if (legacyFound) {
-      warnings.push(
-        `Deprecated config path(s) found under .pi/dev-loop/settings.* or .pi/dev-loop/overrides.*. ` +
-        `Migrate to .devloops (or .devloops.yaml/.devloops.yml/.devloops.json) at repo root. ` +
-        `Legacy paths will be removed in a future version.`
-      );
-      merged = await applyLayer(merged, settingsPaths, "settings", warnings, errors);
-    }
-  }
-
-  // Deprecated `queue.board` -> `tracker.board` alias (issue #1408, the
-  // tracker-agnostic seam). Runs on the fully-merged object (unlike the
-  // `strategy: "github-first"` alias above, this only affects cross-layer
-  // MERGE PRECEDENCE, not per-layer schema validity — queue.board is still a
-  // valid FileConfigSchema shape on its own — so normalizing once here, after
-  // every layer has merged, is sufficient).
-  if (isPlainObject(merged.queue?.board) && !isPlainObject(merged.tracker?.board)) {
-    warnings.push(
-      `queue.board is a deprecated alias for tracker.board (issue #1408). ` +
-      `Update .devloops to set tracker.board instead; the alias will be removed in a future version.`
-    );
-    merged = { ...merged, tracker: { ...(merged.tracker ?? {}), board: merged.queue.board } };
+    merged = await applyLayer(merged, devloopsPath, "devloops", warnings, errors);
   }
 
   // Validate final merged config
@@ -3085,19 +3005,13 @@ export function resolveTrackerProvider(config) {
 }
 
 /**
- * Resolve the effective tracker board identifier. `tracker.board` is
- * canonical; `queue.board` is a DEPRECATED alias, already normalized onto
- * `tracker.board` by `loadDevLoopConfig` (with a load-time warning) for any
- * config that went through the loader. This resolver also accepts a
- * hand-built config object that sets `queue.board` directly (bypassing the
- * loader, e.g. in a test) and falls back to it — with no warning, since only
- * the loader surfaces warnings.
+ * Resolve the effective tracker board identifier. `tracker.board` is the
+ * canonical (and only) board config key.
  *
  * @param {DevLoopConfig} config
  * @returns {{ number?: number, title?: string } | null}
  */
 export function resolveTrackerBoard(config) {
   if (isPlainObject(config?.tracker?.board)) return config.tracker.board;
-  if (isPlainObject(config?.queue?.board)) return config.queue.board;
   return null;
 }

package/src/config/extension-defaults.yaml

@@ -65,7 +65,7 @@ gates:
       - name: config-drift
         persona: review
         prompt: |-
-          Cross-check config, schema, and documentation for contract drift: - Verify that configuration files (.pi/dev-loop/settings.yaml,
+          Cross-check config, schema, and documentation for contract drift: - Verify that configuration files (.devloops,
             package.json, CI workflows, skill manifests) agree on canonical
             status tokens, support floors, and required flags.
           - Flag any instance where two sources of truth disagree about the
@@ -263,9 +263,15 @@ gates:
         mandatory: true
         persona: review
         prompt: |-
-          Verify before approval that the PR checklist and AC/DoD/non-goals matrix are complete. - Every PR checkbox (`- [ ]`) must be checked. If any box is unchecked, flag it as a blocking finding. - The PR body must contain an AC/DoD/non-goals matrix that maps each acceptance criterion
-            to its definition-of-done item(s) and lists explicit non-goals.
-          - The matrix must have a markdown table with at least a header row and one content row. - Flag the matrix as incomplete if any acceptance criterion, definition-of-done item, or non-goal is missing.
+          Completeness is enforced deterministically (#1877): the pre_approval_gate fails closed on any
+          unchecked `- [ ]` in the PR body's AC/DoD checklist, so this angle's completeness duty is
+          machine-backed. Your remaining duty is TRUTHFULNESS, which the machine cannot check: verify
+          that every checked `- [x]` box in the PR body's Acceptance criteria / Definition of done
+          checklists is actually satisfied by the implementation — cite concrete code/test/behavior
+          evidence; flag a dishonestly-ticked box as a blocking finding. Also verify the checked
+          content mirrors the linked issue's AC/DoD/Non-goals matrix and that declared non-goals are
+          respected (no scope creep). The boundary is explicit: the deterministic block enforces
+          completeness (nothing left unchecked/forgotten); you verify each [x] is real.
       - contradiction-lens
       - correctness-final
       - ui-validation
@@ -324,7 +330,7 @@ localImplementation:
     maxFiles: 2
     maxLines: 100
 
-# Queue defaults (repo-specific queue.board omitted by design).
+# Queue defaults (repo-specific tracker.board omitted by design).
 queue:
   maxParallel: 3
   # Local-first is PR-first (issues are skipped, #952), so auto-filing issues is

package/src/loop/gate-fanin.mjs

@@ -63,13 +63,19 @@ export function scheduleFanoutWaves(dispatchGroups, maxConcurrent = 4) {
 }
 
 /**
- * Adaptive 429-backoff concurrency (issue #1601): halve the active batch before
- * escalating to foreground one-at-a-time fallback. On a 429, the conductor
- * recomputes the wave plan with `backoffMaxConcurrent(maxConcurrent)` and
- * retries the failed wave; if a single-unit wave still 429s, it falls back to
- * foreground (one-at-a-time) dispatch. The backoff is recorded in the round's
- * provenance (see skills/docs/gate-review-sub-loop-contract.md). Pure; never
- * returns 0 (a backoff from 1 stays 1 → foreground fallback owns that path).
+ * Adaptive concurrency backoff (issue #1601; retry discipline refined by #1907):
+ * halve the active batch before escalating to foreground one-at-a-time fallback.
+ * A transient dispatch failure (429/5xx) is first retried on the SAME unit with
+ * exponential backoff — safe because a reviewer's findings artifact is an
+ * idempotent single-write at a deterministic path — and the conductor reduces
+ * concurrency ONLY after that unit's retries are exhausted (~3 failed attempts),
+ * recomputing the wave plan with `backoffMaxConcurrent(maxConcurrent)` and
+ * retrying the reduced wave; if a single-unit wave still fails, it falls back to
+ * foreground (one-at-a-time) dispatch. This "retry the unit before reducing
+ * concurrency" ordering is owned by GATE-EXEC-DISPATCH-RETRY-BACKOFF in
+ * skills/docs/gate-review-sub-loop-contract.md; the backoff is recorded in the
+ * round's provenance. Pure; never returns 0 (a backoff from 1 stays 1 →
+ * foreground fallback owns that path).
  * @param {number} maxConcurrent
  * @returns {number}
  */

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

@@ -3,14 +3,15 @@
  *
  * Implements the bounded refinement check required by the draft gate per
  * issue #532: a draft PR cannot leave draft unless the linked issue has an
- * explicit refinement artifact (Acceptance criteria section, DoD section,
- * or a linked refinement doc) that the pre-approval gate can verify
- * against. Prose-only issues (Problem / Root Cause / Fix) without an
- * `Acceptance criteria` or `DoD` section cause the draft gate to post
- * `verdict=blocked` with the `missing_refinement_artifact` finding.
- *
- * Since #1866 the check ALSO requires an explicit Non-goals section on the
- * issue body (see `MISSING_EXPLICIT_NON_GOALS_FINDING` below).
+ * explicit refinement artifact — the full matrix of an Acceptance criteria
+ * checklist plus a Definition of done checklist plus an explicit Non-goals
+ * section, or a linked refinement doc that is a complete artifact on its own —
+ * that the pre-approval gate can verify against. An issue missing any matrix
+ * part fails closed with the matching finding (`missing_dod_checklist`,
+ * `missing_ac_checklist`, `missing_explicit_non_goals`, or
+ * `missing_refinement_artifact`); prose-only issues (Problem / Root Cause /
+ * Fix) cause the draft gate to post `verdict=blocked` with the
+ * `missing_refinement_artifact` finding.
  */
 import { existsSync } from "node:fs";
 import path from "node:path";
@@ -36,9 +37,10 @@ export const REFINEMENT_SOURCE = Object.freeze({
 
 const REFINEMENT_ARTIFACT_FINDING = "missing_refinement_artifact";
 
-// The three artifact sources, any ONE of which satisfies the refinement gate.
-// Single source of truth for the "missing" vocabulary reported when none is
-// present — consumed by the enqueue gate and the parked-unrefined discovery.
+// REFINEMENT_ARTIFACT_SOURCES: the full-matrix floor vocabulary (#1877). The
+// refinement floor is the FULL AC/DoD/Non-goals matrix (a linked refinement
+// doc remains a complete artifact on its own) — this list is the shape of a
+// COMPLETE artifact, not a menu where any one entry suffices.
 export const REFINEMENT_ARTIFACT_SOURCES = Object.freeze([
   "Acceptance criteria section",
   "Definition of done section",
@@ -54,6 +56,24 @@ export const REFINEMENT_ARTIFACT_SOURCES = Object.freeze([
  */
 export const MISSING_EXPLICIT_NON_GOALS_FINDING = "missing_explicit_non_goals";
 
+/**
+ * #1877: finding reported when the issue body carries an AC checklist (and
+ * the Non-goals floor is met) but NO DoD checklist — the tracker-backed
+ * refinement floor is the full AC/DoD/Non-goals matrix (each AC mapped to its
+ * DoD item(s), plus explicit Non-goals), not AC-or-DoD. This lifts the
+ * epic-only matrix requirement (epic-tree-refinement-procedure.md) into the
+ * general refinement predicate, reconciled with #1866's Non-goals parity.
+ */
+export const MISSING_DOD_CHECKLIST_FINDING = "missing_dod_checklist";
+
+/**
+ * #1877: the symmetric matrix miss — a DoD checklist with no Acceptance
+ * criteria checklist. The matrix is authored at refinement on the issue; the
+ * PR then carries the derived checklist whose boxes the pre-approval gate
+ * requires all ticked.
+ */
+export const MISSING_AC_CHECKLIST_FINDING = "missing_ac_checklist";
+
 /**
  * Canonical list of section headings that satisfy the refinement check.
  * Matching is case-insensitive and tolerates trailing/leading whitespace.
@@ -62,16 +82,152 @@ export const MISSING_EXPLICIT_NON_GOALS_FINDING = "missing_explicit_non_goals";
  *   - one DoD-style section (DoD or Definition of Done)
  */
 const ACCEPTANCE_SECTION_PATTERNS = Object.freeze([
-  /^acceptance criteria\s*$/i,
+  // #1877 round-6: index 0 is the exact-canonical ANCHOR family —
+  // `^acceptance criteria\b` — so a decorated-variant canonical heading
+  // (`## Acceptance criteria (v2)`, `## Definition of done — core`) still lands
+  // in the exact bucket rather than matching NO pattern at all (the alias
+  // families anchor on the `AC`/`DoD` abbreviations and never fire for the
+  // spelled-out phrase). The anchor stays distinct from the alias family below
+  // (`/^ac\b/`), so the precedence contract is unchanged: a spelled-out
+  // canonical heading always outranks an abbreviation-shaped alias heading.
+  /^acceptance criteria\b.*$/i,
   /^ac\b.*$/i,
 ]);
 
 const DOD_SECTION_PATTERNS = Object.freeze([
-  /^definition of done\s*$/i,
-  /^done\s*$/i,
-  /^dod\s*$/i,
+  // Same anchor-family widening as the AC family (see above). #1877 round-7:
+  // the ALIAS arms are widened symmetrically with the AC family too — a
+  // decorated-variant alias heading (`## DoD (v2)`, `## Done — core`) must land
+  // in the alias bucket, not in NO bucket (a `$`-anchored alias silently
+  // disarms the PR-side DoD read and false-blocks the issue side).
+  /^definition of done\b.*$/i,
+  /^done\b.*$/i,
+  /^dod\b.*$/i,
 ]);
 
+/**
+ * Normalize a heading name before section-pattern matching (#1877 round-6
+ * parser hardening): GitHub authors legitimately write decorated canonical
+ * headings — `## **Acceptance criteria**`, `## Acceptance criteria:`,
+ * `## Acceptance criteria ##` — and the raw ATX capture (`match[2]`)
+ * fails every pattern family on them, silently disarming the deterministic
+ * AC/DoD reads (PR-side extractor fail-open; issue-side false
+ * missing_refinement_artifact). Strip the harmless decoration once, at the
+ * parse boundary, so exact-vs-alias precedence stays intact: a normalized
+ * `Acceptance criteria` still matches the exact pattern, a decorated alias
+ * still matches its alias family. Strips: surrounding emphasis runs of any
+ * of `*`/`_` (bold `**`/`__` and single-char italic `*`/`_` alike, #1877
+ * round-7), surrounding backtick runs, trailing `:` and surrounding
+ * whitespace.
+ * Deliberately NOT touched: interior text (a real `AC (v2) - final` name keeps
+ * its interior), leading `#` (ATX markers never reach `match[2]`), and any
+ * decoration a section pattern itself could rely on (none does — every family
+ * anchors at the name's start).
+ */
+function normalizeHeadingName(name) {
+  if (typeof name !== "string") return name;
+  return name
+    // trailing decoration first: closing `##` ATX-style, colons, whitespace
+    .replace(/\s*:*\s*$/u, "")
+    .replace(/\s*#+\s*$/u, "")
+    // surrounding emphasis/backtick runs (any length, must pair; #1877
+    // round-7: a run may be single-char italic `*`/`_` as well as bold
+    // `**`/`__`, so `## *Acceptance criteria*` and `## _Definition of done_`
+    // normalize exactly like their bold forms)
+    .replace(/^[*_`]+/u, "")
+    .replace(/[*_`]+$/u, "")
+    .trim();
+}
+
+// #1877 alias-precedence: exact canonical headings (the first pattern in each
+// family) must outrank loose aliases (`/^ac\b/`, `/^dod\b/`) so a matrix-shaped
+// heading the refined-issue contract itself produces (`## AC/DoD matrix`,
+// `## AC → DoD mapping`) can never hijack the canonical section read. Split
+// each pattern family into [exact, aliases] by convention: pattern index 0
+// is the exact canonical match, the rest are aliases.
+const EXACT_PATTERN_INDEX = 0;
+
+/**
+ * Resolve the sections matching a heading-pattern family with exact-first
+ * precedence (#1877): the first section matching the EXACT canonical pattern
+ * (index 0) wins over any earlier section that only matched a loose alias
+ * (e.g. `## AC/DoD matrix` before `## Acceptance criteria`). When no exact
+ * match exists, the first alias match is returned (alias-only bodies keep
+ * working). Returns null when no section matches at all.
+ */
+function findSectionByPatterns(sections, patterns) {
+  const exact = patterns[EXACT_PATTERN_INDEX];
+  for (const section of sections) {
+    if (exact.test(section.name)) {
+      return section;
+    }
+  }
+  for (const section of sections) {
+    for (let i = 1; i < patterns.length; i += 1) {
+      if (patterns[i].test(section.name)) {
+        return section;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Collect ALL sections matching a heading-pattern family, exact-first ordered
+ * (exact canonical matches before alias-only matches). Shared with
+ * `findSectionByPatterns`'s precedence semantics so single-section consumers
+ * and union consumers (#1877 PR-body unchecked-box extraction) cannot drift.
+ */
+function findAllSectionsByPatterns(sections, patterns) {
+  const exact = patterns[EXACT_PATTERN_INDEX];
+  const exactMatches = [];
+  const aliasMatches = [];
+  for (const section of sections) {
+    if (exact.test(section.name)) {
+      exactMatches.push(section);
+    } else {
+      for (let i = 1; i < patterns.length; i += 1) {
+        if (patterns[i].test(section.name)) {
+          aliasMatches.push(section);
+          break;
+        }
+      }
+    }
+  }
+  return [...exactMatches, ...aliasMatches];
+}
+
+/**
+ * Flatten a section (heading record) into a body string that extends past
+ * `###` sub-headings (#1877): a section's checklist may nest items under
+ * deeper sub-headings (`### edge cases` inside `## Acceptance criteria`), so
+ * join the section and every following section of a DEEPER heading level up
+ * to the next same-or-shallower heading. `parseMarkdownSections` terminates a
+ * section's `bodyLines` at ANY heading, which is correct for heading
+ * matching but hides unchecked boxes from consumers that must see ALL of a
+ * canonical section's boxes.
+ */
+function flattenSectionDeep(sections, startIndex) {
+  const start = sections[startIndex];
+  // #1877 round-6 heading-name re-injection fix: the raw sub-heading NAME is
+  // NEVER re-injected into the text the checklist parser re-parses. A name is
+  // a different input class from checklist body text: a fence-opening name
+  // (`### ``` `) used to corrupt the parser's fence state and eat every real
+  // box after it (fail-open), and a checkbox-shaped name (`### - [ ] fake`)
+  // used to be counted as a phantom unchecked item (spurious fail-closed).
+  // Only already-classified bodyLines are joined — a heading can never match
+  // any line-level grammar, and real boxes under sub-headings stay visible
+  // because their bodyLines still join normally. (Keeping a marker line is
+  // unnecessary: parseChecklistItems never needed the heading boundary to
+  // track fence state — body lines carry their own fences.)
+  const parts = [start.bodyLines.join("\n")];
+  for (let i = startIndex + 1; i < sections.length; i += 1) {
+    if (sections[i].level <= start.level) break;
+    parts.push(sections[i].bodyLines.join("\n"));
+  }
+  return parts.join("\n");
+}
+
 /**
  * Fenced-code-span tracker. Given the previous fence state and the current
  * line, returns { fence, insideFence } where:
@@ -135,7 +291,12 @@ export function parseMarkdownSections(body) {
       }
       current = {
         level: match[1].length,
-        name: match[2],
+        // #1877 round-6: normalize the captured name so decorated canonical
+        // headings (`## **Acceptance criteria**`) match the section patterns.
+        // The RAW name is never re-parsed as body text (flattenSectionDeep no
+        // longer re-injects it), so normalization is the only consumer of the
+        // capture — the raw form is not retained (no consumer reads it).
+        name: normalizeHeadingName(match[2]),
         bodyLines: [],
       };
       continue;
@@ -152,22 +313,16 @@ export function parseMarkdownSections(body) {
   return sections;
 }
 
-function findSectionByPatterns(sections, patterns) {
-  for (const section of sections) {
-    for (const pattern of patterns) {
-      if (pattern.test(section.name)) {
-        return section;
-      }
-    }
-  }
-  return null;
-}
 
 /**
  * Parse bullet/checkbox items from a section body into item states. Each
- * checkbox item (`- [ ]`/`- [x]`/`- [X]`) becomes `{ text, checked }`
- * (`checked` true only for a ticked `[x]`/`[X]`); a top-level plain bullet
- * (`- text`, dash at column 0 so nested/indented sub-bullets are not counted)
+ * checkbox item — any GFM/CommonMark task-list marker: `-`/`*`/`+` bullets,
+ * ordered `N.`/`N)`, and blockquote-nested `> - [ ]` (#1877 round-6 grammar
+ * widening; parity with tick-verified-checkboxes.mjs's `[-*+]`) — becomes
+ * `{ text, checked }` (`checked` true only for a ticked `[x]`/`[X]` marker,
+ * read from the captured marker group, never a whole-line re-test); a
+ * top-level plain bullet (`- text`, dash at column 0 so nested/indented
+ * sub-bullets are not counted)
  * becomes `{ text, checked: null }` — it has no checkbox to tick. Empty
  * checkbox placeholders (`- [ ]` / `- [x]` with no trailing text) are skipped,
  * not counted, so a section of only unfilled placeholders reports as unrefined.
@@ -197,17 +352,30 @@ function parseChecklistItems(sectionBody) {
     if (step.insideFence) {
       continue;
     }
-    // Checklist item: `- [ ]` / `- [x]` (leading indentation tolerated).
-    // Consume ANY checkbox-marker line here; push only when it carries text,
-    // so empty placeholders (`- [ ]`) are skipped rather than counted.
-    const checkboxMatch = /^\s*-\s+\[(?:[ xX])\](?:\s+(.+?))?\s*$/u.exec(line);
+    // Checklist item: GFM/CommonMark task-list markers (#1877 round-6 parser
+    // hardening): `-`/`*`/`+` bullets, ordered `N.`/`N)`, and blockquote-nested
+    // `> - [ ]` — the forms GitHub itself renders as interactive checkboxes.
+    // Grammar parity with tick-verified-checkboxes.mjs's CHECKBOX_RE (same
+    // #1877 round-1 widening): both accept bullets, ordered markers, and
+    // blockquote-nested forms, so every form this extractor surfaces as
+    // unchecked is flippable by the tick tool. Consume ANY checkbox-marker line
+    // here; push only when it carries text, so empty placeholders (`- [ ]`) are
+    // skipped rather than counted. #1877 round-7: the tick state comes from the
+    // CAPTURED marker group of this single match — never a second whole-line
+    // re-test. An unanchored `/\[(?:[xX])\]/u.test(line)` reads an UNCHECKED box
+    // whose label text merely mentions `[x]` (e.g. `- [ ] verify [x] flags`) as
+    // checked, silently disarming the deterministic block — the exact
+    // fail-open class the marker-anchored pre-#1877 read could not produce.
+    const checkboxMatch =
+      /^\s*(?:>|\s)*(?:[-*+]|\d+[.)])\s+\[([ xX])\](?:\s+(.+?))?\s*$/u.exec(line);
     if (checkboxMatch) {
-      const text = (checkboxMatch[1] ?? "").trim();
+      const text = (checkboxMatch[2] ?? "").trim();
       if (text.length > 0) {
-        // `checked` is true only for a ticked box; `[ ]` (space) is false.
+        // `checked` is true only for a ticked marker (`[x]`/`[X]`); a space
+        // marker (`[ ]`) is false — regardless of what the label text says.
         // A plain bullet has no checkbox, so it stays `null` below — it is
         // neither ticked nor unticked and does not count as an unticked AC.
-        items.push({ text, checked: /^\s*-\s+\[[xX]\]/u.test(line) });
+        items.push({ text, checked: checkboxMatch[1] !== " " });
       }
       continue;
     }
@@ -366,6 +534,18 @@ export function detectIssueRefinementArtifact({ body = "", issueNumber = null, r
   const acceptanceSection = findSectionByPatterns(sections, ACCEPTANCE_SECTION_PATTERNS);
   const dodSection = findSectionByPatterns(sections, DOD_SECTION_PATTERNS);
 
+  // CONSUMER-CONTRACT BOUNDARY (#1877, intentional asymmetry): the issue-side
+  // reads above are strict — ONE exact-first section, NO deep flattening —
+  // while extractPrBodyUncheckedChecklistItems (PR side) unions ALL matching
+  // sections and deep-flattens past ### sub-headings. The issue side is a
+  // presence check of the refinement matrix: a checklist hidden entirely
+  // under a ### sub-heading fails CLOSED (reported missing, the issue stays
+  // parked for human refinement). The PR side enforces a hard gate over the
+  // derived checklist: it must NEVER miss an unchecked box, so it fails open
+  // on nothing — it unions and deep-flattens. Do not "unify" these reads: the
+  // two failure directions are both deliberate (issue side = safe direction,
+  // PR side = fail-closed gate).
+
   const acItems = acceptanceSection ? extractChecklistItems(acceptanceSection.bodyLines.join("\n")) : [];
   // Unticked AC checkboxes (`- [ ]`) of the spec-of-record — the
   // ACCEPT-CRITERIA-VERIFY-AND-REFLECT precondition a clean pre_approval_gate
@@ -420,6 +600,25 @@ export function detectIssueRefinementArtifact({ body = "", issueNumber = null, r
       };
     }
     if (artifactSource === REFINEMENT_SOURCE.ISSUE_BODY_AC) {
+      // #1877 matrix floor: an AC checklist alone is no longer a complete
+      // refinement artifact on a tracker-backed issue — the matrix is each AC
+      // mapped to its DoD item(s) plus explicit Non-goals, so a missing DoD
+      // checklist fails closed with its own finding. A linked refinement doc
+      // stays a complete artifact on its own (the doc itself carries the
+      // matrix).
+      if (dodItems.length === 0) {
+        return {
+          ...base,
+          hasACs: false,
+          source: artifactSource,
+          reason:
+            "Issue body carries an Acceptance criteria checklist but no Definition of done checklist; " +
+            "the tracker-backed refinement contract requires the full AC/DoD/Non-goals matrix " +
+            "(#1877, rule ARTIFACT-TRACKER-ISSUE-REFINEMENT-FLOOR). Refusing: the refinement check fails closed " +
+            "without a DoD checklist mapped to the acceptance criteria.",
+          finding: MISSING_DOD_CHECKLIST_FINDING,
+        };
+      }
       return {
         ...base,
         hasACs: true,
@@ -429,12 +628,18 @@ export function detectIssueRefinementArtifact({ body = "", issueNumber = null, r
       };
     }
     if (artifactSource === REFINEMENT_SOURCE.ISSUE_BODY_DOD) {
+      // #1877 matrix floor, symmetric arm: a DoD checklist with no Acceptance
+      // criteria checklist is an incomplete matrix, not a refined issue.
       return {
         ...base,
-        hasACs: true,
+        hasACs: false,
         source: REFINEMENT_SOURCE.ISSUE_BODY_DOD,
-        reason: `Found ${dodItems.length} DoD checklist item(s) in the issue body.`,
-        finding: null,
+        reason:
+          "Issue body carries a Definition of done checklist but no Acceptance criteria checklist; " +
+          "the tracker-backed refinement contract requires the full AC/DoD/Non-goals matrix " +
+          "(#1877, rule ARTIFACT-TRACKER-ISSUE-REFINEMENT-FLOOR). Refusing: the refinement check fails closed " +
+          "without acceptance criteria for the DoD items to map to.",
+        finding: MISSING_AC_CHECKLIST_FINDING,
       };
     }
     return {
@@ -730,6 +935,57 @@ export function validateTrackerBackedPrBodySpec({ body = "", closingIssues = []
   return validatePrBodySpec({ body, expectedIssue, requireOpenQuestions: false });
 }
 
+/**
+ * #1877: extract the UNCHECKED AC/DoD checkbox items from a PR body's own
+ * Acceptance criteria / Definition of done checklists — the derived,
+ * self-contained checklist that mirrors the linked issue's AC/DoD/Non-goals
+ * matrix. Any unchecked `- [ ]` in those sections means an acceptance
+ * criterion or definition-of-done item is still open, and the deterministic
+ * pre-approval block (`upsert-checkpoint-verdict.mjs`) fails the gate closed:
+ * the round is `blocked` and the PR cannot reach approval with an open
+ * acceptance criterion. This enforces COMPLETENESS (nothing left
+ * unchecked/forgotten), not truthfulness — a dishonestly-ticked `[x]` passes
+ * this mechanical check and remains the reviewer/judge's responsibility
+ * (ACCEPT-CRITERIA-VERIFY-AND-REFLECT). Composes with
+ * `tick-verified-checkboxes.mjs`: a box the gate could not verify stays
+ * unchecked and therefore blocks.
+ *
+ * Pure; no I/O. Reuses the shared section patterns and checklist parser
+ * (same `parseMarkdownSections` + `extractUncheckedChecklistItems` seams as
+ * `detectIssueRefinementArtifact` / `validatePrBodySpec`) so no parallel
+ * parser can drift. Sections absent from the body contribute no items — the
+ * draft-exit `validateTrackerBackedPrBodySpec` check (#1863) already owns
+ * requiring the sections to EXIST.
+ *
+ * @param {{ body?: string }} input
+ * @returns {{ uncheckedAcItems: string[], uncheckedDodItems: string[] }}
+ */
+export function extractPrBodyUncheckedChecklistItems({ body = "" } = {}) {
+  if (typeof body !== "string" || body.length === 0) {
+    return { uncheckedAcItems: [], uncheckedDodItems: [] };
+  }
+  const sections = parseMarkdownSections(body);
+  // Union the unchecked boxes across ALL sections matching each pattern
+  // family (exact-first ordered), flattening each section past its deeper
+  // sub-headings (#1877): a body nesting ACs under `###` subsections, or
+  // repeating an AC/DoD heading, must not hide unchecked boxes from the
+  // deterministic completeness block. Deduped by text (same box re-read in a
+  // duplicate section is the same box).
+  const collect = (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(...extractUncheckedChecklistItems(flattenSectionDeep(sections, i)));
+    }
+    return [...new Set(items)];
+  };
+  return {
+    uncheckedAcItems: collect(ACCEPTANCE_SECTION_PATTERNS),
+    uncheckedDodItems: collect(DOD_SECTION_PATTERNS),
+  };
+}
+
 /**
  * Decide what an enqueue caller should do with a refinement-artifact result,
  * so an un-refined item never lands in the Next Up pickup column in the first
@@ -749,8 +1005,8 @@ export function validateTrackerBackedPrBodySpec({ body = "", closingIssues = []
 export function decideEnqueueRefinementGate({ artifact, targetIsPickup, auto = false }) {
   // `artifact.finding === null` is the explicit "passes the full refinement
   // check" signal (artifact AND — since #1866 — an explicit Non-goals
-  // section), clearer than reading `hasACs`, whose name understates what it
-  // covers.
+  // section AND — since #1877 — the full AC/DoD checklist matrix), clearer
+  // than reading `hasACs`, whose name understates what it covers.
   if (!targetIsPickup || artifact.finding === null) {
     return { action: "enqueue" };
   }
@@ -763,10 +1019,28 @@ export function decideEnqueueRefinementGate({ artifact, targetIsPickup, auto = f
       "(rule ARTIFACT-TRACKER-ISSUE-REFINEMENT-FLOOR; e.g. run `/dev-loops:loop-grill <issue> --auto` (or `/loop-grill <issue> --auto` in the dev-loops repo itself)) — refusing to enqueue without an explicit Non-goals section.";
     return { action: auto ? "divert" : "block", reason, missing: ["explicit Non-goals section"] };
   }
+  // #1877 matrix arms: name the actual missing matrix arm — an AC-only or
+  // DoD-only issue is NOT artifact-less, so the generic reason below would be
+  // factually wrong and would misdirect the fix.
+  if (artifact.finding === MISSING_DOD_CHECKLIST_FINDING) {
+    const reason =
+      "Issue carries an Acceptance criteria checklist but no Definition of done checklist — the refinement floor is the full AC/DoD/Non-goals matrix (#1877). " +
+      "Add a Definition of done checklist to the issue body (mapped to the acceptance criteria) " +
+      "(rule ARTIFACT-TRACKER-ISSUE-REFINEMENT-FLOOR; e.g. run `/dev-loops:loop-grill <issue> --auto` (or `/loop-grill <issue> --auto` in the dev-loops repo itself)) — refusing to enqueue without the full matrix.";
+    return { action: auto ? "divert" : "block", reason, missing: ["Definition of done checklist"] };
+  }
+  if (artifact.finding === MISSING_AC_CHECKLIST_FINDING) {
+    const reason =
+      "Issue carries a Definition of done checklist but no Acceptance criteria checklist — the refinement floor is the full AC/DoD/Non-goals matrix (#1877). " +
+      "Add an Acceptance criteria checklist to the issue body (for the DoD items to map to) " +
+      "(rule ARTIFACT-TRACKER-ISSUE-REFINEMENT-FLOOR; e.g. run `/dev-loops:loop-grill <issue> --auto` (or `/loop-grill <issue> --auto` in the dev-loops repo itself)) — refusing to enqueue without the full matrix.";
+    return { action: auto ? "divert" : "block", reason, missing: ["Acceptance criteria checklist"] };
+  }
   const missing = [...REFINEMENT_ARTIFACT_SOURCES];
   const reason =
     `Issue has no refinement artifact (none of: ${missing.join(", ")}). ` +
-    "Add at least ONE of them — an Acceptance criteria section, a Definition of done section, or a linked refinement doc " +
+    "Refine the issue to the full AC/DoD/Non-goals matrix — an Acceptance criteria checklist, a Definition of done checklist, and an explicit Non-goals section — " +
+    "or link a refinement doc (tmp/refinement/*.md), which is a complete artifact on its own " +
     "(e.g. run `/dev-loops:loop-grill <issue> --auto` (or `/loop-grill <issue> --auto` in the dev-loops repo itself), or the refiner) — before it enters the pickup queue.";
   return { action: auto ? "divert" : "block", reason, missing };
 }

package/src/loop/pr-gate-coordination.mjs

@@ -3,6 +3,11 @@ import { findBlockingTitleMarkers } from "./pr-title-markers.mjs";
 import { evaluateUiE2eScoping } from "./ui-e2e-scoping.mjs";
 import { evaluateUiDesignerReviewScoping } from "./ui-designer-review-scoping.mjs";
 import { trimmedOrNull } from "./normalize.mjs";
+import {
+  MISSING_AC_CHECKLIST_FINDING,
+  MISSING_DOD_CHECKLIST_FINDING,
+  MISSING_EXPLICIT_NON_GOALS_FINDING,
+} from "./issue-refinement-artifact.mjs";
 
 export const PR_CHECKPOINT = Object.freeze({
   DRAFT_REVIEW: "draft_review",
@@ -241,15 +246,35 @@ function normalizeRefinementArtifactStatus(value) {
 // their own validation-failure reason from the detector; that reason must
 // replace the "linked issue" wording, which does not apply when the PR is the
 // spec-of-record and no linked issue was ever expected.
+// #1877 full-matrix vocabulary for the draft-gate blocked reason: which
+// matrix arm is missing per finding — the SAME finding taxonomy the enqueue
+// gate's guidance (decideEnqueueRefinementGate) and the detector
+// (detectIssueRefinementArtifact) use, so the draft gate (the unconditional
+// backstop for that floor) cannot drift from it. An AC-only or DoD-only
+// linked issue is a matrix miss, not "no artifact" — the guidance must name
+// the actually-missing arm so the fix is not misdirected.
+const REFINEMENT_MISSING_ARM_BY_FINDING = Object.freeze({
+  [MISSING_DOD_CHECKLIST_FINDING]: "a Definition of done checklist (mapped to the acceptance criteria)",
+  [MISSING_AC_CHECKLIST_FINDING]: "an Acceptance criteria checklist (for the DoD items to map to)",
+  [MISSING_EXPLICIT_NON_GOALS_FINDING]: "an explicit Non-goals section",
+});
+
 function formatRefinementBlockedReason(linkedIssue, status, refinementArtifact) {
   const specSource = refinementArtifact?.specSource;
   if (specSource != null && specSource !== REFINEMENT_ARTIFACT_SPEC_SOURCE.LINKED_ISSUE && typeof refinementArtifact?.reason === "string" && refinementArtifact.reason.length > 0) {
     return `The draft gate cannot complete: ${refinementArtifact.reason} finding=${REFINEMENT_ARTIFACT_FINDING}`;
   }
+  const finding = typeof refinementArtifact?.finding === "string" && refinementArtifact.finding.length > 0
+    ? refinementArtifact.finding
+    : REFINEMENT_ARTIFACT_FINDING;
+  const missingArm = REFINEMENT_MISSING_ARM_BY_FINDING[finding];
+  if (missingArm !== undefined) {
+    return `Linked issue #${linkedIssue} has an incomplete refinement matrix — it is missing ${missingArm}. Add it to the issue body to complete the full AC/DoD/Non-goals matrix, then re-open the draft PR. finding=${finding}`;
+  }
   if (linkedIssue !== null && Number.isInteger(linkedIssue)) {
-    return `Linked issue #${linkedIssue} has no refinement artifact (Acceptance criteria / DoD / linked refinement doc). Run refinement first, add ACs/DoD to the issue, then re-open the draft PR. finding=${REFINEMENT_ARTIFACT_FINDING}`;
+    return `Linked issue #${linkedIssue} has no refinement artifact (no Acceptance criteria checklist, DoD checklist, or resolvable linked refinement doc). Refine the issue to the full AC/DoD/Non-goals matrix — or link a refinement doc (tmp/refinement/*.md), a complete artifact on its own — then re-open the draft PR. finding=${REFINEMENT_ARTIFACT_FINDING}`;
   }
-  return `The draft gate cannot complete: the linked issue has no detectable refinement artifact (Acceptance criteria / DoD / linked refinement doc). finding=${REFINEMENT_ARTIFACT_FINDING}`;
+  return `The draft gate cannot complete: the linked issue has no detectable refinement artifact (no Acceptance criteria checklist, DoD checklist, or resolvable linked refinement doc). finding=${REFINEMENT_ARTIFACT_FINDING}`;
 }
 
 // #1472: describes the CI state a round-cap-reached fallback branch actually

package/src/loop/queue-board-sync.mjs

@@ -172,9 +172,8 @@ function readDevloopsSettings(repoRoot) {
     try {
       const raw = readFileSync(base + ext, "utf8");
       const settings = ext === ".json" ? JSON.parse(raw) : parseYaml(raw);
-      // `tracker` (issue #1408, the tracker-agnostic seam) is surfaced
-      // alongside `queue` so loadBoardConfig can prefer tracker.board over
-      // the deprecated queue.board without a second file read.
+      // `tracker` (issue #1408, the tracker-agnostic seam) is surfaced so
+      // loadBoardConfig can read tracker.board directly.
       return { settings: settings?.queue ?? null, tracker: settings?.tracker ?? null };
     } catch (err) {
       if (err?.code === "ENOENT") {
@@ -204,18 +203,15 @@ function boardSelector(board) {
 }
 
 export function loadBoardConfig(repoRoot) {
-  const { settings: queue, tracker, error } = readDevloopsSettings(repoRoot);
+  const { tracker, error } = readDevloopsSettings(repoRoot);
   if (error) {
     return { enabled: false, reason: `config read/parse error: ${error}` };
   }
-  // tracker.board (canonical) takes priority over the deprecated queue.board
-  // (issue #1408) — see resolveTrackerBoard in ../config/config.mjs for the
-  // equivalent resolution against the validated, loaded config.
+  // tracker.board (canonical board key, issue #1408) — see resolveTrackerBoard
+  // in ../config/config.mjs for the equivalent resolution against the
+  // validated, loaded config.
   const trackerBoard = boardSelector(tracker?.board);
   if (trackerBoard) return trackerBoard;
-  if (!queue) return { enabled: false };
-  const queueBoard = boardSelector(queue.board);
-  if (queueBoard) return queueBoard;
   return { enabled: false };
 }
 

package/src/projects/resolve-project.mjs

@@ -6,9 +6,9 @@ import { parse as parseYaml } from "yaml";
 // resolution used by ensure-queue-board.mjs. Returns { project }, { title },
 // and/or { olderThanDays } when configured; never throws on a missing/bad file.
 //
-// `tracker.board` (issue #1408, the tracker-agnostic seam) takes priority over
-// the deprecated `queue.board` — same precedence as loadBoardConfig in
-// ../loop/queue-board-sync.mjs and resolveTrackerBoard in ../config/config.mjs.
+// The board resolves from `tracker.board` (issue #1408, the tracker-agnostic
+// seam) — same source as loadBoardConfig in ../loop/queue-board-sync.mjs and
+// resolveTrackerBoard in ../config/config.mjs.
 function resolveSettings(cwd) {
   const basePath = path.join(cwd, ".devloops");
   const extensions = ["", ".yaml", ".yml", ".json"];
@@ -18,7 +18,7 @@ function resolveSettings(cwd) {
       const settings = ext === ".json" ? JSON.parse(raw) : parseYaml(raw);
       const queue = settings?.queue;
       const out = {};
-      const board = settings?.tracker?.board ?? queue?.board;
+      const board = settings?.tracker?.board;
       if (board && typeof board === "object") {
         if (typeof board.number === "number" && Number.isInteger(board.number) && board.number > 0) {
           out.project = board.number;
@@ -139,7 +139,7 @@ function resolveProjectSelector(args) {
     : null;
   if (!projectRef && !projectTitle) {
     throw Object.assign(
-      new Error("--project is required (or set tracker.board — or the deprecated queue.board — number / title in .devloops)"),
+      new Error("--project is required (or set tracker.board number / title in .devloops)"),
       { code: "INVALID_PROJECT" },
     );
   }
@@ -178,7 +178,7 @@ function findProject(projects, { projectRef, projectTitle }, owner) {
 }
 
 // Apply .devloops board settings when --project was not passed. Precedence:
-// explicit --project flag > queue.board.number/queue.board.title. Mutates args.
+// explicit --project flag > tracker.board.number/tracker.board.title. Mutates args.
 function applyDevloopsBoard(args, cwd) {
   if (args.project === undefined) {
     const settings = resolveSettings(cwd);