@dzhechkov/harness-core 0.8.10 → 0.8.20

package/src/guard.ts

@@ -51,12 +51,20 @@ export interface Violation {
   readonly contentAnchor?: string;
 }
 
+/** A publish-secret waiver: exact repo-relative path, with a mandatory explanation. */
+interface SecretWaiver {
+  readonly path?: string;
+  readonly reason?: string;
+}
+
 export interface GuardResult {
   readonly op: GuardOp;
   readonly verdict: GuardVerdict;
   readonly violations: readonly Violation[];
   /** ids of the rules that ran for this op (so a report can show what was checked, not just what failed). */
   readonly checked: readonly string[];
+  /** ids of the rules that ran for this op but received no input to examine. */
+  readonly notEstablished: readonly string[];
   /**
    * Informational notes (FN-7): things a rule wants ON THE RECORD that are NOT violations and never
    * touch the verdict — e.g. "no-stubs: N changed scannable file(s) not scanned". A fail-open skip
@@ -75,10 +83,58 @@ export interface GuardFacts {
   readonly volume?: VolumeShadowInput;
   /** for no-workspace-star: each publishable package's deps map. */
   readonly packages?: readonly { readonly name: string; readonly deps: Readonly<Record<string, string>> }[];
+  /**
+   * for sibling-dep-protocol: КАЖДАЯ зависимость на соседний пакет монорепозитория, как она
+   * записана НА ДИСКЕ (без подстановки версии), с полем, в котором она объявлена. Поле нужно:
+   * `dependencies` и `devDependencies` обязаны идти через workspace-протокол, а `peerDependencies`
+   * и `optionalDependencies` — НЕТ, и это не послабление, а разная семантика (см. правило).
+   */
+  /**
+   * for plugin-manifest-audit: каждый найденный `.claude-plugin/plugin.json` и объявленные им
+   * поля. `parseError` заполнен ⇒ манифест не разобрался; остальные поля тогда не смотрят.
+   */
+  readonly pluginManifests?: readonly {
+    readonly path: string;
+    readonly parseError?: string;
+    readonly name?: string;
+    readonly version?: string;
+    readonly description?: string;
+    /** Имена навыков, ОБЪЯВЛЕННЫЕ манифестом. */
+    readonly declaredSkills?: readonly string[];
+    /** Имена навыков, НАЙДЕННЫЕ на диске рядом с манифестом. */
+    readonly skillsOnDisk?: readonly string[];
+  }[];
+  readonly siblingDeps?: readonly {
+    readonly name: string;
+    readonly field: string;
+    readonly dep: string;
+    readonly spec: string;
+  }[];
+  /**
+   * for backlog-covers-features: каталоги фич, дата их ПЕРВОГО коммита, тексты записей бэклога и
+   * базовая дата. Базовая дата обязательна и делает правило зелёным на приходе: 336 существующих
+   * каталогов заведены до правила, и краснеть на них — значит учить себя игнорировать (ИЗМЕРЕНО
+   * 2026-09-03: без базы 236 нарушений, в окне 7 дней — 48). Отсутствие факта ⇒ правило молчит:
+   * страж без улик не выдумывает вердикт.
+   */
+  readonly featureBacklog?: {
+    readonly baseline: string;
+    readonly features: readonly { readonly slug: string; readonly createdIso: string; readonly waiver?: string }[];
+    readonly backlogTexts: readonly string[];
+  };
   /** for no-skill-drift: the names that byte-drift between copies (from sweepSkillDrift). */
   readonly drift?: 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.
+   */
+  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: 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 };
   /** 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. */
@@ -294,7 +350,10 @@ function unquoteYaml(s: string): string {
 /** The built-in rule set (works with no config). Ops are the mutating operations each rule guards. */
 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: '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: '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)' },
@@ -306,6 +365,7 @@ export const DEFAULT_RULES: readonly GuardRule[] = [
   { id: 'feature-artifact-diff-ratio', severity: 'soft', ops: ['publish'], description: 'observe feature artifact bytes against attributable unified-diff bytes, explicitly a proxy; advisory only' },
   { id: 'feature-tier-artifact-set', severity: 'soft', ops: ['publish'], description: 'observe artifacts due for the recorded feature tier, active steps, consumers, and lifecycle; advisory only' },
   { id: 'agents-md-policy-sync', severity: 'soft', ops: ['publish'], description: 'proves the AGENTS.md copy is in SYNC with its source — not that the runtime read or obeyed it; heal drift with dz agents-sync' },
+  { id: 'codex-wrapper-for-value-stage', severity: 'hard', ops: ['publish'], description: 'a workflow stage routed to the fire-and-forget codex wrapper must not have its return value consumed — the wrapper answers with a dispatch stub, never with the model' },
   { id: 'lockfile-in-sync', severity: 'soft', ops: ['publish'], description: 'every workspace @dzhechkov/* dependency spec matches the specifier pnpm-lock.yaml records for that importer (a dep bump without a lockfile refresh breaks CI with ERR_PNPM_OUTDATED_LOCKFILE). SOFT-ONLY — a config cannot promote it to HARD' },
   { id: 'store-bloat-cap', severity: 'soft', ops: ['teach', 'consolidate'], description: 'the learned store is within its size cap' },
   // Description ASSEMBLED from STUB_MARKERS so guard.ts itself stays clean under the scan it defines
@@ -340,7 +400,91 @@ export function scanSecrets(text: unknown): { readonly name: string }[] {
   return [...hits].map((name) => ({ name }));
 }
 
+function secretWaiverState(waivers: readonly SecretWaiver[] | undefined): { waived: ReadonlySet<string>; reasonless: number } {
+  const waived = new Set<string>();
+  let reasonless = 0;
+  for (const waiver of Array.isArray(waivers) ? waivers : []) {
+    if (!waiver || typeof waiver !== 'object' || typeof waiver.path !== 'string' || waiver.path.trim() === '') continue;
+    const reason = typeof waiver.reason === 'string' ? waiver.reason.trim() : '';
+    if (reason.length > 0) waived.add(waiver.path);
+    else reasonless++;
+  }
+  return { waived, reasonless };
+}
+
 /** Per-rule pure checkers. Each returns the violations it found (empty ⇒ clean). Missing evidence ⇒ []. */
+/**
+ * Какие каталоги фич заведены после базовой даты и НЕ названы ни одной записью бэклога.
+ *
+ * БАЗОВАЯ ДАТА — не украшение, а условие осмысленности. ИЗМЕРЕНО 2026-09-03: без неё правило даёт
+ * 236 нарушений из 336 каталогов, а в окне «последние 7 дней» — 48 из 85. Проверка, изобретающая
+ * полсотни нарушений в первый день, учит людей себя игнорировать, то есть хуже отсутствующей.
+ * База делает правило зелёным на приходе и красным ровно на новом.
+ *
+ * ДАТА ПЕРВОГО КОММИТА, А НЕ mtime. Время правки меняет любой посторонний процесс — пересборка,
+ * перенос, чтение с обновлением. Дата появления каталога в истории неподвижна. ЧЕСТНАЯ ГРАНИЦА:
+ * функция ДОВЕРЯЕТ переданной строке и происхождение её не подтверждает — обязанность подать
+ * именно git-дату лежит на вызывающем (сбор фактов в cli.ts). Здесь проверяется только то, что
+ * строка вообще разбирается в дату.
+ *
+ * ЧТО ИМЕННО ПРОВЕРЯЕТСЯ В ОГОВОРКЕ — сказано точно, потому что ревью 2026-09-03 поймало
+ * расхождение обещания с кодом. Машинно проверяется РОВНО одно: строка непуста после обрезки
+ * пробелов. Осмысленность причины машинно не проверяема, и оговорка `x` пройдёт. Это сознательная
+ * граница слоя: гейт заставляет РЕШЕНИЕ БЫТЬ ЗАПИСАННЫМ, а качество формулировки остаётся делом
+ * человека — ровно как у освобождений заставы секретов и списка исключений дрейфа.
+ *
+ * БАЗА ВКЛЮЧИТЕЛЬНА: каталог, заведённый В САМ день базы, правилом контролируется («не раньше
+ * базы», а не «после базы»).
+ *
+ * ЧЕГО ЭТА ПРОВЕРКА НЕ ЛОВИТ, названо честно: работу БЕЗ каталога фичи — разбор, ремонт, рой,
+ * обещание «вернёмся». Машинного следа у них нет, и они остаются на слое 2 (текст правила в
+ * CLAUDE.md). Утверждать, что правило покрыто целиком, было бы ложной гарантией.
+ */
+export function backlogCoversFeatures(
+  features: readonly { readonly slug: string; readonly createdIso: string; readonly waiver?: string }[],
+  backlogTexts: readonly string[],
+  baseline: string,
+): readonly string[] {
+  // ДАТЫ СРАВНИВАЮТСЯ ЧИСЛАМИ, А НЕ СТРОКАМИ. Кросс-семейное ревью 2026-09-03 (gpt-5.6-sol, Grade D)
+  // предъявило три входа, на которых строковое сравнение ISO даёт неверный ответ, и я воспроизвёл их
+  // прогоном: `"   "` (пробелы лексикографически меньше любой даты — каталог освобождался),
+  // `"2026-09-02T23:30:00-02:00"` (фактически ПОЗЖЕ базы, строково раньше), и разные формы записи
+  // одной даты. Разбор в число снимает весь класс разом.
+  const baseMs = Date.parse(baseline);
+  const blob = backlogTexts.join('\n').toLowerCase();
+  const out: string[] = [];
+  for (const f of features) {
+    if (typeof f.slug !== 'string' || f.slug.trim() === '') continue;
+    // НЕРАЗБИРАЕМАЯ ИЛИ ОТСУТСТВУЮЩАЯ ДАТА — НЕ ОСВОБОЖДЕНИЕ. Каталог, чью дату появления не удалось
+    // установить, считается новым: это отказ в сторону строгости. Обратный выбор превращал бы порчу
+    // входа в способ обойти правило.
+    const bornMs = typeof f.createdIso === 'string' ? Date.parse(f.createdIso.trim()) : Number.NaN;
+    const born = Number.isFinite(bornMs) ? bornMs : Number.POSITIVE_INFINITY;
+    if (Number.isFinite(baseMs) && born < baseMs) continue;
+    if (typeof f.waiver === 'string' && f.waiver.trim() !== '') continue;
+    if (mentionsSlug(blob, f.slug)) continue;
+    out.push(f.slug);
+  }
+  return out;
+}
+
+/**
+ * Назван ли slug в тексте КАК ОТДЕЛЬНОЕ СЛОВО.
+ *
+ * Голый `includes` засчитывал совпадение внутри чужого слова: slug `log` считался покрытым записью
+ * «обновить catalog schema», а `api` — записью «починить capitalization report» (примеры из
+ * кросс-семейного ревью 2026-09-03, воспроизведены прогоном). Ложное покрытие опаснее ложного
+ * срабатывания: оно ТИХО гасит правило ровно там, где оно нужно.
+ *
+ * Границей считается всё, кроме латинской буквы, цифры, подчёркивания и дефиса — дефис входит в
+ * слово, потому что сами slug'и кебабные и `date-layers` не должен совпасть внутри
+ * `dashboard-date-layers`.
+ */
+function mentionsSlug(haystackLower: string, slug: string): boolean {
+  const s = slug.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`(^|[^a-z0-9_-])${s}($|[^a-z0-9_-])`).test(haystackLower);
+}
+
 const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[]> = {
   'no-workspace-star': (f, sev) => {
     const out: Violation[] = [];
@@ -353,13 +497,146 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
     }
     return out;
   },
+  'plugin-manifest-audit': (f, sev) => {
+    /**
+     * ЗНАЧЕНИЕ ЕСТЬ, ТОЛЬКО ЕСЛИ ОНО ВИДНО. `trim()` не убирает нулевой ширины пробел и его
+     * родню, поэтому описание из одного `\u200B` проходило как заполненное — назвал независимый
+     * ревьюер 2026-09-04. Считается видимым лишь то, что остаётся после удаления пробельных И
+     * невидимых символов.
+     */
+    const visible = (v: unknown): v is string =>
+      typeof v === 'string' && v.replace(/[\s\u00a0\u180e\u200b-\u200f\u2028\u2029\u202a-\u202e\u2060-\u2064\ufeff]/g, '') !== '';
+    /** Путь состава в сравнимом виде: `./skills/a` и `skills/a` — один каталог, а не два. */
+    const normPath = (v: unknown): string | null =>
+      typeof v === 'string'
+        ? v.normalize('NFC').replace(/^\.\//, '').replace(/\/+$/, '').replace(/\/{2,}/g, '/')
+        : null;
+    // ПРОВЕРКА ПАСПОРТА НА ВХОДЕ. Правило `marketplace-parity` отвечает на другой вопрос — совпадает
+    // ли витрина со свежей регенерацией. Если ГЕНЕРАТОР выдаст пустое описание или версию `1.0`,
+    // parity будет доволен: копия совпадает с оригиналом, оба неверны. Здесь проверяется САМО
+    // содержимое.
+    //
+    // ЧЕГО ЗДЕСЬ НЕТ И ПОЧЕМУ: приёма «имя манифеста равно имени каталога». ИЗМЕРЕНО 2026-09-04 на
+    // 10 манифестах дерева — расхождение ровно одно и оно НАМЕРЕННОЕ: пакет называется
+    // `loop-designer-plugin`, а плагин внутри него — `loop-designer`. Имя плагина есть
+    // опубликованная личность и законно отличается от имени каталога, поэтому такая проверка
+    // краснела бы на верном коде. Правило, изобретающее нарушения, учит людей себя игнорировать.
+    // Ведущие нули запрещены (`01.2.3` — не строгая форма), и значение НЕ обрезается: пробел
+    // вокруг версии в манифесте есть дефект манифеста, а не мелочь, которую следует простить.
+    const STRICT_SEMVER = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
+    const out: Violation[] = [];
+    for (const m of f.pluginManifests ?? []) {
+      if (m.parseError !== undefined) {
+        out.push({ rule: 'plugin-manifest-audit', severity: sev, detail: `${m.path}: манифест не разобрался — ${m.parseError}` });
+        continue;   // остальные поля у неразобранного манифеста не существуют
+      }
+      for (const field of ['name', 'description', 'version'] as const) {
+        // СОБСТВЕННОЕ свойство: манифест, чьи поля приходят из прототипа, ничего не объявил.
+        const value = Object.hasOwn(m, field) ? (m as Record<string, unknown>)[field] : undefined;
+        if (!visible(value)) {
+          out.push({ rule: 'plugin-manifest-audit', severity: sev, detail: `${m.path}: поле ${field} пусто или отсутствует` });
+        }
+      }
+      const rawVersion = Object.hasOwn(m, 'version') ? (m as Record<string, unknown>)['version'] : undefined;
+      if (visible(rawVersion) && !STRICT_SEMVER.test(rawVersion)) {
+        out.push({ rule: 'plugin-manifest-audit', severity: sev, detail: `${m.path}: version = ${JSON.stringify(rawVersion)} — нужна строгая форма N.N.N без ведущих нулей и без пробелов` });
+      }
+      // ИНВЕНТАРИЗАЦИЯ В ОБЕ СТОРОНЫ: всё, что записано в накладной, лежит на складе, И всё, что
+      // лежит на складе, вписано в накладную. Одна сторона ловит обещание без товара, другая —
+      // товар, о котором никто не узнает. Класс, который эта пара закрывает: «счётчики поправили,
+      // файлы не тронули».
+      //
+      // Обе стороны проверяются ТОЛЬКО когда обе улики есть: манифест без поля `skills` не
+      // объявляет состава вовсе, и требовать от него совпадения значило бы выдумать обязательство.
+      const declared = Array.isArray(m.declaredSkills) ? m.declaredSkills : undefined;
+      const onDisk = Array.isArray(m.skillsOnDisk) ? m.skillsOnDisk : undefined;
+      // ПОЛОВИНА УЛИК — НЕ УЛИКИ. Прежде состав, объявленный без осмотра диска, ТИХО пропускался,
+      // а правило продолжало числиться проверенным: то самое «успех из тишины», против которого
+      // оно и заведено (назвал независимый ревьюер 2026-09-04).
+      if ((declared === undefined) !== (onDisk === undefined)) {
+        out.push({
+          rule: 'plugin-manifest-audit', severity: sev,
+          detail: `${m.path}: есть только одна половина улик о составе (${declared !== undefined ? 'объявленное без осмотра диска' : 'осмотр диска без объявленного'}) — сверить нечем`,
+        });
+      } else if (declared !== undefined && onDisk !== undefined) {
+        const normList = (xs: readonly unknown[]): string[] => xs.map(normPath).filter((x): x is string => x !== null && x !== '');
+        // Элемент не-строка — не путь. Молча его пропустить значило бы сверять неполные списки.
+        const badDeclared = declared.filter((x) => normPath(x) === null).length;
+        const badOnDisk = onDisk.filter((x) => normPath(x) === null).length;
+        if (badDeclared > 0 || badOnDisk > 0) {
+          out.push({ rule: 'plugin-manifest-audit', severity: sev, detail: `${m.path}: в составе есть элементы, которые не являются путями (объявлено ${badDeclared}, на диске ${badOnDisk})` });
+        }
+        const have = new Set(normList(onDisk));
+        const said = new Set(normList(declared));
+        const missing = [...said].filter((n) => !have.has(n));
+        const undeclared = [...have].filter((n) => !said.has(n));
+        if (missing.length > 0) {
+          out.push({ rule: 'plugin-manifest-audit', severity: sev, detail: `${m.path}: объявлены, но НЕ найдены на диске: ${missing.join(', ')}` });
+        }
+        if (undeclared.length > 0) {
+          out.push({ rule: 'plugin-manifest-audit', severity: sev, detail: `${m.path}: лежат на диске, но НЕ объявлены: ${undeclared.join(', ')}` });
+        }
+      }
+    }
+    return out;
+  },
+  'sibling-dep-protocol': (f, sev) => {
+    // ПАРА К `no-workspace-star`, а не противоречие ему: они говорят о РАЗНЫХ МОМЕНТАХ. На ДИСКЕ
+    // сиблинг-зависимость обязана быть `workspace:` — тогда pnpm подставит реальную версию при
+    // паковке. В ОПУБЛИКОВАННОМ манифесте `workspace:` быть не должно — npm отправляет его
+    // дословно и ломает установку. Одно правило охраняет вход, другое выход.
+    //
+    // ОБЪЁМ СУЖЕН ИЗМЕРЕНИЕМ, а не осторожностью. Запись бэклога требовала протокол для ЛЮБОЙ
+    // сиблинг-зависимости. Замер 2026-09-03 (56 пакетов, 60 сиблинг-зависимостей) показал 8
+    // исключений — и ВСЕ восемь оказались `peerDependencies` (7) и `optionalDependencies` (1), где
+    // диапазон и есть смысл записи: peer-зависимость объявляет, чему обязан удовлетворять
+    // ПОТРЕБИТЕЛЬ, а `workspace:` при паковке превращается в точный пин, враждебный потребителю.
+    // Одна из восьми — намеренная схема «dz как ОБНАРУЖИВАЕМАЯ необязательная зависимость».
+    // То есть правило в исходной формулировке сломало бы работающий замысел; здесь оно охраняет
+    // ровно те два поля, где протокол уместен, и на них нарушений сегодня НОЛЬ.
+    const out: Violation[] = [];
+    for (const d of f.siblingDeps ?? []) {
+      // Поля читаются как ПРИМИТИВНЫЕ строки. Объект с унаследованным `startsWith`, всегда
+      // возвращающим true, прежде проходил мимо правила — назвал независимый ревьюер 2026-09-04.
+      const field = typeof d?.field === 'string' ? d.field : '';
+      const spec = typeof d?.spec === 'string' ? d.spec : null;
+      if (field !== 'dependencies' && field !== 'devDependencies') continue;
+      if (spec === null) {
+        out.push({ rule: 'sibling-dep-protocol', severity: sev, detail: `${String(d?.name)}: ${field}.${String(d?.dep)} — спецификатор не строка, сверить нечем` });
+        continue;
+      }
+      if (spec.startsWith('workspace:')) continue;
+      out.push({
+        rule: 'sibling-dep-protocol',
+        severity: sev,
+        detail: `${d.name}: ${field}.${d.dep} = "${spec}" — a sibling package must be referenced through the workspace: protocol on disk, so pnpm substitutes the real version at pack time`,
+      });
+    }
+    return out;
+  },
   '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` }];
   },
+  'backlog-covers-features': (f, sev) => {
+    const ev = f.featureBacklog;
+    if (!ev) return [];
+    const uncovered = backlogCoversFeatures(ev.features, ev.backlogTexts, ev.baseline);
+    if (uncovered.length === 0) return [];
+    return [{
+      rule: 'backlog-covers-features',
+      severity: sev,
+      detail: `${uncovered.length} фич(и) заведены после ${ev.baseline} и не названы ни одной записью бэклога: `
+        + `${uncovered.slice(0, 8).join(', ')}${uncovered.length > 8 ? '…' : ''}`
+        + ` — заведи запись (dz backlog add) ЛИБО впиши оговорку в features/<slug>/README.md строкой`
+        + ` "Backlog: не заведено — <причина>". Оговорка без причины не считается.`,
+    }];
+  },
   'no-secrets': (f, sev) => {
     const out: Violation[] = [];
+    const waived = secretWaiverState(f.secretWaivers).waived;
     for (const t of f.secretTargets ?? []) {
+      if (waived.has(t.label)) continue;
       for (const hit of scanSecrets(t.text)) {
         out.push({ rule: 'no-secrets', severity: sev, detail: `${t.label}: looks like a ${hit.name} — do not teach/publish a credential` });
       }
@@ -510,6 +787,40 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
       detail: `${drifted.length} AGENTS.md policy section(s) are out of sync: ${drifted.slice(0, 8).join(', ')}${drifted.length > 8 ? '…' : ''} — heal with: dz agents-sync`,
     }];
   },
+  /**
+   * The fire-and-forget wrapper returns a DISPATCH STUB, so a stage whose deliverable is its
+   * return value gets a receipt instead of an answer. MEASURED 2026-08-31: eight stages of one
+   * research swarm each returned "Codex Task started in the background as task-…", downstream
+   * agents built on those stubs, and no artifact was produced. The misuse is visible in the
+   * program text — the stage's result is assigned to a name that a later prompt interpolates —
+   * 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 out: Violation[] = [];
+    for (const s of scripts) {
+      const text = String(s.text ?? '');
+      // Find `const <name> = await agent(… codex:codex-rescue …)` and ask whether <name> is later
+      // interpolated into another prompt. Assignment alone is not the defect: a stage may keep its
+      // handle for logging. Consumption in a prompt is what proves the VALUE was the deliverable.
+      const re = /(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*await\s+agent\(([\s\S]{0,4000}?)\)\s*(?:\n|;)/g;
+      for (const m of text.matchAll(re)) {
+        const name = String(m[1]);
+        const call = String(m[2]);
+        if (!/codex:codex-rescue/.test(call)) continue;
+        const consumed = new RegExp('\\$\\{\\s*(?:String\\()?' + name.replace(/[.*+?^{}()|[\]\\]/g, '\\$&') + '\\b');
+        if (consumed.test(text)) {
+          out.push({
+            rule: 'codex-wrapper-for-value-stage',
+            severity: sev,
+            detail: `${s.path}: stage "${name}" is routed to codex:codex-rescue AND its result is interpolated into another prompt — the wrapper returns a dispatch stub, so that prompt would receive a receipt, not an answer. Invoke codex synchronously (dz codex / codex exec) for a stage whose deliverable is its return value.`,
+          });
+        }
+      }
+    }
+    return out;
+  },
   'lockfile-in-sync': (f, _sev) => {
     // The 2026-07-28 CI break, mechanized: an overnight dep bump edited package.json and left
     // pnpm-lock.yaml stale, so `pnpm install --frozen-lockfile` died with ERR_PNPM_OUTDATED_LOCKFILE.
@@ -598,6 +909,20 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
   },
 };
 
+/** Per-rule evidence predicates. No entry preserves the rule's existing checked behaviour exactly. */
+const HAS_INPUT: Partial<Record<string, (f: GuardFacts) => boolean>> = {
+  // `!== undefined` пропускал `null`: правило объявлялось проверенным и возвращало чисто по
+  // ветке «улик нет». Это буквально отсутствие улик, отчитанное как проверка (назвал независимый
+  // ревьюер 2026-09-04).
+  'backlog-covers-features': (f) => typeof f.featureBacklog === 'object' && f.featureBacklog !== null,
+  // Страж без улик не выдумывает вердикт: в дереве без сиблинг-зависимостей правилу нечего
+  // сказать, и «прошло» тут значило бы «не смотрели».
+  '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,
+};
+
 /**
  * Rules that may NEVER be promoted to HARD, whatever a config says. A rule whose evidence comes from a
  * deliberately tolerant parser must not be able to BLOCK an operation: the parser's own design admits it
@@ -700,6 +1025,7 @@ export function evaluateGuard(facts: GuardFacts, rules: readonly GuardRule[] = D
   );
   const violations: Violation[] = [];
   const checked: string[] = [];
+  const notEstablished: string[] = [];
   const observations: GuardObservation[] = [];
   let volumeResult: VolumeShadowResult | undefined;
   let volumeEvaluated = false;
@@ -717,6 +1043,27 @@ export function evaluateGuard(facts: GuardFacts, rules: readonly GuardRule[] = D
     return volumeResult;
   };
   for (const r of active) {
+    const hasInput = HAS_INPUT[r.id];
+    // ПРЕДИКАТ УЛИК ИСПОЛНЯЕТСЯ ПОД ЗАЩИТОЙ. Прежде он стоял вне `try`, и факт с бросающим
+    // геттером ронял весь страж вместо того, чтобы стать отказом (назвал независимый ревьюер
+    // 2026-09-04). Гейт, падающий на враждебном входе, не даёт вердикта вообще.
+    let inputPresent: boolean;
+    try {
+      inputPresent = hasInput === undefined ? true : hasInput(facts);
+    } catch (error) {
+      violations.push({
+        rule: r.id, severity: r.severity,
+        detail: `улики правила нечитаемы (${error instanceof Error ? error.message : String(error)}) — правило считается НАРУШЕННЫМ, а не пройденным`,
+      });
+      checked.push(r.id);
+      continue;
+    }
+    if (!inputPresent) {
+      // A rule with nothing to measure cannot produce a positive receipt. Keep the verdict unchanged,
+      // but record the missing input explicitly instead of calling the rule checked.
+      notEstablished.push(r.id);
+      continue;
+    }
     checked.push(r.id);
     if ((VOLUME_SHADOW_RULE_IDS as readonly string[]).includes(r.id)) {
       const emission = volume();
@@ -755,6 +1102,16 @@ 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('no-secrets') || notEstablished.includes('no-secrets')) {
+    const reasonless = secretWaiverState(facts.secretWaivers).reasonless;
+    if (reasonless > 0) {
+      notes.push(`no-secrets: ${reasonless} reasonless secret waiver(s) ignored — add a non-empty reason or remove the entry`);
+    }
+    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`);
+    }
+  }
   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
@@ -781,6 +1138,7 @@ export function evaluateGuard(facts: GuardFacts, rules: readonly GuardRule[] = D
     verdict,
     violations,
     checked,
+    notEstablished,
     ...(notes.length > 0 ? { notes } : {}),
     ...(observations.length > 0 ? { observations } : {}),
   };

package/src/harness-core-location.ts

@@ -0,0 +1,44 @@
+// Where THIS harness-core installation lives on disk (feature `destructive-command-guard`, task T8,
+// cross-family review round 3, both P1 findings).
+//
+// WHY A GUARD NEEDS TO KNOW ITS OWN ADDRESS. Both emitted hook bodies — the Claude PreToolUse hook
+// and the Codex veto helper — are files that run OUTSIDE this package: one in a consumer's
+// `.claude/hooks/`, one in `$CODEX_HOME/dz-hooks/`. They cannot `require('@dzhechkov/harness-core')`,
+// because Node resolves a bare specifier from the FILE's location, and neither location has the
+// package above it. So they resolve by PATH — and the paths they were given were all relative to the
+// project being guarded. MEASURED 2026-09-05, the documented global-install workflow
+// (`npm install -g @dzhechkov/harness-cli`, then a target repo with no local install):
+//   every candidate → ERR_MODULE_NOT_FOUND, helper exits 0, `rm -rf .agentic-qe` ALLOWED.
+// The guard was advertised, installed, trusted — and inert. The tests hid it by symlinking the
+// package into the temp project, which is exactly the condition a real target repo does not have.
+//
+// The fix is to bake the EMITTING installation's absolute path into the body at emission time, as a
+// FALLBACK after the project-local candidates: a consumer that has its own harness-core keeps using
+// its own copy, and everyone else reaches the installation that wrote the hook.
+
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * The directory holding this module's own compiled siblings.
+ *
+ * In a published install that is `<pkg>/dist`; under vitest, where the SOURCE is executed, it is
+ * `<pkg>/src`. Callers that need a BUILT sibling must therefore ask for {@link harnessCoreDistDir},
+ * which normalises the second case — a body that baked `<pkg>/src/foo.js` would be a path that
+ * exists in no installation at all.
+ */
+export function harnessCoreModuleDir(): string {
+  return dirname(fileURLToPath(import.meta.url));
+}
+
+/**
+ * The directory the emitted hook bodies must point at: the one holding the BUILT modules.
+ *
+ * `src` → its sibling `dist`, anything else → itself. The mapping is deliberately this narrow: the
+ * only two layouts that exist are "running the build" and "running the sources under the test
+ * runner", and inventing a search would turn a fact into a guess.
+ */
+export function harnessCoreDistDir(): string {
+  const dir = harnessCoreModuleDir();
+  return dir.endsWith('/src') || dir.endsWith('\\src') ? `${dir.slice(0, -3)}dist` : dir;
+}