@event4u/agent-config 14.13.0 → 14.14.0

package/dist/mcp/registry-manifest.json

@@ -3,13 +3,13 @@
     "artefact_count": 623,
     "scanner_version": "de0a22b4ac4c"
   },
-  "generated_at": "2026-08-31",
+  "generated_at": "2026-09-02",
   "package": {
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) \u2014 every claim machine-checked, including the counts in these badges.",
     "homepage": "https://event4u-app.github.io/agent-config",
     "name": "@event4u/agent-config",
     "repository": "https://github.com/event4u-app/agent-config",
-    "version": "14.13.0"
+    "version": "14.14.0"
   },
   "registries": [
     {

package/dist/mcp/server.json

@@ -9,12 +9,12 @@
       "transport": {
         "type": "stdio"
       },
-      "version": "14.13.0"
+      "version": "14.14.0"
     }
   ],
   "repository": {
     "source": "github",
     "url": "https://github.com/event4u-app/agent-config"
   },
-  "version": "14.13.0"
+  "version": "14.14.0"
 }

package/dist/mcp/server.mjs

@@ -18969,6 +18969,11 @@ var init_dashboard_mode = __esm({
 import * as fs23 from "node:fs";
 import * as path22 from "node:path";
 import { fileURLToPath as fileURLToPath17, pathToFileURL as pathToFileURL9 } from "node:url";
+function is_blocked_quickwin(design_validated, capability_gap, blocker_class2) {
+  if (design_validated === null || design_validated === "") return false;
+  if (capability_gap !== "none") return false;
+  return QUICKWIN_BLOCKER_CLASSES.includes(blocker_class2 ?? "");
+}
 function _isDir8(p) {
   try {
     return fs23.statSync(p).isDirectory();
@@ -19063,9 +19068,27 @@ function _parseIso(s) {
   return Number.isNaN(d.getTime()) ? null : d;
 }
 function scan(root, today) {
-  return scan_dir(path22.join(root, STUB_DIR), today);
+  return scan_dir(path22.join(root, STUB_DIR), today, release_dates(root));
+}
+function release_dates(root) {
+  const out = [];
+  for (const rel of CHANGELOG_ERAS) {
+    let text;
+    try {
+      text = fs23.readFileSync(path22.join(root, rel), "utf8");
+    } catch {
+      continue;
+    }
+    for (const m of text.matchAll(RELEASE_HEADING)) {
+      if (m[1] !== void 0) out.push(m[1]);
+    }
+  }
+  return out;
 }
-function scan_dir(base, today) {
+function releases_since(opened, dates) {
+  return dates.filter((d) => d > opened).length;
+}
+function scan_dir(base, today, releaseDates = []) {
   if (!_isDir8(base)) return [];
   const now = _parseIso(today);
   const out = [];
@@ -19086,6 +19109,10 @@ function scan_dir(base, today) {
     const review_by = _scalar(front, "review_by");
     const reviewed_at = _scalar(front, "reviewed_at");
     const probeVal = _scalar(front, "probe");
+    const design_validated = _scalar(front, "design_validated");
+    const capability_gap = _scalar(front, "capability_gap");
+    const blocker_class2 = _scalar(front, "blocker_class");
+    const blocker_opened = _scalar(front, "blocker_opened");
     const shape = text.includes(TRANSFER_MARKER) ? "transfer" : "orgmode";
     let overdue = false;
     let days_overdue = null;
@@ -19105,7 +19132,13 @@ function scan_dir(base, today) {
       has_probe_heading: /^#{1,4} *(Probe|Promotion)/m.test(text),
       owner_decisions: count_owner_decisions(text),
       overdue,
-      days_overdue
+      days_overdue,
+      design_validated,
+      capability_gap,
+      blocker_class: blocker_class2,
+      blocker_opened,
+      releases_since_blocked: blocker_opened === null ? null : releases_since(blocker_opened, releaseDates),
+      blocked_quickwin: is_blocked_quickwin(design_validated, capability_gap, blocker_class2)
     });
   }
   return out;
@@ -19115,6 +19148,7 @@ function counts(records) {
     overdue: records.filter((r) => r.overdue).length,
     owner_decisions: records.reduce((s, r) => s + r.owner_decisions, 0),
     missing_review_by: records.filter((r) => r.review_by === null).length,
+    blocked_quickwin: records.filter((r) => r.blocked_quickwin).length,
     total: records.length
   };
 }
@@ -19178,6 +19212,20 @@ function main9(argv = process.argv.slice(2)) {
     process.stdout.write(":\n");
     for (const r of withDecisions) {
       process.stdout.write(`      ${r.file}  (${r.owner_decisions})
+`);
+    }
+  }
+  const quickwins = records.filter((r) => r.blocked_quickwin);
+  if (quickwins.length > 0) {
+    process.stdout.write(
+      `
+  \u{1F513}  ${quickwins.length} BLOCKED QUICK-WIN(S) \u2014 design validated, no capability gap,
+      held by an estate or budget decision rather than a product one:
+`
+    );
+    for (const r of quickwins) {
+      const since = r.releases_since_blocked === null ? "no `blocker_opened:`" : `${String(r.releases_since_blocked)} release(s) since ${r.blocker_opened}`;
+      process.stdout.write(`      ${r.file}  (${r.blocker_class}, ${since})
 `);
     }
   }
@@ -19227,7 +19275,7 @@ function headerFragment(stubsDir, today) {
   }
   return ` \xB7 **${overdue}** overdue stub${overdue !== 1 ? "s" : ""}, **${decisions}** owner decision${decisions !== 1 ? "s" : ""} \u2192 \`agent-config stubs:due\``;
 }
-var STUB_DIR, CADENCE_DAYS, TRANSFER_MARKER, _HERE6;
+var STUB_DIR, CADENCE_DAYS, TRANSFER_MARKER, _HERE6, QUICKWIN_BLOCKER_CLASSES, CHANGELOG_ERAS, RELEASE_HEADING;
 var init_stubs_due = __esm({
   "src/agent-src/scripts/stubs_due.ts"() {
     "use strict";
@@ -19235,6 +19283,9 @@ var init_stubs_due = __esm({
     CADENCE_DAYS = { transfer: 30, orgmode: 120 };
     TRANSFER_MARKER = "drain-run transfer";
     _HERE6 = path22.resolve(fileURLToPath17(import.meta.url));
+    QUICKWIN_BLOCKER_CLASSES = ["estate", "budget"];
+    CHANGELOG_ERAS = ["CHANGELOG.md", "docs/archive/CHANGELOG-pre-14.12.0.md"];
+    RELEASE_HEADING = /^## \[\d+\.\d+\.\d+\][^\n]*\((\d{4}-\d{2}-\d{2})\)\s*$/gm;
     if (_isCliEntry9() || process.argv[1] === _HERE6) {
       process.exitCode = main9();
     }
@@ -19348,15 +19399,21 @@ function guardedBaselineStaleness(items, repo_root2) {
     if (trigger === "") {
       continue;
     }
-    for (const token of trigger.split(/[\s,]+/).filter((t) => t !== "")) {
-      if (!token.includes("/")) {
-        unverifiable.push(`line ${it.line} (${it.label}): recheck_when \`${token}\``);
-      } else if (fs24.existsSync(path23.join(repo_root2, token))) {
+    const tokens = trigger.split(/[\s,]+/).filter((t) => t !== "");
+    const paths = tokens.filter((t) => t.includes("/"));
+    for (const token of paths) {
+      if (fs24.existsSync(path23.join(repo_root2, token))) {
         stale.push(
           `line ${it.line} (${it.label}): recheck_when \`${token}\` now exists \u2014 re-verify against the real mechanism`
         );
       }
     }
+    if (paths.length > 0) {
+      continue;
+    }
+    for (const token of tokens) {
+      unverifiable.push(`line ${it.line} (${it.label}): recheck_when \`${token}\``);
+    }
   }
   return { stale, unverifiable };
 }
@@ -19435,8 +19492,8 @@ __export(update_roadmap_progress_exports, {
   collect: () => collect,
   collect_bundles: () => collect_bundles,
   count_checkboxes: () => count_checkboxes,
-  is_draft: () => is_draft,
   is_roadmap_candidate: () => is_roadmap_candidate,
+  is_unscheduled: () => is_unscheduled,
   main: () => main10,
   merge_gated_pending: () => merge_gated_pending,
   parse_blockers: () => parse_blockers,
@@ -19492,8 +19549,8 @@ function _stripQuotes2(s) {
   out = out.replace(/^'+/, "").replace(/'+$/, "");
   return out;
 }
-function is_draft(fm) {
-  return DRAFT_VALUES.has((fm["status"] ?? "").toLowerCase());
+function is_unscheduled(fm) {
+  return UNSCHEDULED_VALUES.has((fm["status"] ?? "").toLowerCase());
 }
 function is_roadmap_name(name) {
   if (EXCLUDE_NAMES.has(name)) {
@@ -19785,7 +19842,7 @@ function collect(roadmap_root) {
       continue;
     }
     const text = fs25.readFileSync(p, { encoding: "utf-8" });
-    if (is_draft(parse_frontmatter2(text))) {
+    if (is_unscheduled(parse_frontmatter2(text))) {
       continue;
     }
     const stats = parse_roadmap(p, roadmap_root);
@@ -19815,7 +19872,7 @@ function collect_parked(roadmap_root) {
     } catch {
       continue;
     }
-    if (is_draft(parse_frontmatter2(text))) {
+    if (is_unscheduled(parse_frontmatter2(text))) {
       continue;
     }
     const cell = resume_cell(text);
@@ -20270,7 +20327,7 @@ function _isCliEntry10() {
     return false;
   }
 }
-var _HERE7, _require3, CHECKBOX_RE, PHASE_RE, TITLE_RE, EXCLUDE_NAMES, EXCLUDE_PREFIXES, EXCLUDE_DIRS, FRONTMATTER_RE, DRAFT_VALUES, MERGE_GATED_RE, PR_NUM_RE, PhaseStats, RoadmapStats, FENCED_CODE_RE, BLOCKERS_SECTION_RE, BLOCKER_HEADING_RE, NEXT_H2_RE, LEGACY_BLOCKED_UNTIL_RE, BLOCKER_FIELD_RE, RESUME_STATEMENT, RESUME_LOOSE, ArgparseExit, _PROG5;
+var _HERE7, _require3, CHECKBOX_RE, PHASE_RE, TITLE_RE, EXCLUDE_NAMES, EXCLUDE_PREFIXES, EXCLUDE_DIRS, FRONTMATTER_RE, UNSCHEDULED_VALUES, MERGE_GATED_RE, PR_NUM_RE, PhaseStats, RoadmapStats, FENCED_CODE_RE, BLOCKERS_SECTION_RE, BLOCKER_HEADING_RE, NEXT_H2_RE, LEGACY_BLOCKED_UNTIL_RE, BLOCKER_FIELD_RE, RESUME_STATEMENT, RESUME_LOOSE, ArgparseExit, _PROG5;
 var init_update_roadmap_progress = __esm({
   "src/agent-src/scripts/update_roadmap_progress.ts"() {
     "use strict";
@@ -20292,7 +20349,7 @@ var init_update_roadmap_progress = __esm({
     EXCLUDE_PREFIXES = ["open-questions"];
     EXCLUDE_DIRS = /* @__PURE__ */ new Set(["archive", "skipped", "stubs", "later"]);
     FRONTMATTER_RE = /^---\n([\s\S]*?)\n---[ \t\n\r\f\v]*\n/;
-    DRAFT_VALUES = /* @__PURE__ */ new Set(["draft"]);
+    UNSCHEDULED_VALUES = /* @__PURE__ */ new Set(["draft", "carrier"]);
     MERGE_GATED_RE = /merge-gated/i;
     PR_NUM_RE = /pr[ \t\n\r\f\v]*[=#:]?[ \t\n\r\f\v]*#?[ \t\n\r\f\v]*(\d+)/gi;
     PhaseStats = class {
@@ -20432,6 +20489,7 @@ __export(archive_completed_roadmaps_exports, {
   _git_mv: () => _git_mv,
   _inbound_ref_rewrite: () => _inbound_ref_rewrite,
   _is_frozen_record: () => _is_frozen_record,
+  _relatesTo: () => _relatesTo,
   _repo_root: () => _repo_root,
   archive_completed: () => archive_completed,
   deferralProblems: () => deferralProblems,
@@ -36552,11 +36610,48 @@ function humanAuthoredLead(text) {
   }
   return kept.join("\n");
 }
-var DOCUMENT_HEAD;
+function stripInjectedRegions(text) {
+  const lines = text.split("\n");
+  const kept = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const open = REGION_OPEN.exec(line);
+    if (open === null) {
+      kept.push(line);
+      continue;
+    }
+    const close = new RegExp(`^\\s*</${open[1] ?? ""}>\\s*$`);
+    let end = -1;
+    for (let j = i + 1; j < lines.length; j++) {
+      if (close.test(lines[j] ?? "")) {
+        end = j;
+        break;
+      }
+    }
+    if (end === -1) {
+      kept.push(line);
+      continue;
+    }
+    if (kept.length > 0 && REGION_NOTE.test(kept[kept.length - 1] ?? "")) {
+      kept.pop();
+    }
+    i = end;
+    while (i + 1 < lines.length && (lines[i + 1] ?? "").trim() !== "") {
+      if (!REGION_NOTE.test(lines[i + 1] ?? "")) {
+        break;
+      }
+      i++;
+    }
+  }
+  return kept.join("\n");
+}
+var DOCUMENT_HEAD, REGION_OPEN, REGION_NOTE;
 var init_prompt_shape = __esm({
   "src/scripts/_lib/prompt_shape.ts"() {
     "use strict";
     DOCUMENT_HEAD = /^\s*(#{1,6}\s|-{3,}\s*$|={3,}\s*$|<[A-Za-z][\w-]*>\s*$)/;
+    REGION_OPEN = /^\s*<([A-Za-z][\w-]*)>\s*$/;
+    REGION_NOTE = /\b(content (above|below) is from|treat (it|this|that|the (content|text|above|following)) as data)\b/i;
   }
 });
 
@@ -36599,7 +36694,7 @@ function instructionText(prompt) {
   return kept.join("\n");
 }
 function classify(prompt) {
-  const text = instructionText(prompt);
+  const text = instructionText(stripInjectedRegions(prompt));
   const lead = humanAuthoredLead(text);
   const leadVerdict = _score2(lead);
   if (leadVerdict.language !== "und") {

package/docs/guidelines/agent-infra/guarded-baseline.md

@@ -34,6 +34,6 @@ Tooling, all of it in `guarded_baseline.ts` and enforced by both consumers:
 | Reported **separately**: a `## 🛡️ Guarded baselines` dashboard section plus a per-step stderr line | `update_roadmap_progress` |
 | **Rejected** — exit 1, on both `--check` and a plain regen — when `red_proof` is absent, when `category` is absent or illegal, when there is no evidence block, or when the annotation sits on anything but `- [ ]` | `update_roadmap_progress` |
 | Treated as **incomplete**: archival refused and the reason named | `archive_completed_roadmaps` |
-| Marked **stale** once a path-shaped `recheck_when` trigger resolves in the tree; a bare symbol trigger is reported as not machine-checkable rather than as not-stale | `guardedBaselineStaleness` |
+| Marked **stale** once a path-shaped `recheck_when` trigger resolves in the tree. A trigger carrying **no** path token at all is reported as not machine-checkable rather than as not-stale; a trigger carrying at least one path token is decided by that path and is **not** reported, even when a companion symbol token sits beside it — a checked trigger that looks unchecked is the mirror of the failure the report exists to prevent (measured 2026-09-01: 3 of 4 reported lines were already decidable) | `guardedBaselineStaleness` |
 
 Only verification against the real mechanism permits `[x]`. **A baseline that has not demonstrably gone RED is an ordinary open item** and must not carry the annotation at all — the sabotage-and-restore proof is the entry price, not a nice-to-have.

package/docs/guidelines/code-clarity.md

@@ -315,6 +315,24 @@ Behavioral baseline: `tests/code-comments/eval-fixtures.md`
 `ccd-untouched-preservation`, `ccd-explicit-teaching-override`); the decidable
 criteria are proven by `tests/scripts/code_comment_fixtures.test.ts`.
 
+### Evidence belongs in the roadmap that asked for it
+
+Measured 2026-09-02 in a consumer repository: **509 German comment lines** and
+**21 report- or provenance-shaped comments** across **41 of 45** changed source
+files, the worst a 101-line colour-analysis report inside a CSS file. The cause
+was a roadmap requiring proof for every checked step: the run read that as
+*evidence should be documented* and wrote the measurements into the source too,
+where the roadmap already carried them.
+
+The provenance of a value is not a WHY, and a roadmap cannot license a comment
+the rule forbids.
+
+Two enforcers carry this because neither rule could fire on a write:
+`code-comment-discipline` matches prompt keywords, and `language-and-tone`'s
+English-comment clause named a `.md`-only validator. `lint_code_comments`
+refuses on the diff; the `comment-discipline` concern reports on the text as
+written. Neither replaces the discipline.
+
 ## See also
 
 - Language-specific anchors that link to this guideline:

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@event4u/agent-config",
     "mcpName": "io.github.event4u-app/agent-config",
-    "version": "14.13.0",
+    "version": "14.14.0",
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) — every claim machine-checked, including the counts in these badges.",
     "license": "MIT",
     "private": false,

package/src/agent-src/scripts/archive_completed_roadmaps.ts

@@ -12,8 +12,8 @@
  * `urp.collect()` completion criterion, and exit code 0. snake_case kept.
  *
  * A roadmap that has reached `count_open == 0` and `count_deferred == 0` is
- * **complete**. This sweep moves it to `agents/roadmaps/archive/`, rewrites
- * inbound references (`agents/roadmaps/<x>.md` → `agents/roadmaps/archive/<x>.md`)
+ * **complete**. This sweep moves it to `agents/roadmaps/archive/`, rewrites code-comment-allow provenance-comment -- the sweep's own operand
+ * inbound references (`agents/roadmaps/<x>.md` → `agents/roadmaps/archive/<x>.md`) code-comment-allow provenance-comment -- the rewrite this sweep performs
  * across tracked files so links never break, and regenerates the dashboard.
  *
  * It replaces the old **merge-gate** (keep one item open + a manual post-merge
@@ -136,7 +136,7 @@ function _branch_touched_paths(root: string, base: string): Set<string> | null {
  *
  * Two classes, and the second is why this predicate exists at all:
  *
- * - `agents/evidence/**` — a committed record of what was true, or of what a
+ * - `agents/evidence/**` — a committed record of what was true, or of what a code-comment-allow provenance-comment -- the predicate's operand set
  *   reviewer was shown, at one point in time. Retroactively editing it makes it
  *   claim something that did not happen, which is the failure
  *   `evaluator-independence` exists to prevent ("the prompt ships with the
@@ -146,7 +146,7 @@ function _branch_touched_paths(root: string, base: string): Set<string> | null {
  *   AND makes `git apply` target a path the diff never created.
  *
  * Measured 2026-08-11: archiving one roadmap rewrote four frozen artifacts
- * under `agents/evidence/reviews/`, including the `diff.patch` headers of a
+ * under `agents/evidence/reviews/`, including the `diff.patch` headers of a code-comment-allow provenance-comment -- names what the predicate protects
  * recorded review input. Nothing caught it — the sweep reported it as
  * "4 ref(s) migrated", which reads like success.
  */
@@ -346,7 +346,7 @@ function _escapeRe(v: string): string {
  * bare `- <name>` item inside the `relates:` block, which is a declaration the
  * author made deliberately. A mention anywhere else in the file does not count.
  */
-function _relatesTo(text: string, slug: string): boolean {
+export function _relatesTo(text: string, slug: string): boolean {
     const lines = text.split('\n');
     const start = lines.findIndex((l) => /^relates:/.test(l));
     if (start === -1) return false;
@@ -654,7 +654,7 @@ function _regen_dashboard(root: string, dry_run: boolean): void {
 /**
  * Rebuild the archive index after a move, when the builder is present.
  *
- * The sweep is the one operation that changes what `agents/roadmaps/archive/`
+ * The sweep is the one operation that changes what `agents/roadmaps/archive/` code-comment-allow provenance-comment -- the directory this function writes
  * contains, so it is the one operation that can leave the generated index
  * stale — and the drift gate on that index runs in the same PR the sweep runs
  * in. Regenerating here keeps the two from disagreeing by construction rather

package/src/agent-src/scripts/guarded_baseline.ts

@@ -226,9 +226,18 @@ export function guardedBaselineProblems(items: readonly GuardedBaselineItem[]):
  *
  * HONEST SCOPE. Only a PATH trigger is machine-checkable: a token containing `/`
  * is resolved against the repo root and stale iff it exists. A bare symbol name
- * cannot be decided from a path, so it is returned as `unverifiable` rather than
- * silently reading as "not stale" — an unchecked trigger that looks checked is
- * the failure this whole state exists to avoid.
+ * cannot be decided from a path, so a record carrying ONLY symbol tokens is
+ * returned as `unverifiable` rather than silently reading as "not stale" — an
+ * unchecked trigger that looks checked is the failure this whole state exists
+ * to avoid.
+ *
+ * A record whose trigger carries AT LEAST ONE path token is decided by that
+ * path and is NOT reported as unverifiable, even when a companion symbol token
+ * sits beside it. Reporting it would be the mirror of the failure above: a
+ * checked trigger that looks unchecked. Measured 2026-09-01 — three of the four
+ * lines the dashboard printed as "not machine-checkable" carried a path token
+ * and were therefore already decidable, which is noise that trains a reader to
+ * skip the section where the one genuinely undecidable trigger also lives.
  */
 export function guardedBaselineStaleness(
     items: readonly GuardedBaselineItem[],
@@ -241,16 +250,22 @@ export function guardedBaselineStaleness(
         if (trigger === '') {
             continue;
         }
-        for (const token of trigger.split(/[\s,]+/).filter((t) => t !== '')) {
-            if (!token.includes('/')) {
-                unverifiable.push(`line ${it.line} (${it.label}): recheck_when \`${token}\``);
-            } else if (fs.existsSync(path.join(repo_root, token))) {
+        const tokens = trigger.split(/[\s,]+/).filter((t) => t !== '');
+        const paths = tokens.filter((t) => t.includes('/'));
+        for (const token of paths) {
+            if (fs.existsSync(path.join(repo_root, token))) {
                 stale.push(
                     `line ${it.line} (${it.label}): recheck_when \`${token}\` now exists — ` +
                         're-verify against the real mechanism',
                 );
             }
         }
+        if (paths.length > 0) {
+            continue;
+        }
+        for (const token of tokens) {
+            unverifiable.push(`line ${it.line} (${it.label}): recheck_when \`${token}\``);
+        }
     }
     return { stale, unverifiable };
 }

package/src/agent-src/scripts/stubs_due.ts

@@ -66,6 +66,48 @@ export interface StubRecord {
     owner_decisions: number;
     overdue: boolean;
     days_overdue: number | null;
+    /** Frontmatter `design_validated:` — a citation, or null when absent. */
+    design_validated: string | null;
+    /** Frontmatter `capability_gap:` — `none` means the stub declares no gap. */
+    capability_gap: string | null;
+    /** Frontmatter `blocker_class:` — `estate` | `budget` | `product`. */
+    blocker_class: string | null;
+    /** Frontmatter `blocker_opened:` — ISO date the hold began, or null. */
+    blocker_opened: string | null;
+    /** Releases published since `blocker_opened`, or null when it is absent. */
+    releases_since_blocked: number | null;
+    /** All three membership conditions hold. See {@link BLOCKED_QUICKWIN_FIELDS}. */
+    blocked_quickwin: boolean;
+}
+
+/**
+ * The three frontmatter keys that decide fourth-bucket membership.
+ *
+ * Read as SCALARS, never as substrings of the body. A substring match over
+ * prose is what put a validated fix and a waiting preference into one bucket
+ * in the first place; doing it with three substrings instead of one would be
+ * worse, not better. A stub missing any of the three is not a member and falls
+ * through to the OWNER bucket exactly as before — absence is never a member.
+ */
+export const BLOCKED_QUICKWIN_FIELDS = ['design_validated', 'capability_gap', 'blocker_class'] as const;
+
+/** Blocker classes that make a stub a BLOCKED QUICK-WIN rather than a product wait. */
+export const QUICKWIN_BLOCKER_CLASSES = ['estate', 'budget'] as const;
+
+/**
+ * All three conditions, read from frontmatter only.
+ *
+ * A recorded design validation, an explicit `capability_gap: none`, and an open
+ * blocker that is an estate or budget decision rather than a product one.
+ */
+export function is_blocked_quickwin(
+    design_validated: string | null,
+    capability_gap: string | null,
+    blocker_class: string | null,
+): boolean {
+    if (design_validated === null || design_validated === '') return false;
+    if (capability_gap !== 'none') return false;
+    return (QUICKWIN_BLOCKER_CLASSES as readonly string[]).includes(blocker_class ?? '');
 }
 
 function _isDir(p: string): boolean {
@@ -188,7 +230,48 @@ function _parseIso(s: string): Date | null {
 
 /** Read every stub and classify it. `today` is injectable so tests are stable. */
 export function scan(root: string, today: string): StubRecord[] {
-    return scan_dir(path.join(root, STUB_DIR), today);
+    return scan_dir(path.join(root, STUB_DIR), today, release_dates(root));
+}
+
+/**
+ * Changelog files that carry released sections, newest era first.
+ *
+ * BOTH are read, and that is the whole point of the pair. The era split moved
+ * older releases into the archive, so a count taken over the current file alone
+ * silently reports zero for anything before the split — measured: 14.11.0 lives
+ * only in the archive, and grepping `CHANGELOG.md` for it returns nothing.
+ */
+export const CHANGELOG_ERAS = ['CHANGELOG.md', 'docs/archive/CHANGELOG-pre-14.12.0.md'] as const;
+
+/** `## [x.y.z](…) (YYYY-MM-DD)` — a released section heading with its date. */
+const RELEASE_HEADING = /^## \[\d+\.\d+\.\d+\][^\n]*\((\d{4}-\d{2}-\d{2})\)\s*$/gm;
+
+/** Every released section's date across both eras, unsorted. */
+export function release_dates(root: string): string[] {
+    const out: string[] = [];
+    for (const rel of CHANGELOG_ERAS) {
+        let text: string;
+        try {
+            text = fs.readFileSync(path.join(root, rel), 'utf8');
+        } catch {
+            continue;
+        }
+        for (const m of text.matchAll(RELEASE_HEADING)) {
+            if (m[1] !== undefined) out.push(m[1]);
+        }
+    }
+    return out;
+}
+
+/**
+ * Releases published strictly AFTER the day the hold began.
+ *
+ * Strictly after, because a release cut on the same day cannot have carried a
+ * fix the hold was blocking — counting it would inflate the figure the
+ * council's falsifier is read against.
+ */
+export function releases_since(opened: string, dates: readonly string[]): number {
+    return dates.filter((d) => d > opened).length;
 }
 
 /**
@@ -198,7 +281,11 @@ export function scan(root: string, today: string): StubRecord[] {
  * immediately re-join — a fragile round trip past exactly the directory both
  * callers care about.
  */
-export function scan_dir(base: string, today: string): StubRecord[] {
+export function scan_dir(
+    base: string,
+    today: string,
+    releaseDates: readonly string[] = [],
+): StubRecord[] {
     if (!_isDir(base)) return [];
     const now = _parseIso(today);
     const out: StubRecord[] = [];
@@ -222,6 +309,10 @@ export function scan_dir(base: string, today: string): StubRecord[] {
         const review_by = _scalar(front, 'review_by');
         const reviewed_at = _scalar(front, 'reviewed_at');
         const probeVal = _scalar(front, 'probe');
+        const design_validated = _scalar(front, 'design_validated');
+        const capability_gap = _scalar(front, 'capability_gap');
+        const blocker_class = _scalar(front, 'blocker_class');
+        const blocker_opened = _scalar(front, 'blocker_opened');
         const shape: StubShape = text.includes(TRANSFER_MARKER) ? 'transfer' : 'orgmode';
         let overdue = false;
         let days_overdue: number | null = null;
@@ -242,6 +333,13 @@ export function scan_dir(base: string, today: string): StubRecord[] {
             owner_decisions: count_owner_decisions(text),
             overdue,
             days_overdue,
+            design_validated,
+            capability_gap,
+            blocker_class,
+            blocker_opened,
+            releases_since_blocked:
+                blocker_opened === null ? null : releases_since(blocker_opened, releaseDates),
+            blocked_quickwin: is_blocked_quickwin(design_validated, capability_gap, blocker_class),
         });
     }
     return out;
@@ -251,6 +349,8 @@ export interface Counts {
     overdue: number;
     owner_decisions: number;
     missing_review_by: number;
+    /** ADDITIVE 2026-09-01. Existing keys are unchanged in name, type and meaning. */
+    blocked_quickwin: number;
     total: number;
 }
 
@@ -259,6 +359,7 @@ export function counts(records: StubRecord[]): Counts {
         overdue: records.filter((r) => r.overdue).length,
         owner_decisions: records.reduce((s, r) => s + r.owner_decisions, 0),
         missing_review_by: records.filter((r) => r.review_by === null).length,
+        blocked_quickwin: records.filter((r) => r.blocked_quickwin).length,
         total: records.length,
     };
 }
@@ -328,6 +429,21 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
         }
     }
 
+    const quickwins = records.filter((r) => r.blocked_quickwin);
+    if (quickwins.length > 0) {
+        process.stdout.write(
+            `\n  🔓  ${quickwins.length} BLOCKED QUICK-WIN(S) — design validated, no capability gap,\n` +
+                '      held by an estate or budget decision rather than a product one:\n',
+        );
+        for (const r of quickwins) {
+            const since =
+                r.releases_since_blocked === null
+                    ? 'no `blocker_opened:`'
+                    : `${String(r.releases_since_blocked)} release(s) since ${r.blocker_opened}`;
+            process.stdout.write(`      ${r.file}  (${r.blocker_class}, ${since})\n`);
+        }
+    }
+
     const noProbe = records.filter((r) => !r.probe_none && !r.has_probe_heading);
     if (noProbe.length > 0) {
         process.stdout.write(