@dzhechkov/harness-core 0.6.0 → 0.7.0

package/src/agentdb-index.ts

@@ -173,7 +173,14 @@ export async function indexPatternsToAgentdb(
  * The RECALL/search default task_types. Deliberately EXCLUDES `dz-backlog`: `dz recall` (and
  * feature-adr Step-0) must never surface raw backlog ideas as if they were earned lessons (ADR-005).
  */
-const DZ_TASK_TYPES = ['dz-teach', 'dz-learning'] as const;
+/**
+ * The PATTERN scope — the task types a learned-pattern count covers. Exported so `dz vector status`
+ * can report a mirrored count comparable to its lexical one; the lifecycle superset below is for
+ * ownership, and reporting IT beside a pattern count once led a reader to conclude half the index
+ * was orphaned when none of it was.
+ */
+export const DZ_PATTERN_TASK_TYPES = ['dz-teach', 'dz-learning'] as const;
+const DZ_TASK_TYPES = DZ_PATTERN_TASK_TYPES;
 
 /**
  * The dz-owned task_types for LIFECYCLE scans (id enumeration + reindex ownership) — a SUPERSET of

package/src/amendment-trace.ts

@@ -0,0 +1,348 @@
+/**
+ * Amendment traceability — the deterministic half of the Step-8 amendment gate (ADR-001).
+ *
+ * The gate used to be a paragraph of prompt text asking the QE agent to confirm that every `AM-N`
+ * row names a real test. That is layer 4 on the cost-of-detection ladder, and the recalled lesson at
+ * reward 1.00 says what happens next: a safety property that lives only in a prompt disappears with
+ * the next prompt. `features/qe-scoped-review/08_qe_report.md` recorded the outcome — five ids named,
+ * none existing, and the plan writing `## Amendments: None`.
+ *
+ * Everything here is PURE: text in, verdicts out, file access through an injected reader (NFR-1).
+ * The CLI owns I/O and the exit code; this module owns the grammar and the rules.
+ *
+ * NOT PROVEN HERE: that a resolved test is non-vacuous. `dz discrimination-check` owns "would this
+ * test still pass with the protection deleted" (non-goal NG-1, acid case A8). A checker that implied
+ * it proved vacuity would be the same lie in a new place.
+ */
+
+/** One `AM-N` row as it appears in a `## Amendments` section. */
+export interface AmendmentRow {
+  readonly id: string;
+  readonly testIds: readonly string[];
+  readonly file: string | null;
+  readonly raw: string;
+}
+
+export type AmendmentVerdict =
+  | 'resolved'
+  | 'placeholder'
+  | 'unnamed'
+  | 'no-file-named'
+  | 'file-missing'
+  | 'name-absent-in-file';
+
+export interface AmendmentResolution {
+  readonly id: string;
+  readonly testId: string | null;
+  readonly file: string | null;
+  readonly verdict: AmendmentVerdict;
+  readonly detail: string;
+}
+
+export type AmendmentOutcome = 'pass' | 'fail' | 'skip' | 'not-established';
+
+export interface AmendmentDecision {
+  readonly outcome: AmendmentOutcome;
+  /** Derived FROM the outcome — one mapping, never two (AM-3, acid case A3/A7). */
+  readonly exit: 0 | 1 | 3;
+  readonly reasons: readonly string[];
+  readonly counts: Readonly<Record<AmendmentVerdict, number>>;
+}
+
+/**
+ * Template placeholders that reach shipped reports. A stub read as an ordinary unresolvable id lets
+ * the author believe they merely mistyped a name, so it earns its own verdict (acid case A1).
+ */
+const PLACEHOLDER_IDS = new Set(['test_name', 'test-name', '<test>', '<test_name>', 'tbd', 'todo', 'name']);
+
+/**
+ * Below this many normalised characters an id is too short to match anything meaningfully: the
+ * substring rule ADR-002 accepts would fire on unrelated prose. Guards the degenerate case the ADR
+ * names as its known false-positive risk.
+ */
+export const MIN_MATCHABLE_ID_LENGTH = 8;
+
+/** Case- and separator-folded form. Authors write ids in prose (`a_b_c`); test titles are sentences. */
+/**
+ * Every `it()` / `test()` / `describe()` title in a test file. Empty when none parse.
+ *
+ * Comments are stripped FIRST. A commented-out `it('deny admin writes')` is not a test, and counting
+ * it would leave open the very forgery the title basis exists to close — the cross-family reviewer's
+ * two-comment-line attack in a slightly better costume. Table forms (`test.each([…])('…')`) carry an
+ * argument list between the modifier and the title, so the pattern allows one.
+ */
+export function extractTestTitles(body: string): string[] {
+  const code = body.replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/(^|[^:])\/\/[^\n]*/g, '$1');
+  const out: string[] = [];
+  const re = /\b(?:it|test|describe)(?:\.\w+)*(?:\s*\([^()]{0,200}\))?\s*(?:`[^`]*`)?\s*\(\s*(['"`])([\s\S]{1,300}?)\1/g;
+  for (let m = re.exec(code); m !== null; m = re.exec(code)) if (m[2]) out.push(m[2]);
+  return out;
+}
+
+export function normalizeTestId(s: string): string {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, '');
+}
+
+/**
+ * Row starts, in BOTH shapes the corpus actually contains: a bullet (`- **AM-1 (…):**`) and a table
+ * cell (`| **AM-40** |`). A format LEGEND — the literal `AM-N` with an `N` that is not a digit, as in
+ * `features/ha-consilium/03.5_ideation_report.md` — is deliberately NOT a row: counting a legend as
+ * an amendment would open this feature by falsely accusing a feature that did nothing wrong.
+ */
+const ROW_START = /^(?:[-*]\s+\*{0,2}AM-(\d+)|\|\s*\*{0,2}AM-(\d+))/gm;
+
+/** The `## Amendments` section body, or null when the document has none (acid case A5). */
+export function amendmentSection(md: string): string | null {
+  const m = /^ {0,3}#{2,4}\s+Amendments\b[^\n]*\n/m.exec(md);
+  if (!m) return null;
+  const start = m.index + m[0].length;
+  const rest = md.slice(start);
+  const next = /^ {0,3}#{2,4}\s+\S/m.exec(rest);
+  return next ? rest.slice(0, next.index) : rest;
+}
+
+/** `## Amendments` present but recording nothing to check — distinct from the section being absent. */
+export function planSaysNoAmendments(planMd: string): boolean {
+  const sec = amendmentSection(planMd);
+  if (sec === null) return false;
+  return /^\s*(none|n\/a|нет)\b/i.test(sec.trim());
+}
+
+export function parseAmendments(md: string): AmendmentRow[] {
+  const section = amendmentSection(md);
+  if (section === null) return [];
+  const starts: { index: number; num: string }[] = [];
+  ROW_START.lastIndex = 0;
+  for (let m = ROW_START.exec(section); m !== null; m = ROW_START.exec(section)) {
+    starts.push({ index: m.index, num: (m[1] ?? m[2]) as string });
+  }
+  const rows: AmendmentRow[] = [];
+  for (let i = 0; i < starts.length; i++) {
+    const s = starts[i] as { index: number; num: string };
+    const end = i + 1 < starts.length ? (starts[i + 1] as { index: number }).index : section.length;
+    const raw = section.slice(s.index, end);
+    rows.push({ id: `AM-${s.num}`, testIds: extractTestIds(raw), file: extractFile(raw), raw });
+  }
+  return rows;
+}
+
+/** `→ test \`a\`` and the two-id shape `→ tests \`a\` and \`b\`` — both are in the corpus. */
+function extractTestIds(raw: string): string[] {
+  const out: string[] = [];
+  const re = /→\s*tests?\s+`([^`]+)`(?:\s*(?:and|и)\s*`([^`]+)`)?/g;
+  for (let m = re.exec(raw); m !== null; m = re.exec(raw)) {
+    if (m[1]) out.push(m[1].trim());
+    if (m[2]) out.push(m[2].trim());
+  }
+  return out;
+}
+
+/**
+ * The `in \`<path>\`` half, which in real reports frequently opens the line AFTER the id. A pattern
+ * that cannot cross a newline finds almost nothing here — measured while writing this: three
+ * successive shell-written extractors returned 108, 111 and 13 rows over the identical corpus.
+ */
+function extractFile(raw: string): string | null {
+  const m = /→\s*tests?\s+`[^`]+`(?:\s*(?:and|и)\s*`[^`]+`)?[\s\S]{0,40}?\bin\s+`([^`]+)`/.exec(raw);
+  return m && m[1] ? m[1].trim() : null;
+}
+
+export function resolveAmendments(
+  rows: readonly AmendmentRow[],
+  opts: { readFile: (p: string) => string | null },
+): AmendmentResolution[] {
+  const out: AmendmentResolution[] = [];
+  for (const row of rows) {
+    if (row.testIds.length === 0) {
+      out.push({
+        id: row.id,
+        testId: null,
+        file: row.file,
+        verdict: 'unnamed',
+        detail: 'the row carries no `→ test` token — an amendment with no pointer is not a passing amendment',
+      });
+      continue;
+    }
+    for (const testId of row.testIds) {
+      out.push(resolveOne(row, testId, opts.readFile));
+    }
+  }
+  return out;
+}
+
+function resolveOne(
+  row: AmendmentRow,
+  testId: string,
+  readFile: (p: string) => string | null,
+): AmendmentResolution {
+  const base = { id: row.id, testId, file: row.file };
+  if (PLACEHOLDER_IDS.has(testId.trim().toLowerCase())) {
+    return { ...base, verdict: 'placeholder', detail: `\`${testId}\` is a template placeholder, not a test name` };
+  }
+  if (row.file === null) {
+    return { ...base, verdict: 'no-file-named', detail: 'the row names a test id but no file to find it in' };
+  }
+  const body = readFile(row.file);
+  if (body === null) {
+    return { ...base, verdict: 'file-missing', detail: `\`${row.file}\` does not exist or cannot be read` };
+  }
+  const needle = normalizeTestId(testId);
+  if (needle.length < MIN_MATCHABLE_ID_LENGTH) {
+    return {
+      ...base,
+      verdict: 'name-absent-in-file',
+      detail: `\`${testId}\` normalises to ${needle.length} characters — below the ${MIN_MATCHABLE_ID_LENGTH}-character floor, so a match would prove nothing`,
+    };
+  }
+  // An existing FILE never stands in for an existing TEST (ADR-002) — and neither does an existing
+  // COMMENT. Matching the whole file body is forgeable with two comment lines whose letters happen to
+  // spell the id, so the basis is the file's TEST TITLES. Falling back to the body when none parse is
+  // stated in the detail rather than done quietly: a silent fallback restores the hole it closes.
+  const titles = extractTestTitles(body);
+  const basis = titles.length > 0 ? titles.map(normalizeTestId).join('\n') : normalizeTestId(body);
+  const basisNote = titles.length > 0 ? `${titles.length} test title(s)` : 'the whole file body — NO test titles parsed, so this match is weaker';
+  if (!basis.includes(needle)) {
+    return {
+      ...base,
+      verdict: 'name-absent-in-file',
+      detail: `\`${row.file}\` exists but no test in it is named \`${testId}\` (searched ${basisNote})`,
+    };
+  }
+  return { ...base, verdict: 'resolved', detail: `found in \`${row.file}\` (searched ${basisNote})` };
+}
+
+const ZERO_COUNTS: Record<AmendmentVerdict, number> = {
+  resolved: 0,
+  placeholder: 0,
+  unnamed: 0,
+  'no-file-named': 0,
+  'file-missing': 0,
+  'name-absent-in-file': 0,
+};
+
+export function decideAmendmentOutcome(input: {
+  sectionPresent: boolean;
+  rows: readonly AmendmentRow[];
+  resolutions: readonly AmendmentResolution[];
+  planSaysNone: boolean;
+  readError?: string | null;
+  /** Ideation amendments the plan fails to carry — absent, or reworded under the same id. */
+  missingFromPlan?: readonly { id: string; kind: 'dropped' | 'subject-changed' }[];
+}): AmendmentDecision {
+  const counts: Record<AmendmentVerdict, number> = { ...ZERO_COUNTS };
+  for (const r of input.resolutions) counts[r.verdict]++;
+  const reasons: string[] = [];
+
+  // Inputs we could not read are never a verdict about the feature (acid case A7).
+  if (input.readError) {
+    return { outcome: 'not-established', exit: 3, reasons: [`inputs unreadable: ${input.readError}`], counts };
+  }
+  // Absence is a skip with a stated reason, never a pass and never a silent zero (acid case A5).
+  if (!input.sectionPresent) {
+    return {
+      outcome: 'skip',
+      exit: 0,
+      reasons: ['no `## Amendments` section — nothing to check (this is an absence, not a pass)'],
+      counts,
+    };
+  }
+  // The whole class this feature removes: a check that silently checked nothing (AM-1, acid case A7).
+  if (input.rows.length === 0) {
+    return {
+      outcome: 'not-established',
+      exit: 3,
+      reasons: [
+        'the `## Amendments` section is present but ZERO rows parsed — the grammar matched nothing, which is not the same as nothing being wrong',
+      ],
+      counts,
+    };
+  }
+  // Ideation carries rows while the plan records "None" — this is HIGH-2 itself (acid case A6).
+  // Discovered while closing HIGH-2: the pointers belong in the PLAN. Step 6's own instruction is
+  // "carry AM-N into 06_implementation_plan.md verbatim", and the ideation report is a historical
+  // artifact — editing its rows to match tests that were named later would be rewriting the record
+  // rather than closing the trail. So the plan's rows are authoritative when present, and the rule
+  // that keeps that honest is coverage: an ideation amendment the plan never mentions is a DROPPED
+  // amendment, which is the renegotiating-away failure in a quieter form.
+  for (const gap of input.missingFromPlan ?? []) {
+    reasons.push(
+      gap.kind === 'dropped'
+        ? `${gap.id} is an amendment in 03.5_ideation_report.md that 06_implementation_plan.md never carries — an amendment dropped in planning is one nobody can audit`
+        : `${gap.id} appears in both documents but the plan describes a DIFFERENT change — "carry verbatim" means the subject survives; only the test pointer may be renamed`,
+    );
+  }
+  if (input.planSaysNone) {
+    reasons.push(
+      `the ideation report carries ${input.rows.length} amendment row(s) while 06_implementation_plan.md records \`## Amendments: None\` — the amendments were renegotiated away, and an amendment nobody can resolve is one nobody can audit`,
+    );
+  }
+  for (const r of input.resolutions) {
+    if (r.verdict !== 'resolved') reasons.push(`${r.id} → ${r.verdict}: ${r.detail}`);
+  }
+  return { outcome: reasons.length > 0 ? 'fail' : 'pass', exit: reasons.length > 0 ? 1 : 0, reasons, counts };
+}
+
+/** The one line every caller reads last, in the K2 gate's own shape so the two read alike. */
+export function amendmentVerdictLine(d: AmendmentDecision): string {
+  const label = d.outcome === 'not-established' ? 'NOT-ESTABLISHED' : d.outcome.toUpperCase();
+  const head = `amendment traceability: ${label}`;
+  const tail =
+    d.outcome === 'pass'
+      ? `${d.counts.resolved} row(s) resolved`
+      : (d.reasons[0] ?? 'no reason recorded');
+  return `${head} — ${tail}`;
+}
+
+/** Printed on every run: this checker does NOT prove a resolved test discriminates (NG-1, A8). */
+export const AMENDMENT_VACUITY_NOTE =
+  'note: this checks that each amendment RESOLVES to a real test, not that the test is non-vacuous — `dz discrimination-check` owns vacuity.';
+
+
+/**
+ * The amendment's own text with the `→ test …` pointer clause and markdown furniture removed — what
+ * "carry AM-N into the plan verbatim" is actually about. The POINTER may legitimately change (tests
+ * are named later than ideation guesses); the SUBJECT may not.
+ */
+export function amendmentSubject(raw: string): string {
+  const withoutPointer = raw.split(/→\s*tests?\s/)[0] ?? '';
+  // Strip ONLY the row's furniture: bullet/table marks, the bold id, an optional `(source)` tag and
+  // a colon. An earlier version consumed up to 80 characters after the id, which ate the SUBJECT
+  // itself whenever a row carried no `(source):` tag — the checker then compared two truncations
+  // and called honest rows a mismatch.
+  const stripped = withoutPointer.replace(/^[\s|*\-]*\**AM-\d+\**\s*(?:\([^)]{0,80}\))?\s*:?\s*/, '');
+  return normalizeTestId(stripped);
+}
+
+export interface PlanCoverageGap {
+  readonly id: string;
+  readonly kind: 'dropped' | 'subject-changed';
+}
+
+/**
+ * Ideation amendments the plan fails to carry: either absent outright, or present under the same id
+ * with a DIFFERENT subject. Cross-family review (Codex gpt-5.6-sol, 2026-08-21) found the second
+ * case: comparing ids alone let a plan swap "deny unauthenticated deletes" for "render footer" under
+ * the same `AM-1` and still pass.
+ */
+export function amendmentsMissingFromPlan(
+  ideationRows: readonly AmendmentRow[],
+  planRows: readonly AmendmentRow[],
+): PlanCoverageGap[] {
+  const byId = new Map(planRows.map((r) => [r.id, r]));
+  const gaps: PlanCoverageGap[] = [];
+  for (const row of ideationRows) {
+    const planRow = byId.get(row.id);
+    if (planRow === undefined) {
+      gaps.push({ id: row.id, kind: 'dropped' });
+      continue;
+    }
+    const want = amendmentSubject(row.raw);
+    const got = amendmentSubject(planRow.raw);
+    // Containment either way: a plan may append a note ("closes HIGH-2"), and ideation may be the
+    // longer prose. What it may not do is describe a different change.
+    if (want.length >= MIN_MATCHABLE_ID_LENGTH && !got.includes(want) && !want.includes(got)) {
+      gaps.push({ id: row.id, kind: 'subject-changed' });
+    }
+  }
+  return gaps;
+}

package/src/guard.ts

@@ -73,6 +73,28 @@ export interface GuardFacts {
   readonly skillPacks?: readonly { readonly name: string; readonly nonRegistrable: readonly string[] }[];
   /** for readme-first: per publishable package, is a version bump staged without a README change? */
   readonly readmeFirst?: readonly { readonly name: string; readonly versionBumped: boolean; readonly readmeChanged: boolean }[];
+  /**
+   * for review-round: per publishable package, does this change bump a version AND touch SOURCE, and
+   * did it bring a GRADED QE report with it? `undefined` (the whole fact absent) means the tree could
+   * not be read — the rule then reports nothing, which is different from reporting "no review".
+   */
+  readonly reviewRound?: {
+    readonly packages: readonly { readonly name: string; readonly versionBumped: boolean; readonly sourceChanged: boolean }[];
+    /** grades parsed out of `features/*∕08_qe_report.md` files in this change set, in file order. */
+    readonly grades: readonly { readonly report: string; readonly grade: string }[];
+    /**
+     * Optional floor from `.dz/guard.json` → `reviewRound.minGrade`. Carried in the FACT because a
+     * rule body is a pure function of facts and takes no config — and because the owner reserved the
+     * choice of threshold, so the DEFAULT must stay "a grade is present".
+     */
+    readonly minGrade?: string | undefined;
+    /**
+     * `false` when the gatherer TRIED and could not read the tree. The note below fires only on
+     * that, never on a caller that simply never gathered — otherwise every synthetic evaluation
+     * carries a warning about evidence nobody asked for.
+     */
+    readonly gathered?: boolean | undefined;
+  };
   /**
    * for agents-md-policy-sync: result of the pure policy drift detector, gathered by the CLI.
    * `applicable:false` is a repo whose canonical policy sources are unreadable; omission means the
@@ -246,6 +268,7 @@ export const DEFAULT_RULES: readonly GuardRule[] = [
   // Description ASSEMBLED from STUB_MARKERS so guard.ts itself stays clean under the scan it defines
   // (structural self-exemption — tested in no-stubs.test.ts).
   { id: 'no-stubs', severity: 'soft', ops: ['publish'], description: `an unfinished-stub marker (${STUB_MARKERS.join('/')} / "${STUB_PHRASES.join('", "')}") left in a CHANGED file — any unwaived match means the change ships incomplete; waive per line with "no-stubs: <reason>" or per path in .dz/guard.json stubWaivers (reason MANDATORY)` },
+  { id: 'review-round', severity: 'hard', ops: ['publish'], description: 'a package publishing CHANGED SOURCE must bring a GRADED features/*/08_qe_report.md in the same change. Scoped to source so a docs-only republish is never blocked; the floor is PRESENCE of a grade unless .dz/guard.json sets reviewRound.minGrade. It proves a graded report EXISTS for this change — NOT that the review was independent, competent, or taken against this exact revision' },
   { id: 'licence-hold', severity: 'hard', ops: ['publish'], description: 'a pack that declares a licence hold (package.json.licenseHold — ADR-001 hermes-claude-adaptation) must not become publishable until the hold is satisfied: LICENSE present without the PENDING grant placeholder, a Grant-Confirmation URL, non-empty THIRD_PARTY_NOTICES, and a clean SPDX license field' },
 ];
 
@@ -337,6 +360,50 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
     }
     return out;
   },
+  'review-round': (f, sev) => {
+    // The publish gate had eleven rules and not one asked whether anyone but the author had read the
+    // code. MEASURED cost (health-advisor slice H): five rounds graded F, thirteen packages published
+    // on the author's own verification, and round six found six defects in ALREADY-PUBLISHED code.
+    //
+    // Scoped to CHANGED SOURCE on purpose (ADR-001): a HARD rule that also fired on a docs-only
+    // republish would be a rule someone switches off. `undefined` facts mean the tree could not be
+    // read — silence, not an accusation.
+    const rr = f.reviewRound;
+    if (rr === undefined) return [];
+    const min = typeof rr.minGrade === 'string' ? rr.minGrade.trim().toUpperCase() : undefined;
+    // The grade must BE a letter, not merely START with one: keyed on the first character alone,
+    // "approved" reads as an A and "broken" as a B (found by cross-family review). The fact gatherer
+    // already extracts a bounded letter, so this is defence in depth — and a pure function has no
+    // business being looser than its caller.
+    const rank = (g: string): number => {
+      const t = String(g ?? '').trim().toUpperCase();
+      return t.length === 1 ? 'ABCDF'.indexOf(t) : -1;
+    };
+    const graded = rr.grades.filter((g) => rank(g.grade) >= 0);
+    const out: Violation[] = [];
+    for (const p of rr.packages) {
+      if (!(p.versionBumped === true && p.sourceChanged === true)) continue;
+      if (graded.length === 0) {
+        out.push({
+          rule: 'review-round',
+          severity: sev,
+          detail: `${p.name}: source changed and the version is bumped, but this change brings no GRADED features/*/08_qe_report.md — a publish gate that cannot tell "reviewed" from "not reviewed" treats them alike. (This proves a graded report EXISTS in this change; it does NOT prove the review was independent, was competent, covered THIS package, or was taken against this revision.)`,
+        });
+        continue;
+      }
+      if (min !== undefined && rank(min) >= 0) {
+        const best = graded.reduce((a, b) => (rank(a.grade) <= rank(b.grade) ? a : b));
+        if (rank(best.grade) > rank(min)) {
+          out.push({
+            rule: 'review-round',
+            severity: sev,
+            detail: `${p.name}: the best review grade in this change is ${best.grade.trim()} (${best.report}), below the configured floor ${min} — .dz/guard.json reviewRound.minGrade`,
+          });
+        }
+      }
+    }
+    return out;
+  },
   'agents-md-policy-sync': (f, _sev) => {
     const fact = f.policyDrift;
     if (!fact || fact.applicable !== true || !Array.isArray(fact.drifted)) return [];
@@ -557,6 +624,13 @@ export function evaluateGuard(facts: GuardFacts, rules: readonly GuardRule[] = D
       notes.push(`no-stubs: ${skipped} changed scannable file(s) not scanned (deleted/oversize/unreadable/beyond the file cap) — the stub scan is fail-open, so this is a coverage gap on the record, not a violation`);
     }
   }
+  if (checked.includes('review-round') && facts.reviewRound?.gathered === false) {
+    // A HARD gate that passes SILENTLY when it could not gather its evidence is a gate you cannot
+    // tell from one that checked and approved (raised by cross-family review). It still does not
+    // BLOCK — absence of facts is ignorance, not an accusation, and blocking every non-git checkout
+    // would make the rule unusable — but the ignorance goes on the record.
+    notes.push('review-round: the working-tree change could not be read, so NO review evidence was gathered — this run neither confirms nor denies that the code was reviewed');
+  }
   if (checked.includes('agents-md-policy-sync')) {
     // A repo that never opted in (no `dz:policies` fence in AGENTS.md) is OUT OF SCOPE, not
     // inconclusive — noting it on every run would put a permanent line in a channel that exists to

package/src/index.ts

@@ -78,7 +78,7 @@ export type { SyncUpstreamReport, UpstreamCheckResult, SourcesManifest, SourcePa
 export { sweepSkillDrift, syncCanonicalSkill } from './skill-drift.js';
 export type { SweepResult, DriftedSkill, SyncResult, SyncCanonicalOptions } from './skill-drift.js';
 export { benchmarkSkill, benchmarkSkills, compareSkills } from './benchmark.js';
-export { buildRegistry, searchRegistry, filterByCategory, skillPackBaseDirs, discoverSkillPackDirs } from './registry.js';
+export { buildRegistry, searchRegistry, filterByCategory, skillPackBaseDirs, discoverSkillPackDirs, discoverVerifiablePackDirs } from './registry.js';
 // Package skill-layout resolution (feature dz-install-npx-init) — the ONE seam that knows where an
 // npm package keeps its skills (flat / templates/.claude/skills / skills). `cmdInstall` calls it;
 // `dz init`/`dz registry` are the filed follow-up consumers.
@@ -240,6 +240,32 @@ export {
 export type { CheckpointStage, CheckpointEntry, ResumeMode, ResumeDecision, ParsedCheckpointRead, TrainingPairFamily, TrainingPair, TrainingPairEvaluation, TrainingPairProvenance, TrainingPairTruncation,
   CheckpointWriteVerdict,
 } from './feature-adr-checkpoints.js';
+
+// amendment-traceability (ADR-001/002/003): the deterministic half of the Step-8 amendment gate.
+export {
+  MIN_MATCHABLE_ID_LENGTH,
+  AMENDMENT_VACUITY_NOTE,
+  normalizeTestId,
+  amendmentSection,
+  planSaysNoAmendments,
+  parseAmendments,
+  resolveAmendments,
+  decideAmendmentOutcome,
+  amendmentVerdictLine,
+  amendmentsMissingFromPlan,
+  amendmentSubject,
+  extractTestTitles,
+} from './amendment-trace.js';
+export {
+  RECORD_MAX_LINE_CHARS,
+  decideRecordWrite,
+  decideReadBack,
+  recordVerdictLine,
+} from './run-records.js';
+export { decidePublishSigning, decidePostSigningVerification, decideSignableSet, publishSigningLine, signableSetLine } from './publish-signing.js';
+export type { PublishSigningVerdict, PublishSigningDecision, SignableSetDecision } from './publish-signing.js';
+export type { RecordKind, RecordVerdict, RecordDecision } from './run-records.js';
+export type { AmendmentRow, AmendmentVerdict, AmendmentResolution, AmendmentOutcome, AmendmentDecision, PlanCoverageGap } from './amendment-trace.js';
 export {
   DOMAIN_LIFT_EXACT,
   DOMAIN_LIFT_RELATED,

package/src/patterns.ts

@@ -287,7 +287,10 @@ export function computePatternBoost(
       matched = true;
     } else {
       // medium: a meaningful word from the pattern appears in the skill haystack
-      for (const word of text.split(/[^a-z0-9]+/)) {
+      // `\p{L}\p{N}`, not `a-z0-9`: the ASCII-only class made every non-Latin word invisible to
+      // the boost, so a Cyrillic pattern could never match a skill haystack. The `>= 5` rule below
+      // is this site's OWN threshold and is deliberately unchanged — only the alphabet moved.
+      for (const word of text.split(/[^\p{L}\p{N}]+/u)) {
         if (word.length >= 5 && haystack.includes(word)) {
           matched = true;
           break;