@dzhechkov/harness-core 0.8.39 → 0.8.41

package/src/publish.ts

@@ -38,12 +38,29 @@ export type ProbeOutcome = {
 export const REGISTRY_PROBE_BUDGET = 90;
 export const REGISTRY_PROBE_INTERVAL_MS = 10_000;
 
+export type RegistryProbe =
+  | { kind: 'published'; version: string; scripted?: true }
+  | { kind: 'never-published'; scripted?: true }
+  | { kind: 'unknown'; reason: string; scripted?: true };
+
+/**
+ * Scripted registry seam for tests that spawn the REAL bin and therefore cannot inject `exec`
+ * (first-publish-not-offline AM-A; same shape as `WF_RUN_DISPATCH_SCRIPT_ENV`). Value: path to a JSON
+ * file `{ "<name>": "<x.y.z>" | "E404" | "<npm code>" }`. When set, no `npm view` runs at all and EVERY
+ * row carries `probeOverride: true` — a scripted plan can never read as a verified one.
+ */
+export const PUBLISH_PROBE_SCRIPT_ENV = 'DZ_PUBLISH_PROBE_SCRIPT';
+
 /** Result for a single package publish attempt. */
 export interface PublishResult {
   readonly name: string;
   readonly oldVersion: string;
   readonly newVersion: string;
   readonly status: 'published' | 'skipped' | 'error';
+  readonly firstPublish?: boolean;
+  readonly probe?: RegistryProbe['kind'];
+  /** Present (true) only when `DZ_PUBLISH_PROBE_SCRIPT` answered instead of the registry. */
+  readonly probeOverride?: boolean;
   readonly error?: string | undefined;
   /** Live publish only: how many registry probes were needed to confirm the exact new version. */
   readonly registryProbes?: number | undefined;
@@ -176,26 +193,54 @@ export function compareVersions(a: string, b: string): number {
   return a0 - b0 || a1 - b1 || a2 - b2;
 }
 
-/**
- * The version already published to npm for `name`, or `undefined` if the package
- * has never been published (or npm is unreachable). Used to bump from
- * max(local, published) so a locally-reverted version can't collide (audit #10).
- */
 type PublishExec = (command: string, options: ExecSyncOptionsWithStringEncoding) => string;
 
-function publishedVersion(name: string, exec: PublishExec = execSync): string | undefined {
+/** Only explicit npm absence signals establish that a package has never been published. */
+export function classifyRegistryProbe(stderr: string, message: string): RegistryProbe {
+  const detail = `${stderr}\n${message}`;
+  if (/\bcode E404\b/.test(detail) || /\b404 Not Found\b/.test(detail) || /is not in this registry/.test(detail)) {
+    return { kind: 'never-published' };
+  }
+  const reason = /npm error code (\S+)/.exec(detail)?.[1]
+    ?? stderr.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0)
+    ?? message;
+  return { kind: 'unknown', reason };
+}
+
+function scriptedProbe(name: string): RegistryProbe | undefined {
+  const scriptPath = process.env[PUBLISH_PROBE_SCRIPT_ENV];
+  if (typeof scriptPath !== 'string' || scriptPath === '') return undefined;
+  let table: Record<string, unknown>;
   try {
-    const out = exec(`npm view ${name} version --prefer-online`, { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf-8', timeout: 20000 }).trim();
-    return /^\d+\.\d+\.\d+/.test(out) ? out : undefined;
-  } catch {
-    return undefined; // 404 (never published) or offline → fall back to local
+    table = JSON.parse(readFileSync(scriptPath, 'utf-8')) as Record<string, unknown>;
+  } catch (err) {
+    return { kind: 'unknown', reason: `scripted probe unreadable: ${err instanceof Error ? err.message : String(err)}`, scripted: true };
+  }
+  const answer = table[name];
+  if (typeof answer !== 'string') return { kind: 'unknown', reason: `scripted probe has no entry for ${name}`, scripted: true };
+  if (/^\d+\.\d+\.\d+/.test(answer)) return { kind: 'published', version: answer, scripted: true };
+  if (answer === 'E404') return { kind: 'never-published', scripted: true };
+  return { kind: 'unknown', reason: answer, scripted: true };
+}
+
+function probeRegistry(name: string, exec: PublishExec = execSync): RegistryProbe {
+  const scripted = scriptedProbe(name);
+  if (scripted !== undefined) return scripted;
+  try {
+    const out = exec(`npm view ${name} version --prefer-online`, { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8', timeout: 20000 }).trim();
+    return /^\d+\.\d+\.\d+/.test(out)
+      ? { kind: 'published', version: out }
+      : { kind: 'unknown', reason: 'unparsable npm view output' };
+  } catch (err) {
+    const error = err as { stderr?: unknown; message?: unknown } | null | undefined;
+    return classifyRegistryProbe(String(error?.stderr ?? ''), String(error?.message ?? ''));
   }
 }
 
 /** The higher of the local version and the npm-published version (audit #10). */
 function maxPublished(name: string, localVersion: string, exec: PublishExec = execSync): string {
-  const pub = publishedVersion(name, exec);
-  return pub !== undefined && compareVersions(pub, localVersion) > 0 ? pub : localVersion;
+  const probe = probeRegistry(name, exec);
+  return probe.kind === 'published' && compareVersions(probe.version, localVersion) > 0 ? probe.version : localVersion;
 }
 
 // ── workspace-floor preflight (feature workspace-dep-protocol, Codex P1) ─────
@@ -829,6 +874,8 @@ export function publishPackages(
   opts: {
     dryRun?: boolean | undefined;
     filter?: string[] | undefined;
+    /** Exact CLI-selected batch; an empty list means no targets. Discovery remains unfiltered. */
+    targetNames?: readonly string[] | undefined;
     bumpOnly?: boolean | undefined;
     /**
      * Path to the Ed25519 signing key, OUTSIDE the repository. A pack that carries a
@@ -860,8 +907,8 @@ export function publishPackages(
     /**
      * Floor probe injection for the workspace-floor preflight (see
      * `findUnpublishedWorkspaceFloors`). Default: a real `npm view` probe, which runs only on LIVE
-     * publishes — dry-run stays offline, matching `maxPublished`. Injecting a probe also arms the
-     * preflight under dry-run, which is how the wiring test drives it without network.
+     * publishes. Injecting a probe also arms this floor preflight under dry-run. The package's
+     * own registry classification runs in both live and dry-run modes independently.
      */
     probeFloor?: ((name: string, version: string) => boolean) | undefined;
     /** Subprocess injection for tests; the default is Node's synchronous executor. */
@@ -907,9 +954,13 @@ export function publishPackages(
 
   const packages = discoverPackages(monorepoRoot);
   const results: PublishResult[] = [];
-  const filtered = opts.filter && opts.filter.length > 0
+  const registryProbes = new Map<string, RegistryProbe>();
+  const matching = opts.filter && opts.filter.length > 0
     ? packages.filter((p) => opts.filter!.some((f) => matchesPublishFilter(p, f, monorepoRoot)))
     : packages;
+  const filtered = opts.targetNames === undefined
+    ? matching
+    : matching.filter((p) => opts.targetNames!.includes(p.name));
   // Publish dependencies before dependents so pnpm rewrites workspace:* to the
   // freshly-bumped version, never a stale one (the harness-cli@0.3.122 breakage).
   const ordered = orderByDependencies(filtered);
@@ -1014,11 +1065,29 @@ export function publishPackages(
       failedInBatch.add(pkg.name);
       continue;
     }
-    // Bump from max(local, npm-published) so a locally-reverted version can't
-    // collide with an already-published one (audit #10). Dry-run stays offline
-    // (local only) to keep previews fast and network-free.
-    const base = opts.dryRun ? oldVersion : maxPublished(pkg.name, oldVersion, exec);
-    const newVersion = bumpPatch(base);
+    // Both modes establish registry state before planning: absence keeps the disk version,
+    // uncertainty refuses a bump, and an existing release bumps from max(local, published).
+    const registryProbe = probeRegistry(pkg.name, exec);
+    registryProbes.set(pkg.name, registryProbe);
+    if (registryProbe.kind === 'unknown') {
+      results.push({
+        name: pkg.name, oldVersion, newVersion: oldVersion,
+        status: opts.dryRun ? 'skipped' : 'error',
+        probe: 'unknown',
+        error: opts.dryRun
+          ? `NOT ESTABLISHED (registry unreachable: ${registryProbe.reason})`
+          : `registry unreachable: ${registryProbe.reason} — cannot tell "never published" from "offline"; not bumping blind`,
+      });
+      if (!opts.dryRun) failedInBatch.add(pkg.name);
+      continue;
+    }
+    const plan = {
+      base: registryProbe.kind === 'published' && compareVersions(registryProbe.version, oldVersion) > 0
+        ? registryProbe.version : oldVersion,
+      firstPublish: registryProbe.kind === 'never-published',
+      probe: registryProbe.kind,
+    };
+    const newVersion = plan.firstPublish ? oldVersion : bumpPatch(plan.base);
 
     // Preflight: refuse to publish a pack whose `files` whitelist would silently
     // drop a skill dir from the tarball (the bug that shipped skills-meta without
@@ -1113,7 +1182,7 @@ export function publishPackages(
     if (opts.dryRun) {
       // NOT a statement that the package would publish cleanly — only that the gates checked ABOVE
       // this line passed. Everything below it (build, re-sign, pack, the package's own
-      // `prepublishOnly`, the registry itself) is untouched by a dry run and is named as such.
+      // `prepublishOnly`, the registry's publish receipt) is untouched by a dry run and named as such.
       const NOT_VERIFIED_BY_DRY_RUN = Object.freeze([
         'prepublishOnly пакета (его собственный гейт публикации)',
         'сборка dist из исходников',
@@ -1492,7 +1561,17 @@ export function publishPackages(
   }
 
   return {
-    packages: results,
+    // Decorate every final path, including packed transport and gate failures. A dependency
+    // blocked before its own probe has unknown registry state; keep the deps-first short circuit.
+    packages: results.map((result) => {
+      const registryProbe = registryProbes.get(result.name);
+      return {
+        ...result,
+        probe: registryProbe?.kind ?? 'unknown',
+        ...(registryProbe?.kind === 'never-published' ? { firstPublish: true } : {}),
+        ...(registryProbe?.scripted === true ? { probeOverride: true } : {}),
+      };
+    }),
     published: results.filter((r) => r.status === 'published').length,
     skipped: results.filter((r) => r.status === 'skipped').length,
     errors: results.filter((r) => r.status === 'error').length,

package/src/registry.ts

@@ -8,9 +8,10 @@
  */
 
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync, type Dirent } from 'node:fs';
-import { basename, dirname, join, relative, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import { PACKAGE_SKILL_LAYOUTS } from './package-skill-layouts.js';
 import { stems } from './stem.js';
 
 /**
@@ -81,11 +82,13 @@ function readSkillDiscoveryConfig(cwd: string): { skillScopes: string[]; skillDi
 /** List `skills-*` pack directories across all base dirs, de-duplicated by pack name (first wins). */
 /**
  * Does this directory actually carry skills? Answers by LOOKING, so a pack is catalogued for what it
- * contains rather than for how it is named. Bounded on purpose: only the three layouts real packs
- * use (`skills/<id>/SKILL.md`, `<pack>/<id>/SKILL.md` for a single-skill pack, and a bare
- * `SKILL.md`), never a full-tree walk — an unbounded scan over `node_modules` would cost more than
- * the catalogue it builds. Templates are excluded: a template is a stamp for making skills, not an
- * installed skill, and counting it would list the same name twice.
+ * contains rather than for how it is named. Probes PACKAGE_SKILL_LAYOUTS — the ONE table that says
+ * where a package keeps its skills (backlog 86b787b8: the same three layouts used to be spelled out
+ * by hand here and in `buildRegistry`, so the next layout would land in one place and be forgotten
+ * in the other). Bounded on purpose: never a full-tree walk, because an unbounded scan over
+ * `node_modules` would cost more than the catalogue it builds. For the flat layout the package
+ * itself may also be a skill (a bare `SKILL.md`). `hasSkillMd` skips a `templates` child so a
+ * template stamp is not counted twice — it is reached only through its own allowed layout.
  */
 function packCarriesSkills(dir: string): boolean {
   const hasSkillMd = (d: string): boolean => {
@@ -98,13 +101,11 @@ function packCarriesSkills(dir: string): boolean {
     return false;
   };
   try {
-    if (existsSync(join(dir, 'SKILL.md'))) return true;
-    if (hasSkillMd(join(dir, 'skills'))) return true;
-    // A template pack ships the skills it will roll out into the user's project. From the
-    // catalogue's point of view those skills EXIST — `trip-planner` and `presentation-storyteller`
-    // are installable answers to a task — so hiding them makes the advisor deny a real capability.
-    if (hasSkillMd(join(dir, 'templates', '.claude', 'skills'))) return true;
-    return hasSkillMd(dir);
+    return PACKAGE_SKILL_LAYOUTS.some(({ rel }) => {
+      const root = rel === '.' ? dir : join(dir, rel);
+      if (rel === '.' && existsSync(join(root, 'SKILL.md'))) return true;
+      return hasSkillMd(root);
+    });
   } catch {
     return false;
   }
@@ -188,6 +189,42 @@ export function discoverSkillCarryingDirs(cwd: string): { pack: string; dir: str
  * drop the `unsigned` verdict for a `skills-*` pack that carries no manifest — turning "unsigned" into
  * "absent", which is the same class of silence this fixes.
  */
+/**
+ * Чей это пак: проекта, который проверяют, или самого прибора, который проверяет.
+ *
+ * ИЗМЕРЕНО 2026-09-21 на одном репозитории в одну минуту: `dz` из PATH перечисляет 88 паков и
+ * сообщает «31 verified», сборка из дерева — 57 и «0 verified». Оба ответа ВЕРНЫ и расходятся
+ * ровно на 29 подписанных манифестов внутри глобальной установки: `discoverVerifiablePackDirs`
+ * намеренно дотягивается до упакованных копий самого прибора. Беда не в числе, а в строке, где оно
+ * стоит: «31 verified» рядом с именем проекта читается как охват ПРОЕКТА, хотя проверены копии
+ * инструмента. Разделение считается по пути, потому что только путь и отличает эти два случая.
+ *
+ * Сравнение путей РАЗДЕЛИТЕЛЬНОЕ: `/repo-2/x` не внутри `/repo`. Наивный `startsWith` этот репозиторий
+ * уже однажды отгружал.
+ */
+export function packScope(dir: string, projectRoot: string): 'project' | 'instrument' {
+  const rel = relative(projectRoot, dir);
+  const inside = rel === '' || (!isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${sep}`));
+  return inside ? 'project' : 'instrument';
+}
+
+/**
+ * Уточнение к числу проверенных подписей: сколько из них — паки ЭТОГО проекта, а сколько принадлежат
+ * самому прибору. Возвращает ПУСТУЮ строку, когда уточнять нечего (ничего не проверено либо всё
+ * проверенное — проектное): приписка к нулю была бы шумом, а шум в строке охвата её и обесценивает.
+ */
+export function verifiedScopeNote(
+  checks: readonly { readonly dir: string; readonly verdict: string }[],
+  projectRoot: string,
+): string {
+  const verified = checks.filter((c) => c.verdict === 'verified');
+  if (verified.length === 0) return '';
+  const outside = verified.filter((c) => packScope(c.dir, projectRoot) === 'instrument').length;
+  if (outside === 0) return '';
+  return ` (${verified.length - outside} in this project, ${outside} in the instrument's own install`
+    + " — not this project's artifacts)";
+}
+
 export function discoverVerifiablePackDirs(cwd: string): { pack: string; dir: string }[] {
   const out: { pack: string; dir: string }[] = [];
   // Keyed on the RESOLVED path: a globally-installed `dz` reaches its own bundled packs as well as the
@@ -388,21 +425,80 @@ function categoryFromPack(pack: string): string {
  * `node_modules/@dzhechkov`, **and** the CLI's own install location. This is why
  * `dz registry` works for a globally-installed `dz`, not only inside the monorepo.
  */
+/** One skill as the public showcase page (`marketplace/index.html`) renders it. */
+export interface ShowcaseSkill {
+  readonly id: string;
+  readonly pack: string;
+  readonly description: string;
+  readonly trustTier: number;
+  readonly category: string;
+  /** The exact command a visitor copies. Derived, never stored — one spelling, one place. */
+  readonly install: string;
+}
+
+export interface ShowcaseRegistry {
+  readonly version: string;
+  readonly generated: string;
+  readonly totalSkills: number;
+  readonly totalPacks: number;
+  readonly categories: readonly string[];
+  readonly skills: readonly ShowcaseSkill[];
+}
+
+/**
+ * The public showcase catalogue, projected from the SAME {@link Registry} the plugin manifests come
+ * from — so the page and the manifests can never answer "how many skills are there" differently.
+ *
+ * Why this exists: MEASURED 2026-09-04 and re-measured 2026-09-20, `marketplace/registry.json` said
+ * 57 skills / 10 packs while `buildRegistry` counted 260 / 37, and the file's last commit was
+ * 2026-06-03 — because NOTHING wrote it. A grep for its path across the whole source tree returned
+ * zero writers (backlog 9595b21e). A catalogue with no generator does not go stale slowly; it stops
+ * being true the first time anything ships, and it was the one surface a visitor actually reads.
+ *
+ * `generated` is the caller's to supply: a timestamp minted inside would make the output
+ * non-reproducible and the drift gate unable to compare a fresh build against the published file.
+ */
+export function buildShowcaseRegistry(
+  registry: Registry,
+  opts: { readonly version: string; readonly generated: string },
+): ShowcaseRegistry {
+  return {
+    version: opts.version,
+    generated: opts.generated,
+    totalSkills: registry.totalSkills,
+    totalPacks: registry.totalPacks,
+    categories: [...registry.categories],
+    skills: registry.entries.map((e) => ({
+      id: e.id,
+      pack: e.pack,
+      description: e.description,
+      trustTier: e.trustTier,
+      category: e.category,
+      install: `dz init --target claude-code --select ${e.id}`,
+    })),
+  };
+}
+
 export function buildRegistry(cwd: string): Registry {
   const entries: RegistryEntry[] = [];
   const packs = discoverSkillCarryingDirs(cwd);
 
-  // A pack keeps its skills in one of three shapes, and reading only the first made 41 real skills
+  // The catalogue collects ALL allowed layouts, and reading only the first made 41 real skills
   // invisible (MEASURED 2026-09-01): the pack root (`skills-*` packs), a `skills/` subdirectory
   // (health-advisor and friends), and `templates/.claude/skills/` for packs that roll their skills
-  // out into the user's project. The catalogue answers "what can I use", so all three count.
-  const SKILL_LAYOUTS = [[], ['skills'], ['templates', '.claude', 'skills']] as const;
+  // out into the user's project. A template pack ships the skills it will roll out; from the
+  // catalogue's point of view those skills EXIST — `trip-planner` and `presentation-storyteller`
+  // are installable answers to a task — so hiding them would make the advisor deny a real
+  // capability. The layouts themselves now come from PACKAGE_SKILL_LAYOUTS so the knowledge lives
+  // in ONE place; resolvePackageSkillRoots deliberately selects only the FIRST non-empty root
+  // (installation semantics, plan AM-4) and therefore cannot serve this enumeration — calling it
+  // here would silently drop skills from a pack that fills two layouts (backlog 86b787b8).
   const seenSkillIds = new Set<string>();
 
   for (const { pack, dir: packDir } of packs) {
     const found: { name: string; root: string }[] = [];
-    for (const layout of SKILL_LAYOUTS) {
-      const root = layout.length === 0 ? packDir : join(packDir, ...layout);
+    for (const { rel } of PACKAGE_SKILL_LAYOUTS) {
+      const root = rel === '.' ? packDir : join(packDir, rel);
       if (!existsSync(root)) continue;
       try {
         for (const e of readdirSync(root, { withFileTypes: true })) {

package/src/release.ts

@@ -929,6 +929,42 @@ function fencedBlock(text: string, indent = '    '): string[] {
   return [`${indent}${fence}`, ...contentLines, `${indent}${fence}`];
 }
 
+/**
+ * Формы отказа `gh`, означающие «учётные данные не приняты», а не «команда не та».
+ * Список узкий намеренно: широкая сетка превратила бы любой сбой в повод лезть в окружение.
+ */
+const GH_AUTH_FAILURE_SHAPES: readonly RegExp[] = [
+  /no longer valid/i,
+  /bad credentials/i,
+  /authentication failed/i,
+  /requires authentication/i,
+  /gh auth login/i,
+  /HTTP 401/i,
+];
+
+/**
+ * Стоит ли повторить вызов `gh` БЕЗ переменной `GITHUB_TOKEN`.
+ *
+ * ИЗМЕРЕНО 2026-09-21 в этой среде: `gh auth status` → «the github.com token in GITHUB_TOKEN is no
+ * longer valid», а `env -u GITHUB_TOKEN gh auth status` → вход как djd1m через keyring. То есть
+ * мёртвая переменная ЗАТЕНЯЕТ рабочие учётные данные, и всякий вызов `gh` из скрипта падает
+ * (бэклог ead5f8e0). Переменная живёт в окружении tmux-сервера и снимается только владельцем.
+ *
+ * Почему повтор, а не безусловное снятие: в сборочной среде `GITHUB_TOKEN` — ШТАТНЫЙ способ
+ * авторизации, и выбрасывать его всегда значило бы ломать работающее ради сломанного. Поэтому
+ * сначала обычный вызов, и лишь на отказе ИМЕННО по авторизации — одна попытка без переменной.
+ */
+export function shouldRetryGhWithoutToken(input: {
+  readonly exitCode: number;
+  readonly stderr: string;
+  readonly stdout: string;
+  readonly tokenPresent: boolean;
+}): boolean {
+  if (input.exitCode === 0 || !input.tokenPresent) return false;
+  const text = `${input.stderr}\n${input.stdout}`;
+  return GH_AUTH_FAILURE_SHAPES.some((re) => re.test(text));
+}
+
 /**
  * gh-2.4-safe `gh issue create` payload (only `--title`/`--body` are assumed downstream).
  * Pure + deterministic for a fixed verdict — the issue is the verdict's echo, never its judge.

package/src/reqe-verdict.ts

@@ -0,0 +1,174 @@
+export type ReqeSeverity = 'BLOCKER' | 'HIGH' | 'MEDIUM' | 'LOW' | 'unknown';
+export interface ReqeSeverityCounts {
+  readonly blocker: number; readonly high: number; readonly medium: number;
+  readonly low: number;     readonly unknown: number;
+}
+/** `where` is null when the location cell is an em dash — the title alone is echoed (ADR AM-5). */
+export interface ReqeBlockingRow {
+  readonly severity: 'BLOCKER' | 'HIGH'; readonly title: string; readonly where: string | null;
+}
+/** THREE states, never two (03.5 C5b): `absent` = no Findings section; `rejected` = section present,
+ *  table not canonical, reason NAMED; `accepted` = parsed. */
+export type ReqeFindingsClass =
+  | { readonly kind: 'accepted'; readonly counts: ReqeSeverityCounts; readonly rows: number;
+      readonly declared: number | null; readonly blocking: readonly ReqeBlockingRow[] }
+  | { readonly kind: 'rejected'; readonly reason: string }
+  | { readonly kind: 'absent' };
+export type ReqePriorVerdict =
+  | { readonly kind: 'closed'; readonly closed: number; readonly total: number }
+  | { readonly kind: 'open'; readonly open: readonly number[]; readonly total: number }
+  | { readonly kind: 'unassessed' };
+export interface ReqeVerdict {
+  readonly new: 'ready' | 'blocked' | 'unassessed';
+  readonly prior: ReqePriorVerdict;
+  readonly findings: ReqeFindingsClass;
+  readonly counts: ReqeSeverityCounts;           // all zeros unless findings.kind === 'accepted'
+  readonly rows: number;                         // 0 unless accepted
+  readonly blocking: readonly ReqeBlockingRow[]; // [] unless accepted
+  readonly source: 'reviewer-declared';          // FR-6: the declarer is named in the data too
+}
+
+const emptyCounts = (): ReqeSeverityCounts => ({ blocker: 0, high: 0, medium: 0, low: 0, unknown: 0 });
+const heading = /^#{1,6}[ \t]+/;
+const findingsHeading = /^#{1,6}[ \t]*Findings(?:[ \t]+\((\d+)\))?[ \t]*$/;
+const expectedTable = 'expected severity plus finding/title and location/where columns';
+
+/** qe-findings.ts does not export maskMarkdown. This local fallback blanks fences and
+ * HTML comments without moving source lines, as permitted by the TASK-1 contract. */
+function maskMarkdown(text: string): string {
+  let fence: string | null = null;
+  let inComment = false;
+  return text.split('\n').map((line) => {
+    if (fence !== null) {
+      const close = /^ {0,3}(`{3,}|~{3,})[ \t]*\r?$/.exec(line)?.[1];
+      if (close && close[0] === fence[0] && close.length >= fence.length) fence = null;
+      return ' '.repeat(line.length);
+    }
+    let visible = '';
+    for (let i = 0; i < line.length;) {
+      if (inComment) {
+        const end = line.indexOf('-->', i);
+        if (end === -1) { visible += ' '.repeat(line.length - i); break; }
+        visible += ' '.repeat(end + 3 - i);
+        i = end + 3;
+        inComment = false;
+      } else {
+        const start = line.indexOf('<!--', i);
+        if (start === -1) { visible += line.slice(i); break; }
+        visible += line.slice(i, start) + '    ';
+        i = start + 4;
+        inComment = true;
+      }
+    }
+    const open = /^ {0,3}(`{3,}|~{3,})/.exec(visible)?.[1];
+    if (open) { fence = open; return ' '.repeat(line.length); }
+    return visible;
+  }).join('\n');
+}
+
+function cells(line: string): string[] {
+  const parts = line.trim().split(/(?<!\\)\|/);
+  if (parts[0] === '') parts.shift();
+  if (parts[parts.length - 1] === '') parts.pop();
+  return parts.map((cell) => cell.replace(/\\\|/g, '|').trim());
+}
+
+function severityOf(cell: string): ReqeSeverity {
+  switch (cell.trim().toLowerCase()) {
+    case 'blocker': case 'critical': return 'BLOCKER';
+    case 'high': case 'major': return 'HIGH';
+    case 'medium': case 'med': return 'MEDIUM';
+    case 'low': case 'minor': return 'LOW';
+    default: return 'unknown';
+  }
+}
+
+/** Read only the single Findings section; malformed attempts carry an explicit reason. */
+export function classifyReqeFindings(text: string): ReqeFindingsClass {
+  const lines = maskMarkdown(text).split(/\r?\n/);
+  const sections = lines.flatMap((line, index) => {
+    const match = findingsHeading.exec(line);
+    return match ? [{ index, declared: match[1] === undefined ? null : Number(match[1]) }] : [];
+  });
+  if (sections.length === 0) return { kind: 'absent' };
+  if (sections.length !== 1) return { kind: 'rejected', reason: `ambiguous: ${sections.length} Findings headings` };
+  const section = sections[0]!;
+  let end = section.index + 1;
+  while (end < lines.length && !heading.test(lines[end]!)) end++;
+  let start = section.index + 1;
+  while (start < end && !/(?<!\\)\|/.test(lines[start]!)) start++;
+  if (start === end) {
+    if (section.declared === 0) {
+      return { kind: 'accepted', counts: emptyCounts(), rows: 0, declared: 0, blocking: [] };
+    }
+    return { kind: 'rejected', reason: `no canonical table; ${expectedTable}` };
+  }
+  const headers = cells(lines[start]!).map((cell) => cell.toLowerCase());
+  const severityIndex = headers.indexOf('severity');
+  if (severityIndex === -1) return { kind: 'rejected', reason: `no severity column; ${expectedTable}; parsed columns: ${headers.join(', ')}` };
+  if (headers.lastIndexOf('severity') !== severityIndex) return { kind: 'rejected', reason: 'ambiguous: multiple severity columns' };
+  const titleIndex = headers.findIndex((cell) => cell === 'finding' || cell === 'title');
+  const whereIndex = headers.findIndex((cell) => cell === 'location' || cell === 'where');
+  if (titleIndex === -1 || whereIndex === -1) return { kind: 'rejected', reason: `missing finding/title or location/where column; ${expectedTable}` };
+  const delimiter = start + 1 < end ? cells(lines[start + 1]!) : [];
+  if (delimiter.length !== headers.length || !delimiter.every((cell) => /^:?-{3,}:?$/.test(cell))) {
+    return { kind: 'rejected', reason: `row ${start + 2}: invalid delimiter; expected ${headers.length} delimiter cells for columns: ${headers.join(', ')}` };
+  }
+  const counts = { ...emptyCounts() };
+  const blocking: ReqeBlockingRow[] = [];
+  let rows = 0;
+  let finished = false;
+  for (let index = start + 2; index < end; index++) {
+    const line = lines[index]!;
+    if (!/(?<!\\)\|/.test(line)) { finished = true; continue; }
+    if (finished) return { kind: 'rejected', reason: `row ${index + 1}: ambiguous table continuation` };
+    const row = cells(line);
+    if (row.length !== headers.length) {
+      return { kind: 'rejected', reason: `row ${index + 1}: ${row.length} cells for ${headers.length} columns (unescaped pipe?); parsed columns: ${headers.join(', ')}` };
+    }
+    if (row.every((cell) => /^:?-{3,}:?$/.test(cell))) return { kind: 'rejected', reason: `row ${index + 1}: ambiguous additional table delimiter` };
+    const severity = severityOf(row[severityIndex]!);
+    const key = severity.toLowerCase() as keyof ReqeSeverityCounts;
+    counts[key]++;
+    rows++;
+    if (severity === 'BLOCKER' || severity === 'HIGH') {
+      const where = row[whereIndex]!;
+      blocking.push({ severity, title: row[titleIndex]!, where: where === '—' || where === '' ? null : where });
+    }
+  }
+  return { kind: 'accepted', counts, rows, declared: section.declared, blocking };
+}
+
+/** Independent pass: no classification or new-findings state participates in prior status. */
+export function parsePriorFindings(text: string): ReqePriorVerdict {
+  const lines = maskMarkdown(text).split(/\r?\n/);
+  const sections = lines.flatMap((line, index) => /^#{1,6}[ \t]*Prior findings[ \t]*$/.test(line) ? [index] : []);
+  if (sections.length !== 1) return { kind: 'unassessed' };
+  let total = 0;
+  const open: number[] = [];
+  for (let index = sections[0]! + 1; index < lines.length; index++) {
+    const line = lines[index]!;
+    if (heading.test(line)) break;
+    const match = /^[ \t]*(\d+):[ \t]+(closed|open)[ \t]+—[ \t]+\S.*$/.exec(line);
+    if (!match) continue;
+    total++;
+    if (match[2] === 'open') open.push(Number(match[1]));
+  }
+  if (total === 0) return { kind: 'unassessed' };
+  return open.length > 0 ? { kind: 'open', open, total } : { kind: 'closed', closed: total, total };
+}
+
+/** The only blocking rule; prior status is reported independently. */
+export function buildReqeVerdict(text: string): ReqeVerdict {
+  const findings = classifyReqeFindings(text);
+  const prior = parsePriorFindings(text);
+  const accepted = findings.kind === 'accepted';
+  const counts = accepted ? findings.counts : emptyCounts();
+  return {
+    new: accepted ? (counts.blocker >= 1 || counts.high >= 1 ? 'blocked' : 'ready') : 'unassessed',
+    prior, findings, counts,
+    rows: accepted ? findings.rows : 0,
+    blocking: accepted ? findings.blocking : [],
+    source: 'reviewer-declared',
+  };
+}