@dzhechkov/harness-core 0.8.39 → 0.8.41

package/src/guard.ts

@@ -24,7 +24,18 @@ import {
 import { findReleaseLine } from './release-line.js';
 
 export type GuardSeverity = 'hard' | 'soft';
-export type GuardOp = 'publish' | 'teach' | 'consolidate' | 'reindex';
+// The 'code' operation checks facts already established when code changes, such as shared skill-copy
+// drift or a stale signature on a pack whose files changed. Publication readiness (README, release
+// lines, versions) belongs to publish. On 2026-09-21, story-page's stale signature surfaced six hours
+// after the edit in harness-cli's tests, demonstrating why edit-time facts need an edit-time gate.
+export const GUARD_OPS = [
+  'publish',
+  'teach',
+  'consolidate',
+  'reindex',
+  'code',
+] as const;
+export type GuardOp = typeof GUARD_OPS[number];
 export type GuardVerdict = 'pass' | 'warn' | 'block';
 
 /** A declarative rule. Built-in rules ship with a checker (below); config can only tune/disable them. */
@@ -154,6 +165,8 @@ export interface GuardFacts {
   };
   /** for no-skill-drift: the names that byte-drift between copies (from sweepSkillDrift). */
   readonly drift?: readonly string[];
+  /** for no-skill-drift: canonical-side defects as skill:path (from sweepSkillDrift). */
+  readonly canonicalDefects?: readonly string[];
   /**
    * for codex-wrapper-for-value-stage: workflow scripts to scan, as (path, text). Absent ⇒ the
    * rule reports nothing: a guard with no evidence must stay silent rather than invent a verdict.
@@ -161,10 +174,15 @@ export interface GuardFacts {
   readonly workflowScripts?: readonly { readonly path: string; readonly text: string }[];
   /** for no-secrets: labelled blobs to scan (lesson text, staged files). */
   readonly secretTargets?: readonly { readonly label: string; readonly text: string }[];
+  /** for no-secrets: findings already scanned from the streaming publish inventory. */
+  readonly secretFindings?: readonly { readonly label: string; readonly name: string }[];
   /** for no-secrets: exact path waivers; entries without a non-empty reason are ignored and noted. */
   readonly secretWaivers?: readonly SecretWaiver[];
   /** Publish secret-scan coverage gaps; skips are informational and never verdict inputs. */
-  readonly secretScan?: { readonly skipped: number };
+  /** backlog a530eaca: `skippedPaths` names what the fail-open scan never read (repo-relative, with the
+   * reason) so the coverage gap is auditable — a bare count told the owner nothing to check. Optional:
+   * an older CLI that sends only the count still renders the count-only note. */
+  readonly secretScan?: { readonly skipped: number; readonly skippedPaths?: readonly string[]; readonly scanned?: number; readonly inventory?: string };
   /** for readme-consistency: labelled (a,b) count pairs that must be equal. */
   readonly counts?: readonly { readonly label: string; readonly a: number; readonly b: number }[];
   /** for store-bloat-cap: current learned-store size vs its cap. */
@@ -199,7 +217,7 @@ export interface GuardFacts {
   /**
    * 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".
+   * not be read — the rule is NOT-ESTABLISHED, which is different from reporting "no review".
    */
   readonly reviewRound?: {
     readonly packages: readonly { readonly name: string; readonly versionBumped: boolean; readonly sourceChanged: boolean }[];
@@ -477,12 +495,12 @@ export const DEFAULT_RULES: readonly GuardRule[] = [
   { id: 'no-workspace-star', severity: 'hard', ops: ['publish'], description: 'a published package.json must carry no workspace:* dep (npm ships it verbatim → the install breaks)' },
   { id: 'plugin-manifest-audit', severity: 'hard', ops: ['publish'], description: 'every .claude-plugin/plugin.json parses and declares a non-empty name, description and a STRICT N.N.N version' },
   { id: 'sibling-dep-protocol', severity: 'hard', ops: ['publish'], description: 'a dependencies/devDependencies entry on a sibling @dzhechkov package must use the workspace: protocol on disk (peer/optional deps are deliberately exempt — a range is their point)' },
-  { id: 'no-skill-drift', severity: 'hard', ops: ['publish', 'consolidate'], description: 'no unexpected byte-drift between shared skill copies' },
+  { id: 'no-skill-drift', severity: 'hard', ops: ['publish', 'consolidate', 'code'], description: 'no unexpected byte-drift between shared skill copies' },
   { id: 'backlog-covers-features', severity: 'soft', ops: ['publish', 'consolidate'], description: 'каталог фичи, заведённый после базовой даты, назван записью бэклога — либо несёт именованную оговорку с причиной' },
   { id: 'no-secrets', severity: 'hard', ops: ['teach', 'publish'], description: 'no private key or API token in lesson text or a published file' },
   { id: 'readme-consistency', severity: 'soft', ops: ['publish'], description: 'README counts agree (CJM header vs All Commands, etc.)' },
   { id: 'release-line-in-sync', severity: 'soft', ops: ['publish'], description: 'root and harness-cli README release lines agree with the harness-core and harness-cli package versions' },
-  { id: 'signature-fresh', severity: 'soft', ops: ['publish'], description: 'a pack whose files changed in this diff still verifies against its signed .dz-manifest.json — a stale signature is named before publish, not at the gate' },
+  { id: 'signature-fresh', severity: 'soft', ops: ['publish', 'code'], description: 'a pack whose files changed in this diff still verifies against its signed .dz-manifest.json — a stale signature is named before publish, not at the gate' },
   { id: 'skills-registrable', severity: 'soft', ops: ['publish'], description: 'every skill directory in a skill pack has a depth-1 SKILL.md (a buried or missing one ships un-registrable — the health-advisor 1.2.0 class)' },
   { id: 'readme-first', severity: 'soft', ops: ['publish'], description: 'a package with a staged version bump must update its own README.md in the same change (README-first)' },
   { id: 'routing-store-stale', severity: 'soft', ops: ['publish'], description: 'harvested routing telemetry has been applied to the auto-cost outcome store' },
@@ -527,6 +545,22 @@ export function scanSecrets(text: unknown): { readonly name: string }[] {
   return [...hits].map((name) => ({ name }));
 }
 
+export const SECRET_SCAN_OVERLAP_BYTES = 4096;
+
+export function scanSecretsChunked(chunks: Iterable<Buffer>, opts?: { overlapBytes?: number }): { name: string }[] {
+  const overlapBytes = opts?.overlapBytes ?? SECRET_SCAN_OVERLAP_BYTES;
+  const hits = new Set<string>();
+  let tail = Buffer.alloc(0);
+  for (const chunk of chunks) {
+    const window = Buffer.concat([tail, chunk]);
+    const text = window.toString('utf8');
+    for (const p of SECRET_PATTERNS) if (p.re.test(text)) hits.add(p.name);
+    if (hits.size === SECRET_PATTERNS.length) break;
+    tail = window.subarray(Math.max(0, window.length - overlapBytes));
+  }
+  return [...hits].map((name) => ({ name }));
+}
+
 function secretWaiverState(waivers: readonly SecretWaiver[] | undefined): { waived: ReadonlySet<string>; reasonless: number } {
   const waived = new Set<string>();
   let reasonless = 0;
@@ -613,7 +647,7 @@ function mentionsSlug(haystackLower: string, slug: string): boolean {
 }
 
 const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[]> = {
-  'rounds-closed': (f, sev) => (f.openRounds ?? [])
+  'rounds-closed': (f, sev) => f.openRounds!
     .filter((round) => Number.isFinite(round.ageMinutes) && round.ageMinutes > 120)
     .map((round) => ({
       rule: 'rounds-closed',
@@ -762,7 +796,11 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
   },
   'no-skill-drift': (f, sev) => {
     const drifted = Array.isArray(f.drift) ? f.drift.filter((d) => typeof d === 'string') : [];
-    return drifted.length === 0 ? [] : [{ rule: 'no-skill-drift', severity: sev, detail: `${drifted.length} skill(s) drift between copies: ${drifted.slice(0, 8).join(', ')}${drifted.length > 8 ? '…' : ''} — heal with dz sync-canonical` }];
+    const defects = Array.isArray(f.canonicalDefects) ? f.canonicalDefects.filter((d) => typeof d === 'string') : [];
+    const out: Violation[] = [];
+    if (drifted.length > 0) out.push({ rule: 'no-skill-drift', severity: sev, detail: `${drifted.length} skill(s) drift between copies: ${drifted.slice(0, 8).join(', ')}${drifted.length > 8 ? '…' : ''} — heal with dz sync-canonical` });
+    if (defects.length > 0) out.push({ rule: 'no-skill-drift', severity: sev, detail: `${defects.length} canonical defect(s): ${defects.join(', ')} — fix the canon, not the copies` });
+    return out;
   },
   'backlog-covers-features': (f, sev) => {
     const ev = f.featureBacklog;
@@ -787,11 +825,15 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
         out.push({ rule: 'no-secrets', severity: sev, detail: `${t.label}: looks like a ${hit.name} — do not teach/publish a credential` });
       }
     }
+    for (const hit of f.secretFindings ?? []) {
+      if (waived.has(hit.label)) continue;
+      out.push({ rule: 'no-secrets', severity: sev, detail: `${hit.label}: looks like a ${hit.name} — do not teach/publish a credential` });
+    }
     return out;
   },
   'readme-consistency': (f, sev) => {
     const out: Violation[] = [];
-    for (const c of f.counts ?? []) {
+    for (const c of f.counts!) {
       if (Number.isFinite(c.a) && Number.isFinite(c.b) && c.a !== c.b) {
         out.push({ rule: 'readme-consistency', severity: sev, detail: `${c.label}: ${c.a} ≠ ${c.b} (README counts disagree)` });
       }
@@ -804,7 +846,7 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
     // a heuristic (a pack counts only if it already has one registrable skill, and only
     // markdown-bearing dirs are considered intended), so it informs rather than blocks.
     const out: Violation[] = [];
-    for (const p of f.skillPacks ?? []) {
+    for (const p of f.skillPacks!) {
       if (!p || !Array.isArray(p.nonRegistrable) || p.nonRegistrable.length === 0) continue;
       out.push({
         rule: 'skills-registrable',
@@ -819,7 +861,7 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
     // whose own README.md is untouched in the same diff. SOFT: some republishes legitimately need no doc
     // change — the point is that skipping the README becomes a VISIBLE decision, not a silent lapse.
     const out: Violation[] = [];
-    for (const p of f.readmeFirst ?? []) {
+    for (const p of f.readmeFirst!) {
       if (p && p.versionBumped === true && p.readmeChanged !== true) {
         out.push({ rule: 'readme-first', severity: sev, detail: `${p.name}: version bumped but its README.md is untouched in this change — README-first: document the change (or consciously proceed; this warning is the record)` });
       }
@@ -886,7 +928,7 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
     //
     // 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.
+    // read — HAS_INPUT records NOT-ESTABLISHED, not an accusation.
     const rr = f.reviewRound;
     if (rr === undefined) return [];
     const min = typeof rr.minGrade === 'string' ? rr.minGrade.trim().toUpperCase() : undefined;
@@ -942,8 +984,8 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
    * so it belongs on layer 1 rather than in a rule nobody re-reads.
    */
   'codex-wrapper-for-value-stage': (f, sev) => {
-    const scripts = f.workflowScripts;
-    if (scripts === undefined || scripts.length === 0) return [];
+    const scripts = f.workflowScripts!; // Presence is established by HAS_INPUT.
+    if (scripts.length === 0) return [];
     const out: Violation[] = [];
     for (const s of scripts) {
       const text = String(s.text ?? '');
@@ -1055,6 +1097,14 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
   },
 };
 
+// Missing volume means NOT-ESTABLISHED. A throwing getter is INTENTIONALLY treated as present
+// so volume() can emit honest 'unknown' observations instead of failing in the precondition.
+// This preserves the older contract: test/guard.test.ts:725,
+// "a hostile volume getter becomes visible unknown evidence instead of a HARD checker error".
+const volumeInputPresent = (f: GuardFacts): boolean => {
+  try { return f.volume !== undefined; } catch { return true; }
+};
+
 /** Per-rule evidence predicates. No entry preserves the rule's existing checked behaviour exactly. */
 const HAS_INPUT: Partial<Record<string, (f: GuardFacts) => boolean>> = {
   'rounds-traced': (f) => {
@@ -1070,9 +1120,24 @@ const HAS_INPUT: Partial<Record<string, (f: GuardFacts) => boolean>> = {
   'sibling-dep-protocol': (f) => Array.isArray(f.siblingDeps) && f.siblingDeps.length > 0,
   // Дерево без плагин-манифестов правилу нечего сказать: «прошло» тут значило бы «не смотрели».
   'plugin-manifest-audit': (f) => Array.isArray(f.pluginManifests) && f.pluginManifests.length > 0,
-  'no-secrets': (f) => Array.isArray(f.secretTargets) && f.secretTargets.length > 0,
+  'no-secrets': (f) => (Array.isArray(f.secretTargets) && f.secretTargets.length > 0)
+    || Array.isArray(f.secretFindings) || typeof f.secretScan?.scanned === 'number',
   'release-line-in-sync': (f) => typeof f.releaseLines === 'object' && f.releaseLines !== null,
+  // 2026-09-21: на одном дереве с дрейфом publish=block, а code=pass без собранного факта drift.
+  'no-skill-drift': (f) => Array.isArray(f.drift),
+  'review-round': (f) => f.reviewRound !== undefined,
+  'no-workspace-star': (f) => Array.isArray(f.packages),
+  'codex-wrapper-for-value-stage': (f) => Array.isArray(f.workflowScripts),
   'signature-fresh': (f) => Array.isArray(f.signedPacks),
+  'rounds-closed': (f) => Array.isArray(f.openRounds),
+  'readme-consistency': (f) => Array.isArray(f.counts),
+  'skills-registrable': (f) => Array.isArray(f.skillPacks),
+  'readme-first': (f) => Array.isArray(f.readmeFirst),
+  'store-bloat-cap': (f) => f.store !== undefined,
+  'template-context-token-weight': volumeInputPresent,
+  'template-context-largest-file-share': volumeInputPresent,
+  'feature-artifact-diff-ratio': volumeInputPresent,
+  'feature-tier-artifact-set': volumeInputPresent,
 };
 
 /**
@@ -1138,7 +1203,7 @@ export function resolveRules(userRules?: readonly Partial<GuardRule>[]): GuardRu
       // than `lockfile-in-sync`'s tolerant parser, which is already SOFT-only. "I might be wrong"
       // plus "block the publish" is the wrong pair (ADR-004).
       if (isTemplateRule(u)) {
-        const ops = Array.isArray(u.ops) && u.ops.every((o) => ['publish', 'teach', 'consolidate', 'reindex'].includes(o as string)) && u.ops.length > 0 ? (u.ops as readonly GuardOp[]) : (['publish'] as const);
+        const ops = Array.isArray(u.ops) && u.ops.every((o) => (GUARD_OPS as readonly string[]).includes(o as string)) && u.ops.length > 0 ? (u.ops as readonly GuardOp[]) : (['publish'] as const);
         byId.set(u.id, {
           id: u.id,
           severity: 'soft',
@@ -1203,9 +1268,11 @@ export function evaluateGuard(facts: GuardFacts, rules: readonly GuardRule[] = D
     try {
       inputPresent = hasInput === undefined ? true : hasInput(facts);
     } catch (error) {
+      // Бросок в предикате улик и бросок в чекере обязаны нести общий маркер fail-closed:
+      // страж не смог решить и потому обвиняет, а не оправдывает; какой перехватчик был первым, потребителю неважно.
       violations.push({
         rule: r.id, severity: r.severity,
-        detail: `улики правила нечитаемы (${error instanceof Error ? error.message : String(error)}) — правило считается НАРУШЕННЫМ, а не пройденным`,
+        detail: `улики правила нечитаемы (${error instanceof Error ? error.message : String(error)}) — правило считается НАРУШЕННЫМ, а не пройденным (fail-closed)`,
       });
       checked.push(r.id);
       continue;
@@ -1291,10 +1358,30 @@ export function evaluateGuard(facts: GuardFacts, rules: readonly GuardRule[] = D
     }
     const skipped = facts.secretScan?.skipped;
     if (typeof skipped === 'number' && Number.isFinite(skipped) && skipped > 0) {
-      notes.push(`no-secrets: ${skipped} packed inventory item(s) not scanned (oversize/unreadable/binary) — the secret scan is fail-open, so this is a coverage gap on the record, not a violation`);
+      // MEASURED 2026-09-21: the count alone hid that harness-cli's own src/cli.ts and dist/cli.js
+      // (1.3 MiB each, both packed) are among the never-scanned items — name them, capped.
+      // Codex review (B): the legacy sentence stays byte-identical for consumers that match it whole;
+      // the names are APPENDED after it. "…and N more" counts from the FACT's `skipped`, not from the
+      // list length, so a partial list never understates the gap.
+      const paths = facts.secretScan?.skippedPaths ?? [];
+      const shown = paths.slice(0, 6);
+      const rest = Math.max(skipped - shown.length, 0);
+      const named = shown.length > 0
+        ? ` — skipped: ${shown.join(', ')}${rest > 0 ? `, …and ${rest} more` : ''}`
+        : '';
+      // Codex r2: NO trailing period — the legacy sentence must stay byte-identical, names follow after a space.
+      notes.push(`no-secrets: ${skipped} packed inventory item(s) not scanned (oversize/unreadable/binary) — the secret scan is fail-open, so this is a coverage gap on the record, not a violation${named}`);
+    }
+    // Lead fix (guard-change-fact regression): a fixture with zero publishable packages yields an EMPTY
+    // inventory string — 'present but empty' is not a source to report; only a non-empty summary is a line.
+    const inventoryLine = facts.secretScan?.inventory;
+    if (typeof inventoryLine === 'string' && inventoryLine.trim().length > 0) {
+      notes.push(`no-secrets: inventory: ${inventoryLine}`);
     }
   }
   if (checked.includes('review-round') && facts.reviewRound?.gathered === false) {
+    // A wholly absent fact is already NOT-ESTABLISHED via HAS_INPUT; this note covers an explicit
+    // failed gathering attempt on a present fact only.
     // 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
@@ -1338,6 +1425,18 @@ export interface GuardAuditRecord {
   readonly observations?: readonly GuardObservation[];
   /** set when the operator overrode a block with `--force <reason>` — the override is logged, never silent. */
   readonly override?: { readonly forced: true; readonly reason: string };
+  /**
+   * Ids of every rule this run EVALUATED — `checked` plus `notEstablished`, because both mean the
+   * rule was active for the op and got its turn.
+   *
+   * Why the log needs it (backlog 1bee49dd): a guard rule's zero-firing state is its HEALTHY state,
+   * so `violations[]` cannot tell a working safety net from a dead rule. MEASURED 2026-09-21 on
+   * `.dz/guard-audit.jsonl`: 1854 rows, 26 default rules, 6 of which never appear in any violations
+   * array — and 4 of those 6 are not allowlisted, so the moment the report's history floor is met
+   * they would be named dead for doing their job. The evaluation set was already computed in
+   * `GuardResult`; only the record dropped it.
+   */
+  readonly evaluated?: readonly string[];
 }
 
 /** Build the audit record for a guard evaluation (+ an optional forced-override reason). Pure. */
@@ -1350,9 +1449,21 @@ export function auditRecord(result: GuardResult, ts: string, override?: { reason
     ...(Array.isArray(result.notes) && result.notes.length > 0 ? { notes: result.notes } : {}),
     ...(Array.isArray(result.observations) && result.observations.length > 0 ? { observations: result.observations } : {}),
     ...(override && typeof override.reason === 'string' ? { override: { forced: true, reason: override.reason } } : {}),
+    ...(evaluatedRuleIds(result).length > 0 ? { evaluated: evaluatedRuleIds(result) } : {}),
   };
 }
 
+/**
+ * Every rule that got its turn this run, sorted and de-duplicated. A rule with no input still RAN —
+ * calling that "not evaluated" would reintroduce the very conflation this field exists to remove.
+ */
+export function evaluatedRuleIds(result: GuardResult): string[] {
+  const ids = new Set<string>();
+  for (const id of Array.isArray(result.checked) ? result.checked : []) if (typeof id === 'string' && id !== '') ids.add(id);
+  for (const id of Array.isArray(result.notEstablished) ? result.notEstablished : []) if (typeof id === 'string' && id !== '') ids.add(id);
+  return [...ids].sort();
+}
+
 /** The exit-code contract: a block is non-zero unless forced; a warn/pass is zero. */
 export function guardExitCode(result: GuardResult, forced: boolean): number {
   return result.verdict === 'block' && !forced ? 1 : 0;

package/src/index.ts

@@ -78,6 +78,8 @@ export {
 } from './parity.js';
 export type { RuntimeCapability, FeatureForm, ParityFeature, ParityCell, ParityReportCell, ParityMatrixRow, CapabilityEvidence, UnbackedCapability, ProbedRuntimeVersions } from './parity.js';
 export * from './operations.js';
+export { checkInstrumentFreshness, checkRankingState } from './doctor-instrument.js';
+export type { InstrumentFreshness, InstrumentCheckInput, InstrumentCheckResult, RankingStateCheckInput, RankingStateCheckResult } from './doctor-instrument.js';
 // workflows.ts: the ADR-005 templates are RETIRED (feature loop-designer, AM-6) — the module is a
 // deprecation shim (empty WORKFLOW_NAMES). BREAKING for external harness-core consumers of
 // WorkflowTemplate/WORKFLOWS/getWorkflow — deliberately channeled through the 0.x MINOR bump and
@@ -116,6 +118,7 @@ export * from './trace-bundle.js';
 export { BLOBS as LOOP_BLOBS, LOOP_BLOB_NAMES, BLOB_COVERAGE_MANIFEST } from './loop-blobs.generated.js';
 export type { LoopBlob } from './loop-blobs.generated.js';
 export * from './sign.js';
+export * from './pack-inventory.js';
 export * from './publish-source-scope.js';
 export * from './swarm-brief.js';
 export * from './skill-schema.js';
@@ -123,7 +126,7 @@ export { createSkill } from './create-skill.js';
 export type { CreateSkillOptions, CreateSkillResult } from './create-skill.js';
 export { checkUpstream, checkAllUpstream, discoverSourcePackages, loadSourcesManifest } from './sync-upstream.js';
 export type { SyncUpstreamReport, UpstreamCheckResult, SourcesManifest, SourcePackageInfo } from './sync-upstream.js';
-export { sweepSkillDrift, syncCanonicalSkill } from './skill-drift.js';
+export { sweepSkillDrift, syncCanonicalSkill, findCanonicalDefects } from './skill-drift.js';
 export { SKILL_INSTALL_ROOTS, SKILL_INSTALL_ROOT_BY_TARGET, DEV_SKILL_ROOT, TARGET_ENRICHMENT_ASSETS } from './skill-install-roots.js';
 export { stampCheckpointLine } from './checkpoint-stamp.js';
 export { TELEMETRY_VOCAB_VERSION, TELEMETRY_FIELDS, PROVISIONAL_TELEMETRY_FIELDS, LOCAL_FIELD_ALIASES, RUN_OUTCOMES, telemetryFieldFor, runOutcomeOf } from './telemetry-vocabulary.js';
@@ -135,9 +138,9 @@ export { projectSkillsOneRoot, projectSkillsProbeCommand } from './project-skill
 export { isRepoBoundary } from './repo-boundary.js';
 export type { RepoBoundaryIo } from './repo-boundary.js';
 export type { LedgerBackfillPlan, LedgerBackfillRow, RunCostFacts } from './ledger-backfill.js';
-export type { SweepResult, DriftedSkill, SyncResult, SyncCanonicalOptions } from './skill-drift.js';
+export type { SweepResult, DriftedSkill, SyncResult, SyncCanonicalOptions, CanonicalDefect, CanonicalDefectKind } from './skill-drift.js';
 export { benchmarkSkill, benchmarkSkills, compareSkills } from './benchmark.js';
-export { buildRegistry, searchRegistry, filterByCategory, skillPackBaseDirs, discoverSkillPackDirs, discoverSkillCarryingDirs, discoverVerifiablePackDirs } from './registry.js';
+export { buildRegistry, buildShowcaseRegistry, searchRegistry, filterByCategory, skillPackBaseDirs, discoverSkillPackDirs, discoverSkillCarryingDirs, discoverVerifiablePackDirs, packScope, verifiedScopeNote } from './registry.js';
 export { tokenize, stemToken, stems } from './stem.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;
@@ -147,9 +150,9 @@ export { recommend } from './recommend.js';
 export { pretrain } from './pretrain.js';
 export { loadPatterns, loadSessions, computePatternBoost, readLearningConfig, readMemoryLearningConfig, BOOST_CAP, recordPattern, recordLessonForms, loadStorePatternsSync, loadStoreRecords, findExactLesson, patternToRecord, recordToPattern, patternRecordId, patternIdentityOf, dreamRecordId, isMirrorableLearning, consolidateSessions, recallPatterns, pruneNoisePatterns, removePatternsByIds, snapshotStore, readReinforcementState, encodeReinforcementState, reinforcePattern, resolveReinforceTarget, updateReinforcementState, storeStats, lessonDeltaReport, lessonDeltaMap, readQuarantineState, encodeQuarantineState, promotePatterns, quarantineExpiryCandidates, pruneQuarantinePatterns } from './patterns.js';
 export { normalizeLessonForms, validateClassTemplate, lessonPairIdOf, mergeLessonFormHits, mergeLessonMatchedForms } from './lesson-generalization.js';
-export { withStoreLock, withStoreLockSync, storeLockPath, StoreLockTimeoutError, StoreLockCompromisedError, STALE_LOCK_MS, LOCK_TIMEOUT_MS } from './store-lock.js';
+export { withStoreLock, withStoreLockSync, storeLockPath, storeExists, StoreAbsentError, StoreLockTimeoutError, StoreLockCompromisedError, STALE_LOCK_MS, LOCK_TIMEOUT_MS } from './store-lock.js';
 export type { StoreLockOptions } from './store-lock.js';
-export { withNamedLockSync, namedLockPath, isSafeLockName, NamedLockNameError, NamedLockTimeoutError, NamedLockCompromisedError } from './named-lock.js';
+export { withProjectLockSync, withDirLockSync, namedLockPath, isSafeLockName, NamedLockNameError, NamedLockTimeoutError, NamedLockCompromisedError } from './named-lock.js';
 export {
   QE_BRIDGE_SCHEMA,
   QE_BRIDGE_FAILURE_SCHEMA,
@@ -601,8 +604,11 @@ export {
   extractReportGrade,
   settleReqeDebt,
   renderReqeList,
+  countReqeByCause,
 } from './reqe.js';
-export type { ModelFamily, ReqeEmitDecision, ReqeDebt, ReqeBrief, ReqeSettlement } from './reqe.js';
+export type { ModelFamily, ReqeCause, ReqeRungState, ReqeBridgeFacts, ReqeEmitInput, ReqeEmitDecision, ReqeDebt, ReqeBrief, ReqeSettlement } from './reqe.js';
+export { classifyReqeFindings, parsePriorFindings, buildReqeVerdict } from './reqe-verdict.js';
+export type { ReqeVerdict, ReqeFindingsClass, ReqeSeverity, ReqeSeverityCounts, ReqeBlockingRow, ReqePriorVerdict } from './reqe-verdict.js';
 export {
   detectQueryLang,
   relevanceFloorFor,
@@ -782,6 +788,7 @@ export {
   planReleaseGates,
   classifyGateExecutions,
   buildFailureIssue,
+  shouldRetryGhWithoutToken,
   buildReleaseNotes,
   releaseTagName,
   firstOutputLine,
@@ -881,7 +888,7 @@ export type {
   McpSeverity,
   McpCapability,
 } from './mcp-scan.js';
-export type { RegistryEntry, Registry } from './registry.js';
+export type { RegistryEntry, Registry, ShowcaseRegistry, ShowcaseSkill } from './registry.js';
 export type { BenchmarkCheck, BenchmarkScore, BenchmarkReport, CompareResult } from './benchmark.js';
 export {
   specToOpts,
@@ -1153,6 +1160,14 @@ export * from './skills-verify.js';
 // from darwin-mode; measurements are dz-native and NEVER fake a verdict (INSUFFICIENT_DATA is a
 // finding, not a pass).
 export * from './compounding.js';
+// Дополнительная метрика доведённой работы: публичные функции и типы.
+export { joinLessonOutcomes, renderLessonOutcomes } from './compounding.js';
+export type {
+  LessonOutcomeRow,
+  LessonOutcomeCounters,
+  LessonOutcomeCoverage,
+  JoinedLessonOutcomes,
+} from './compounding.js';
 
 // Advisory command-invocation telemetry + deadwood report (feature dz-deadwood).
 export * from './cmd-usage.js';
@@ -1346,3 +1361,9 @@ export * from './cross-family-control.js';
 
 export { debtRatchetVerdict, parsePinnedCeiling, ceilingUnreadableMessage } from './debt-ratchet.js';
 export type { DebtRatchetArgs, DebtRatchetVerdict, PinnedCeiling } from './debt-ratchet.js';
+
+// Квитанция зелёного прогона: проверка на PUSH вместо проверки на коммите (развилка 4, 21.09).
+export { decideTestReceipt, renderTestReceiptVerdict } from './test-receipt.js';
+export type { TestReceipt, TestReceiptVerdict, TestReceiptScopeState } from './test-receipt.js';
+export { decideBackupFreshness, renderBackupFreshness } from './backup-freshness.js';
+export type { BackupFreshnessVerdict } from './backup-freshness.js';

package/src/integration-apply.ts

@@ -20,7 +20,7 @@ import { dirname, join, relative, resolve, sep } from 'node:path';
 
 import { canonicalIntegrationJson, parseStrictJson, type CarrierFragment, type IntegrationReasonCode } from '@dzhechkov/core';
 
-import { withNamedLockSync } from './named-lock.js';
+import { withProjectLockSync } from './named-lock.js';
 
 const MAX_CARRIER_BYTES = 1024 * 1024;
 const JOURNAL_REL = '.dz/integrations-ownership.json';
@@ -226,7 +226,7 @@ export function applyIntegrationFragments(options: ApplyIntegrationOptions): Int
   }
   if (groups.size === 0) return { written: [], alreadyCurrent: [], journalPath: JOURNAL_REL };
 
-  return withNamedLockSync(root, 'integrations', () => {
+  return withProjectLockSync(root, 'integrations', () => {
     const rootBefore = statSync(root);
     const dzBefore = statSync(join(root, '.dz'));
     const journalRead = readBoundedJson(journalPath, JOURNAL_REL);

package/src/lesson-payoff.ts

@@ -37,7 +37,7 @@ import { randomBytes } from 'node:crypto';
 import { join } from 'node:path';
 
 import { LessonBandit, type ArmStats, type SerializedBanditState } from './lesson-bandit.js';
-import { withNamedLockSync } from './named-lock.js';
+import { withProjectLockSync } from './named-lock.js';
 import { readMemoryLearningConfig, type MemoryLearningConfig } from './patterns.js';
 
 // ── Paths and constants ─────────────────────────────────────────────────────────────────────────
@@ -360,7 +360,7 @@ export interface BanditWriteOutcome {
  *
  * **Why the lock and not just the atomic rename.** MEASURED in this repo (2026-08-19, four
  * barrier-synchronised writers on one JSON file, all exit 0): ONE of four updates survived without a
- * lock; all four survived with `withNamedLockSync`. Temp+rename prevents a TORN read; it does
+ * lock; all four survived with `withProjectLockSync`. Temp+rename prevents a TORN read; it does
  * nothing about a LOST update, and the loss is silent — both writers report success.
  *
  * No network call, no subprocess, no model turn inside the section — an advisory lock held past its
@@ -372,7 +372,7 @@ function mutateBanditState(
   mutate: (bandit: LessonBandit, env: { exposures: Record<string, Record<string, number>>; explorePulls: Record<string, Record<string, number>> }) => void,
 ): BanditWriteOutcome {
   try {
-    return withNamedLockSync(projectRoot, BANDIT_LOCK_NAME, (): BanditWriteOutcome => {
+    return withProjectLockSync(projectRoot, BANDIT_LOCK_NAME, (): BanditWriteOutcome => {
       const { state, reason } = loadBanditState(projectRoot);
       if (reason === 'future-schema') {
         // Refuse to clobber a state written by a newer dz. The reward is dropped, loudly.

package/src/mutation-gate.ts

@@ -494,6 +494,12 @@ export interface MutationObservation {
   readonly outputError?: string;
   /** bounded log proving an internal runner failure received at most one retry. */
   readonly internalAttemptLog?: string;
+  /**
+   * Whether any suite the entry's `testCommand` selects NAMES the mutated module — see
+   * {@link suiteSelectionNamesModule}. Only read on the UNDEFENDED path, and only to add a hint:
+   * `false` says "check the command before the tests", never "the property is fine".
+   */
+  readonly suiteNamesModule?: boolean | 'unknown';
 }
 
 export interface MutationEntryResult {
@@ -1333,7 +1339,13 @@ function classifyMutationOutcomeWithoutAttemptLog(obs: MutationObservation): Mut
       applied: true,
       verdict: 'UNDEFENDED',
       drop: false,
-      detail: `suite stayed GREEN with the protection deleted — property UNDEFENDED: "${e.property}" (${e.file}). The suite would not notice this protection regressing (rule 2).`,
+      detail: `suite stayed GREEN with the protection deleted — property UNDEFENDED: "${e.property}" (${e.file}). The suite would not notice this protection regressing (rule 2).`
+        + (obs.suiteNamesModule === false
+          ? ' HINT: no suite in this entry\'s testCommand NAMES this module, so check the COMMAND before the tests'
+            + ' — a suite that never loads the module cannot notice its protection (MEASURED 2026-09-04: two properties'
+            + ' read as UNDEFENDED for exactly this reason, and both tests existed). The hint matches the module stem,'
+            + ' so a transitive import would not be seen by it: it narrows where to look, it does not decide.'
+          : ''),
     };
   }
 
@@ -1408,6 +1420,47 @@ function classifyMutationOutcomeWithoutAttemptLog(obs: MutationObservation): Mut
   };
 }
 
+/**
+ * Suite paths a registry `testCommand` selects, in order. Tokens that are not suite files (the
+ * runner, its flags) are ignored — the command is a shell line, not a schema, so this reads the
+ * shape it actually has rather than assuming one.
+ */
+export function parseSuitePaths(testCommand: string): readonly string[] {
+  return String(testCommand ?? '')
+    .split(/\s+/)
+    .filter((token) => /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(token) && !token.startsWith('-'));
+}
+
+/**
+ * Does ANY suite the command selects even name the mutated module?
+ *
+ * Why this exists: `UNDEFENDED` reads as "this property has no test", and MEASURED 2026-09-04 that
+ * reading was wrong twice in one run — both tests existed; the registry's `testCommand` simply did
+ * not select the suites that import them (backlog 1f4e4f66). The author filed a finding about two
+ * "unprotected properties" before checking the instrument, which is the failure this hint prevents.
+ *
+ * Deliberately a HINT, never a verdict: it matches the module's STEM in each suite's text, so a
+ * suite that reaches the module through a transitive import is invisible to it. `'unknown'` when no
+ * suite could be read — absence of evidence is not evidence, and a hint that guesses is worse than
+ * no hint.
+ */
+export function suiteSelectionNamesModule(input: {
+  readonly file: string;
+  readonly suitePaths: readonly string[];
+  readonly readSuite: (path: string) => string | null;
+}): boolean | 'unknown' {
+  const stem = String(input.file ?? '').split('/').pop()?.replace(/\.[cm]?[jt]sx?$/, '') ?? '';
+  if (stem === '') return 'unknown';
+  let read = 0;
+  for (const suite of input.suitePaths) {
+    const text = input.readSuite(suite);
+    if (text === null) continue;
+    read += 1;
+    if (text.includes(stem)) return true;
+  }
+  return read === 0 ? 'unknown' : false;
+}
+
 export function classifyMutationOutcome(obs: MutationObservation): MutationEntryResult {
   const result = classifyMutationOutcomeWithoutAttemptLog(obs);
   if (obs.internalAttemptLog === undefined) return result;

package/src/named-lock.ts

@@ -1,5 +1,6 @@
 /**
- * Named advisory locks — `.dz/locks/<name>.lock` (feature qe-bridge-claude, ADR-001 D4-A).
+ * Named advisory locks — project stores use `.dz/locks/<name>.lock`; generic directories
+ * use `.dz-locks/<name>.lock`, honouring an existing legacy `.dz/locks` directory.
  *
  * WHY. The pattern store already has a cross-process lock (`store-lock.ts`), but it guards ONE
  * resource. Other read-modify-write surfaces in this repo have the same lost-update shape and no
@@ -27,13 +28,13 @@
  * backstop for that case, and the rule doc says so in as many words.
  */
 
-import { mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { randomBytes } from 'node:crypto';
 import { createRequire } from 'node:module';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { lockSync } from 'proper-lockfile';
 
-import { LOCK_TIMEOUT_MS, resolveStaleMs } from './store-lock.js';
+import { LOCK_TIMEOUT_MS, resolveStaleMs, storeExists, StoreAbsentError } from './store-lock.js';
 import type { StoreLockOptions } from './store-lock.js';
 
 /** `proper-lockfile` silently clamps `stale` up to this minimum. */
@@ -172,13 +173,11 @@ function ownerMarkerPath(lockPath: string): string {
 }
 
 function tryAcquire(
-  projectRoot: string,
-  name: string,
+  lockPath: string,
+  resourceKey: string,
   staleMs: number,
   onCompromised: (e: Error) => void,
 ): Acquired | 'held' {
-  const lockPath = namedLockPath(projectRoot, name);
-  const resourceKey = resolve(projectRoot, '.dz', 'locks', name);
   try {
     const release = lockSync(resourceKey, {
       lockfilePath: lockPath,
@@ -231,21 +230,47 @@ function tryAcquire(
  * heartbeat cannot fire while a synchronous `fn` blocks the event loop, so keep bodies well under
  * `staleMs` — the same caveat `withStoreLockSync` carries.
  */
-export function withNamedLockSync<T>(
+export function withProjectLockSync<T>(
   projectRoot: string,
   name: string,
   fn: () => T,
   opts: StoreLockOptions = {},
 ): T {
   const lockPath = namedLockPath(projectRoot, name); // validates the name BEFORE any mkdir
+  if (!storeExists(projectRoot)) throw new StoreAbsentError(projectRoot, name);
+  mkdirSync(dirname(lockPath), { recursive: true });
+  return withLockSync(lockPath, name, fn, opts);
+}
+
+/** A directory mutex never seeds a store; an existing legacy lock directory is shared. */
+export function withDirLockSync<T>(
+  dir: string,
+  name: string,
+  fn: () => T,
+  opts: StoreLockOptions = {},
+): T {
+  const legacyPath = namedLockPath(dir, name); // validation precedes the filesystem question
+  const legacyDir = dirname(legacyPath);
+  let lockPath: string;
+  if (existsSync(legacyDir)) {
+    lockPath = legacyPath; // never create the legacy directory
+  } else {
+    const lockDir = join(dir, '.dz-locks');
+    mkdirSync(lockDir, { recursive: true });
+    lockPath = join(lockDir, `${name}.lock`);
+  }
+  return withLockSync(lockPath, name, fn, opts);
+}
+
+function withLockSync<T>(lockPath: string, name: string, fn: () => T, opts: StoreLockOptions): T {
+  const resourceKey = resolve(dirname(lockPath), name);
   const { staleMs, timeoutMs, pollMs } = resolveOpts(opts);
-  mkdirSync(join(projectRoot, '.dz', 'locks'), { recursive: true });
   const started = Date.now();
   const deadline = started + timeoutMs;
   let compromised: Error | undefined;
   const onCompromised = (e: Error): void => { compromised = e; };
   for (;;) {
-    const got = tryAcquire(projectRoot, name, staleMs, onCompromised);
+    const got = tryAcquire(lockPath, resourceKey, staleMs, onCompromised);
     if (got !== 'held') {
       let result: T;
       let outcome: 'released' | 'stolen' | 'stolen-undisarmed' = 'released';