@dzhechkov/harness-core 0.8.10 → 0.8.20

package/src/loop-plan-graph.ts

@@ -34,7 +34,72 @@ export type InterfaceGraph = ReadonlyMap<string, readonly GraphField[]>;
 
 /** Brace-matched interface extraction. A regex-only scan truncates at the first nested brace
  * (inline object fields are everywhere in this file), so bodies are cut by depth counting. */
-export function parseInterfaceGraph(source: string): InterfaceGraph {
+/**
+ * Убрать из текста КОММЕНТАРИИ и СОДЕРЖИМОЕ строковых литералов, сохранив длину и переводы строк.
+ *
+ * ЗАЧЕМ, с воспроизведёнными случаями (ИЗМЕРЕНО 2026-09-04, бэклог f23e97dc). Разбор считал скобки
+ * и точки с запятой по СЫРОМУ тексту, и четыре конструкции давали ТИХО НЕВЕРНЫЙ граф — а граф
+ * решает, достижим ли интерфейс, то есть живой он или мёртвый:
+ *
+ *   • `interface X { note: "смотри Y"; }` — упоминание Y ВНУТРИ строки становилось НАСТОЯЩИМ
+ *     ребром. Мёртвый интерфейс выглядел живым: ложно-зелёное в проверке достижимости.
+ *   • `interface X { note: "a; ref: Y"; }` — точка с запятой внутри строки резала запись, и
+ *     появлялось призрачное поле `ref` со своим ребром.
+ *   • `interface X { // закрывает } раньше\n ref: Y; }` — закрывающая скобка в комментарии
+ *     обрезала тело, и настоящее ребро ТЕРЯЛОСЬ: живой интерфейс выглядел мёртвым.
+ *   • `interface X { kind: "{"; ref: Y; }` — открывающая скобка в строке раздувала тело так, что
+ *     интерфейс вовсе исчезал из графа.
+ *
+ * ДЛИНА СОХРАНЯЕТСЯ НАМЕРЕННО: разбор ниже работает индексами по этому же тексту, и замена на
+ * строку другой длины сдвинула бы каждую последующую позицию. Переводы строк сохраняются, чтобы
+ * номера строк оставались верными, если их когда-нибудь понадобится сообщить.
+ */
+function stripCommentsAndStrings(source: string): string {
+  const out = source.split('');
+  const blank = (from: number, to: number): void => {
+    for (let i = from; i < to && i < out.length; i += 1) {
+      if (out[i] !== '\n') out[i] = ' ';
+    }
+  };
+  let i = 0;
+  while (i < source.length) {
+    const two = source.slice(i, i + 2);
+    if (two === '//') {
+      const end = source.indexOf('\n', i);
+      blank(i, end === -1 ? source.length : end);
+      i = end === -1 ? source.length : end;
+      continue;
+    }
+    if (two === '/*') {
+      const end = source.indexOf('*/', i + 2);
+      const stop = end === -1 ? source.length : end + 2;
+      blank(i, stop);
+      i = stop;
+      continue;
+    }
+    const ch = source[i];
+    if (ch === '"' || ch === "'" || ch === '`') {
+      let j = i + 1;
+      while (j < source.length) {
+        if (source[j] === '\\') { j += 2; continue; }   // экранированный символ не закрывает строку
+        if (source[j] === ch) break;
+        j += 1;
+      }
+      // Гасится СОДЕРЖИМОЕ, а кавычки остаются: тип `"a" | "b"` обязан выглядеть как тип, а не
+      // как склеенное слово.
+      blank(i + 1, Math.min(j, source.length));
+      i = Math.min(j + 1, source.length);
+      continue;
+    }
+    i += 1;
+  }
+  return out.join('');
+}
+
+export function parseInterfaceGraph(rawSource: string): InterfaceGraph {
+  // Комментарии и содержимое строк гасятся ДО подсчёта скобок: иначе `}` в комментарии обрезает
+  // тело, `{` в строке его раздувает, а имя интерфейса внутри строки становится ребром графа.
+  const source = stripCommentsAndStrings(rawSource);
   const names = new Set<string>();
   const headRe = /(?:^|\n)\s*(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)/g;
   for (let m = headRe.exec(source); m !== null; m = headRe.exec(source)) names.add(m[1]!);

package/src/loop-trace.ts

@@ -23,6 +23,7 @@
  * consumed by `dz workflow-trace` and by the fitness suite (same runInvariants, two call sites).
  */
 
+import { isNonRunRow } from './ledger-backfill.js';
 import type { TraceProjection } from './loop-plan.js';
 
 /** Blob version stamp for the emitter half (read by scripts/gen-loop-blobs.mjs). */
@@ -941,10 +942,21 @@ export function assembleTimeline(input: {
     }
   }
   if (input.ledger) {
+    // The source is declared even when every row is filtered out: the file WAS read, and saying so
+    // is the difference between "no cost rows" and "no ledger".
     sources.push('ledger');
     for (const line of input.ledger.split('\n')) {
       const t = line.trim();
-      if (t !== '') rows.push({ seq: 0, kind: 'ledger', label: 'cost', detail: t.slice(0, 160), wallTime: null });
+      if (t === '') continue;
+      // AM-4: `kind`-carrying rows are per-phase TELEMETRY, not cost. Labelling one `cost` in a run
+      // timeline states a cost claim the row does not make — MEASURED 2026-09-06 as a real defect,
+      // not a hypothetical. A malformed line is still shown: unparseable is not "not a cost row".
+      try {
+        const parsed: unknown = JSON.parse(t);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+          && isNonRunRow(parsed as Record<string, unknown>)) continue;
+      } catch { /* unparseable → keep it visible, exactly as before */ }
+      rows.push({ seq: 0, kind: 'ledger', label: 'cost', detail: t.slice(0, 160), wallTime: null });
     }
   }
   if (Array.isArray(input.usageEvents)) {

package/src/managed-hooks.ts

@@ -8,8 +8,8 @@
  * obvious way to write it and the wrong one.
  *
  * What differs between the targets is ONLY the attribution predicate, so that is the parameter:
- * the Claude path passes its historical substring list verbatim (bytes must not move — AM-3), the
- * Codex path passes sha-over-manifest (ADR-001 §3: dz never deletes what it cannot prove it wrote).
+ * the Claude path passes its historical command identities, the Codex path passes sha-over-manifest
+ * (ADR-001 §3), and both salvage foreign handlers that share a matcher group with an owned handler.
  *
  * The plan (AM-37) is explicit that the extracted block has **three** outputs, not one: the merged
  * body, the REPORT tail string, and the no-write path (`changed === false`). A golden test on the
@@ -69,10 +69,9 @@ export interface MergeManagedHookOptions {
    * Per-HANDLER salvage for an entry `isManaged` claimed. Given an OWNED entry, return it rebuilt
    * from only the handlers that are NOT ours, or `null` when every handler was ours.
    *
-   * Optional, and absent means the historical whole-entry behaviour — the Claude path passes
-   * nothing and is byte-identical to before (AM-3). The Codex path passes it because attribution at
-   * matcher-group granularity deleted a foreign handler that merely shared a group with dz's
-   * (independent review, finding 6).
+   * Optional, and absent means the historical whole-entry behaviour. Both live registry paths pass
+   * it because attribution at matcher-group granularity would delete a foreign handler that merely
+   * shared a group with dz's (Codex finding 6; Claude delivery review round 19).
    */
   readonly retainForeign?: (entry: ManagedHookEntry, event: string) => ManagedHookEntry | null;
   /** e.g. `'agentdb'` → `merged agentdb hooks (user hooks preserved)`. */

package/src/model-recommender.ts

@@ -54,8 +54,12 @@ const RULE_TEXT =
 
 /** `codex:gpt-5.5:xhigh (usage-switched)` → `gpt-5.5`; claude ids pass through; unknown → null. */
 export function normalizeModelId(raw: unknown): string | null {
-  if (typeof raw !== 'string' || raw === '') return null;
-  let id = raw.replace(/ \(usage-switched\)$/, '').trim();
+  if (typeof raw !== 'string' || raw.trim() === '') return null;
+  // ОБРЕЗКА ИДЁТ ПЕРВОЙ. Прежде метка снималась якорем `$` по СЫРОЙ строке, и один хвостовой
+  // пробел — `codex:gpt-5.5:xhigh (usage-switched) ` — делал весь образец неопознанным (null),
+  // то есть телеметрия молча теряла запись. ИЗМЕРЕНО 2026-09-04: без пробела «gpt-5.5», с
+  // пробелом null.
+  let id = raw.trim().replace(/\s*\(usage-switched\)$/, '').trim();
   const codex = /^codex:([^:]+)(?::[a-z]+)?$/.exec(id);
   if (codex !== null) id = codex[1]!;
   return COST_LADDER.some((r) => r.id === id) ? id : null;
@@ -94,7 +98,14 @@ export function harvestStageOutcomes(records: readonly unknown[]): Harvest {
     if (grade === null) { skipped.noGrade += 1; continue; }
     // Full canonical JSON is intentional: the former 40-character prefix merged distinct records
     // whose stage names shared a long prefix, manufacturing idempotency across different runs.
-    const runId = typeof source['runId'] === 'string' ? source['runId'] : `models:${JSON.stringify(modelsUsed)}`;
+    // ПУСТОЙ runId — НЕ ИДЕНТИФИКАТОР. Прежде проверка была `typeof === 'string'`, и пустая строка
+    // принималась: ВСЕ такие записи схлопывались в один «прогон», а число прогонов и признак
+    // «скормлено» считались по нему. Отсутствующий и пустой теперь одинаково уходят на запасной
+    // ключ по составу моделей.
+    const rawRunId = source['runId'];
+    const runId = typeof rawRunId === 'string' && rawRunId.trim() !== ''
+      ? rawRunId.trim()
+      : `models:${JSON.stringify(modelsUsed)}`;
     const ts = typeof source['timestamp'] === 'string' ? source['timestamp'] : null;
     const tier = typeof result['tier'] === 'string' && result['tier'] !== '' ? result['tier'] : 'unknown';
     let contributed = false;

package/src/mutation-gate.ts

@@ -108,6 +108,10 @@ export interface MutationObservation {
   readonly rebaselineExitCode?: number | null;
   /** named no-exit reason for the restored-tree attribution run, when it produced none. */
   readonly rebaselineFailureReason?: string;
+  /** parsed failing files from a RED restored-tree run; absent when no red rebaseline ran. */
+  readonly rebaselineAttribution?: BaselineAttribution;
+  /** bounded log proving an internal runner failure received at most one retry. */
+  readonly internalAttemptLog?: string;
 }
 
 export interface MutationEntryResult {
@@ -135,6 +139,60 @@ export interface MutationEntryResult {
   readonly detail: string;
 }
 
+// ── Internal runner crash containment — exactly one retry, both attempts observable ───────────
+
+export type InternalRunnerAttemptOutcome = 'completed' | 'runner-internal-error';
+
+export interface InternalRunnerAttempt {
+  readonly attempt: 1 | 2;
+  readonly outcome: InternalRunnerAttemptOutcome;
+  readonly detail: string;
+}
+
+export interface InternalRunnerRetryResult<T> {
+  /** The completed attempt's value. null means both attempts threw internally. */
+  readonly value: T | null;
+  readonly attempts: readonly InternalRunnerAttempt[];
+  /** Closed by construction: a runner receives either zero retries or exactly one. */
+  readonly internalRetries: 0 | 1;
+  /** Named reason consumed by the existing no-exit → INCONCLUSIVE arm. */
+  readonly failureReason?: `runner-internal-error: ${string}`;
+}
+
+function internalRunnerErrorHead(error: unknown): string {
+  const raw = error instanceof Error ? error.message : String(error);
+  const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() || 'unknown internal runner error';
+  return Array.from(firstLine).slice(0, 160).join('');
+}
+
+/**
+ * Run one internal runner invocation. Only a THROWN internal error is retried; normal green/red
+ * observations and ordinary no-exit observations are values and therefore never retried.
+ */
+export function runWithOneInternalRetry<T>(runner: () => T): InternalRunnerRetryResult<T> {
+  const attempts: InternalRunnerAttempt[] = [];
+  for (const attempt of [1, 2] as const) {
+    try {
+      const value = runner();
+      attempts.push({ attempt, outcome: 'completed', detail: `attempt ${attempt}: completed` });
+      return { value, attempts, internalRetries: attempt === 1 ? 0 : 1 };
+    } catch (error) {
+      const head = internalRunnerErrorHead(error);
+      attempts.push({
+        attempt,
+        outcome: 'runner-internal-error',
+        detail: `attempt ${attempt}: runner-internal-error: ${head}`,
+      });
+    }
+  }
+  return {
+    value: null,
+    attempts,
+    internalRetries: 1,
+    failureReason: 'runner-internal-error: persistent after 2/2 attempts',
+  };
+}
+
 // ── Registry parsing — declarative DATA, validated loudly ─────────────────────────────────────
 
 const SAFE_ID = /^[a-z0-9][a-z0-9-]{0,79}$/;
@@ -495,21 +553,114 @@ export function classifyRunFailure(rawOutput: string): RunFailureClassification
 
 // ── Baseline (rule 3's runnability half) ──────────────────────────────────────────────────────
 
+export type BaselineAttributionSource = 'node-test' | 'vitest' | 'unparseable';
+
+export interface BaselineAttribution {
+  readonly parsedFrom: BaselineAttributionSource;
+  /** Package-relative failing paths, in first-seen order. */
+  readonly failingFiles: readonly string[];
+  /** Failing paths that match a registry file exactly (or by package-relative suffix). */
+  readonly covered: readonly string[];
+  /** Failing paths with no matching registry file. */
+  readonly extraneous: readonly string[];
+}
+
+function normaliseReportedFile(raw: string): string | null {
+  let value = raw.trim().replace(/^['"]|['"]$/g, '').replace(/:\d+(?::\d+)?$/, '');
+  value = value.replace(/\\/g, '/');
+  const testSegment = value.lastIndexOf('/test/');
+  if (testSegment >= 0) value = value.slice(testSegment + 1);
+  if (!value.includes('/') || !/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(value)) return null;
+  return value;
+}
+
+/** Parse the failing FILE paths already exposed by supported node --test and vitest shapes. */
+export function attributeBaselineRedness(
+  rawOutput: string,
+  registryFiles: readonly string[],
+): BaselineAttribution {
+  const output = stripSgr(rawOutput);
+  const files: string[] = [];
+  const add = (raw: string): void => {
+    const file = normaliseReportedFile(raw);
+    if (file !== null && !files.includes(file)) files.push(file);
+  };
+
+  const vitestMatches = [...output.matchAll(/^\s*FAIL\s+(\S+)/gm)];
+  for (const match of vitestMatches) add(match[1] ?? '');
+
+  const tapMatches = [...output.matchAll(/^not ok \d+\s+-\s+(.+)$/gm)];
+  for (const match of tapMatches) add(match[1] ?? '');
+  for (const match of output.matchAll(/^\s*location:\s*['"]([^'"]+)['"]\s*$/gm)) {
+    add(match[1] ?? '');
+  }
+
+  const parsedFrom: BaselineAttributionSource = files.length === 0
+    ? 'unparseable'
+    : vitestMatches.length > 0 ? 'vitest' : 'node-test';
+  if (parsedFrom === 'unparseable') {
+    return { parsedFrom, failingFiles: [], covered: [], extraneous: [] };
+  }
+
+  const normalisedRegistry = registryFiles
+    .map((file) => normaliseReportedFile(file) ?? file.replace(/\\/g, '/'));
+  const covered = files.filter((file) => normalisedRegistry.some((registryFile) =>
+    file === registryFile || file.endsWith(`/${registryFile}`) || registryFile.endsWith(`/${file}`)));
+  const extraneous = files.filter((file) => !covered.includes(file));
+  return { parsedFrom, failingFiles: files, covered, extraneous };
+}
+
+export type BaselineFailureReason =
+  | 'runner-internal-error'
+  | 'runner-no-exit'
+  | 'extraneous-red-in-allowlist'
+  | 'baseline-red-covered-files'
+  | 'baseline-red-files-unparseable';
+
 export interface BaselineResult {
   readonly ok: boolean;
   readonly detail: string;
+  readonly reason?: BaselineFailureReason;
 }
 
 /**
  * A RED baseline in the scratch copy is a SETUP error, never a mutation result: every subsequent
  * "red under mutation" would be noise, and every "green" a lie about an unrunnable copy.
  */
-export function classifyBaseline(exitCode: number | null, runFailureReason?: string): BaselineResult {
+export function classifyBaseline(
+  exitCode: number | null,
+  runFailureReason?: string,
+  attribution?: BaselineAttribution,
+): BaselineResult {
   if (exitCode === 0) return { ok: true, detail: 'baseline suite green in the scratch copy' };
   if (exitCode === null) {
-    return { ok: false, detail: `baseline suite produced no exit code (${runFailureReason ?? 'unknown timeout/spawn failure'}) — the copy is not runnable; fix the copy, do not read this as a mutation result` };
+    const internal = runFailureReason?.startsWith('runner-internal-error:') === true;
+    return {
+      ok: false,
+      reason: internal ? 'runner-internal-error' : 'runner-no-exit',
+      detail: `baseline INCONCLUSIVE — suite produced no exit code (${runFailureReason ?? 'unknown timeout/spawn failure'}) — the copy is not runnable; do not read this as a mutation result`,
+    };
   }
-  return { ok: false, detail: `baseline suite RED (exit ${exitCode}) in the UNMUTATED scratch copy — a broken copy cannot prove anything; fix the copy (node_modules link? path-dependent test?) before trusting any verdict` };
+  if (attribution === undefined || attribution.parsedFrom === 'unparseable') {
+    return {
+      ok: false,
+      reason: 'baseline-red-files-unparseable',
+      detail: `baseline suite RED (exit ${exitCode}) in the UNMUTATED scratch copy — failing files: unparseable from runner output — the broken copy cannot prove anything`,
+    };
+  }
+  const failing = `failing files: ${attribution.failingFiles.join(', ')}`;
+  if (attribution.extraneous.length > 0 && attribution.covered.length === 0) {
+    return {
+      ok: false,
+      reason: 'extraneous-red-in-allowlist',
+      detail: `baseline suite RED (exit ${exitCode}) in the UNMUTATED scratch copy — ${failing} — extraneous red in the testCommand allowlist; the registry entries themselves are not disproven`,
+    };
+  }
+  return {
+    ok: false,
+    reason: 'baseline-red-covered-files',
+    detail: `baseline suite RED (exit ${exitCode}) in the UNMUTATED scratch copy — ${failing} — broken-copy baseline redness touches registry-covered files; fix the copy before evaluating mutations`,
+  };
 }
 
 // ── Classification (rules 1 + 2, and the drop decision) ───────────────────────────────────────
@@ -549,7 +700,7 @@ export function classifyBaseline(exitCode: number | null, runFailureReason?: str
  *     while the contract still holds is the early warning, reported loudly so a human re-pins
  *     `observed` or investigates — silently normalising it would erase the signal.
  */
-export function classifyMutationOutcome(obs: MutationObservation): MutationEntryResult {
+function classifyMutationOutcomeWithoutAttemptLog(obs: MutationObservation): MutationEntryResult {
   const e = obs.entry;
   const minFailing = e.minFailing ?? 1;
   const base = {
@@ -653,12 +804,15 @@ export function classifyMutationOutcome(obs: MutationObservation): MutationEntry
   // not come back green, so the suite is flaky and an unrelated neighbour may be what went red.
   // Not attributable ⇒ INCONCLUSIVE (a failure, never a pass).
   if (obs.rebaselineExitCode !== undefined && obs.rebaselineExitCode !== 0) {
+    const failing = obs.rebaselineAttribution === undefined || obs.rebaselineAttribution.parsedFrom === 'unparseable'
+      ? 'failing files: unparseable from runner output'
+      : `failing files: ${obs.rebaselineAttribution.failingFiles.join(', ')}`;
     return {
       ...base,
       applied: true,
       verdict: 'INCONCLUSIVE',
       drop: false,
-      detail: `suite red under the mutation BUT the restored baseline did not reproduce green (${obs.rebaselineExitCode === null ? `no exit code: ${obs.rebaselineFailureReason ?? 'unknown timeout / spawn failure'}` : `exit ${obs.rebaselineExitCode}`}) — the suite is flaky; the redness is not attributable to the protection and may be an unrelated neighbour`,
+      detail: `suite red under the mutation BUT the restored baseline did not reproduce green (${obs.rebaselineExitCode === null ? `no exit code: ${obs.rebaselineFailureReason ?? 'unknown timeout / spawn failure'}` : `exit ${obs.rebaselineExitCode}`}) — mutation did not revert / flaky restored-tree route; ${failing}; the redness is not attributable to the protection`,
     };
   }
 
@@ -698,6 +852,12 @@ export function classifyMutationOutcome(obs: MutationObservation): MutationEntry
   };
 }
 
+export function classifyMutationOutcome(obs: MutationObservation): MutationEntryResult {
+  const result = classifyMutationOutcomeWithoutAttemptLog(obs);
+  if (obs.internalAttemptLog === undefined) return result;
+  return { ...result, detail: `${result.detail}; ${obs.internalAttemptLog}` };
+}
+
 /** Verdicts that fail the gate. INCONCLUSIVE and NOT_APPLIED fail (inconclusive ≠ pass). */
 const FAILING_VERDICTS: ReadonlySet<MutationVerdict> = new Set(['UNDEFENDED', 'RECEIPT_MISMATCH', 'NOT_APPLIED', 'BELOW_MIN', 'MUTATION_UNPARSEABLE', 'MUTATION_LOAD_FATAL', 'OVER_FAILING', 'INCONCLUSIVE']);
 

package/src/operations.ts

@@ -169,6 +169,26 @@ export interface InitReport {
 // Platform enrichment — optional extras beyond SKILL.md
 // ---------------------------------------------------------------------------
 
+/**
+ * Размер RVF-файла, при котором в нём заведомо НЕТ ни одной записи.
+ *
+ * ИЗМЕРЕНО 2026-09-04 прямым прогоном на `@ruvector/rvf-node` 0.1.8 (linux-x64): пустое хранилище —
+ * РОВНО 162 байта при любой размерности; первая запись доводит файл до 615 байт при размерности 8,
+ * 839 при 64, 2119 при 384 и 6727 при 1536. Порог 200 — небольшой запас над измеренным пустым
+ * размером: он покрывает возможный чуть больший заголовок и втрое ниже самого маленького
+ * наблюдавшегося хранилища С записью.
+ *
+ * ПОПРАВКА К ПЕРВОЙ РЕДАКЦИИ (ревью 2026-09-04). Здесь стояло «первая запись добавляет ~1550 байт»
+ * и «порог — середина измеренного зазора». Оба утверждения неверны: 1550 нигде не измерялось, а
+ * серединой зазора [162, 2119] было бы 1140, не 200. Строгое на вид обоснование опиралось на
+ * арифметическую ошибку в собственных числах документа.
+ *
+ * Оговорка «при меньшей размерности запись могла бы уместиться в зазор» тоже СНЯТА как
+ * неизмеренная: замер по четырём размерностям показывает обратное — даже при размерности 8
+ * хранилище с записью втрое больше порога.
+ */
+const RVF_HEADER_ONLY_MAX_BYTES = 200;
+
 /**
  * Where each target's skill tree is rooted. These MUST agree with the
  * `skillsRoot` each adapter actually emits to — so we import the adapters'
@@ -1187,6 +1207,61 @@ export async function runDoctor(options: { projectRoot: string }): Promise<Docto
       detail: 'orphan .dz/memory.rvf placeholder from an old setup (nothing reads it) — delete it; the real store is .dz/agentdb.db',
     });
   }
+  // 8y. ПУСТОЕ ВЕКТОРНОЕ ХРАНИЛИЩЕ МОЛЧИТ, А НЕ ЖАЛУЕТСЯ (решение владельца 2026-09-04).
+  //
+  // Пустой RVF-файл не даёт ошибки: поиск по нему возвращает пустой список, и всё выглядит
+  // работающим. ИЗМЕРЕНО 2026-09-04: `.agentic-qe/patterns.rvf` — 162 байта (записей не помещается)
+  // при 288 паттернах и 275 векторах, целых в `.agentic-qe/memory.db` рядом. Подробности,
+  // измерения и названные пределы — features/doctor-empty-vector-store/01_requirements.md.
+  //
+  // ПОЧЕМУ ПО РАЗМЕРУ, А НЕ ПО ЧИСЛУ ВЕКТОРОВ. Единственная причина — не потревожить наблюдение:
+  // идёт семидневный замер «читает ли этот файл хоть кто-нибудь», а открытие сдвигает время
+  // последнего чтения. Прежняя редакция называла второй причиной файловый замок — ЭТО ОПРОВЕРГНУТО
+  // ревью экспериментально: `openReadonly` под живым замком открывает хранилище, не создаёт `.lock`
+  // и не меняет ни размер, ни mtime. Ложное обоснование убрано, верное оставлено.
+  //
+  // ЧТО ДОКАЗЫВАЕТ РАЗМЕР: ровно «записей тут поместиться не может». НЕ доказывает, что файл —
+  // валидный заголовок формата: пустой, обрезанный или посторонний файл с тем же расширением
+  // попадёт в ту же ветку, поэтому текст находки говорит про размер и следствие.
+  //
+  // ОБЛАСТЬ — ТРИ ИЗВЕСТНЫХ КАТАЛОГА ХРАНИЛИЩ, без рекурсии. `.dz/memory` добавлен по находке
+  // ревью: собственное RVF-хранилище dz лежит именно там (vector-tier.ts), и без него ветка `.dz`
+  // покрывала только legacy-заглушку, то есть была декоративной. Рекурсия по дереву не делается:
+  // она нашла бы десятки копий в `.claude/worktrees/agent-*/`, и отчёт утонул бы в шуме.
+  for (const dir of ['.agentic-qe', '.dz', '.dz/memory']) {
+    let names: string[] = [];
+    try {
+      names = readdirSync(join(root, dir)).filter((n) => n.endsWith('.rvf'));
+    } catch { continue; } // каталога нет — проверять нечего, и это не находка
+    for (const name of names) {
+      // `.dz/memory.rvf` уже разобран проверкой выше как legacy-сирота с советом «удалить».
+      // Вторая находка на тот же файл советовала бы искать держателя у файла, который никто не
+      // читает — два совета об одном объекте, и один из них бессмысленный (находка ревью).
+      if (dir === '.dz' && name === 'memory.rvf') continue;
+      let size: number;
+      try {
+        const st = statSync(join(root, dir, name));
+        // Каталог с таким именем — не хранилище; `isFile` дешевле и честнее, чем гадать по размеру.
+        if (!st.isFile()) continue;
+        size = st.size;
+      } catch { continue; } // нечитаемый или исчезнувший файл — не находка: мы про него ничего не установили
+      if (size > RVF_HEADER_ONLY_MAX_BYTES) continue;
+      // СООБЩЕНИЕ, А НЕ ПРОВАЛ. Проверка не умеет отличить испорченное хранилище от только что
+      // созданного, в которое ещё ничего не писали, — а это здоровое состояние первого дня. Ронять
+      // код возврата на здоровом состоянии значит приучить читателя к красному; соседняя проверка
+      // целостности в этой же функции решает ту же дилемму так же и говорит об этом вслух.
+      checks.push({
+        name: 'vector store',
+        ok: true,
+        detail: `${dir}/${name} — ${size} bytes: too small to hold a single record, so a search `
+          + 'over it returns an empty answer instead of an error, and nothing looks broken. '
+          + 'Size alone does not say WHY: an empty store, a truncated file, or not a store at all. '
+          + 'If this project HAS learned patterns, the store is behind — compare with the SQLite '
+          + 'store beside it before deciding.',
+      });
+    }
+  }
+
   const legacyMcp = join(root, '.claude', 'mcp.json');
   if (existsSync(legacyMcp) && readFileSync(legacyMcp, 'utf-8').includes('agentdb')) {
     checks.push({
@@ -1383,9 +1458,12 @@ export async function runDoctor(options: { projectRoot: string }): Promise<Docto
   // Silent when a log is absent or has never been chained: an unchained file is legal (FR-5), not a
   // fault, and reporting it would train the reader to ignore this line.
   try {
-    const { verifyEventChainText, classifyChainDefects, EVENT_CHAIN_SCOPE } = await import('./event-chain.js');
-    for (const rel of ['recall-usage.jsonl', 'guard-audit.jsonl']) {
-      const p = join(root, '.dz', rel);
+    const { verifyEventChainText, classifyChainDefects, EVENT_CHAIN_SCOPE, CHAINED_JOURNALS } = await import('./event-chain.js');
+    // W0-chain (bc4ee35c): enumerated from THE registry, never from a list kept here. The inline
+    // array this replaces is why a journal could be given a chain and still be checked by nobody —
+    // the mechanism present, the coverage absent, and no red anywhere to say so.
+    for (const journal of CHAINED_JOURNALS) {
+      const p = join(root, journal.rel);
       if (!existsSync(p)) continue;
       const text = readFileSync(p, 'utf-8');
       const v = verifyEventChainText(text);
@@ -1400,7 +1478,7 @@ export async function runDoctor(options: { projectRoot: string }): Promise<Docto
       // file and false of the present, and a red nobody can act on is a red nobody reads.
       if (age.inRun.length === 0 && age.runRecords > 0) {
         checks.push({
-          name: `evidence chain (.dz/${rel})`,
+          name: `evidence chain (${journal.rel})`,
           ok: true,
           // The COUNT carries the meaning, and is printed first for that reason: "1 record forms an
           // unbroken run" is true and says almost nothing, while 998 says a great deal. Naming the
@@ -1413,7 +1491,7 @@ export async function runDoctor(options: { projectRoot: string }): Promise<Docto
         continue;
       }
       checks.push({
-        name: `evidence chain (.dz/${rel})`,
+        name: `evidence chain (${journal.rel})`,
         ok: false,
         detail: `${named} — with NO sound records after them: learning verdicts computed from this log are unsafe. Scope: ${EVENT_CHAIN_SCOPE}`,
       });

package/src/patterns.ts

@@ -60,6 +60,29 @@ export interface PatternRecord {
   readonly lessonPairId?: string;
   /** Read-model companion; derived from the linked class row, never persisted on this row. */
   readonly classForm?: string;
+  /**
+   * Address of this record IN THE STORE IT CAME FROM — `MemoryRecord.id`, carried so that
+   * `dz recall --forget` / `--promote` can be driven from `dz recall --all --json`, which their own
+   * help text already tells the reader to use. Deriving it instead is the trap `cmdRecallForget`
+   * already warns about: MEASURED on this store, `patternRecordId(recordToPattern(r))` reproduces
+   * the id for 535 of 537 records and hands a plausible WRONG address for the other two (a
+   * `dream:`-written row and one on an older scheme) — and a wrong id makes `--forget` report
+   * success while deleting nothing. So the id travels rather than being recomputed.
+   *
+   * VALID ONLY IN THE ISSUING STORE. `dz teach --from-json` must never adopt it: an id names a
+   * DIFFERENT record on the receiving machine, so an adopted id would point `--forget` at the wrong
+   * lesson. The importer builds its candidate from named fields (never a spread), and a test pins
+   * that — the property is what keeps the portable export safe to accept from anyone.
+   */
+  readonly dzId?: string;
+  /**
+   * Quarantine marker (feature lesson-quarantine): the lesson is a HYPOTHESIS, not knowledge.
+   * Present ONLY when true — absence means promoted, matching `readQuarantineState`'s AM-1
+   * fail-safe, so a missing field is never read as a claim about the record. Carried because
+   * `--promote` addresses exactly the quarantined rows and had no way to name them from an export.
+   * Like `dzId`, it is a fact about the ISSUING store and is not adopted on import.
+   */
+  readonly quarantined?: boolean;
 }
 
 /** A session lifecycle event as written by the session hooks to `.dz/sessions.jsonl`. */
@@ -498,6 +521,15 @@ export function recordToPattern(r: MemoryRecord): PatternRecord {
     && typeof lessonPairId === 'string' && lessonPairId !== ''
     ? { lessonForm, lessonPairId }
     : {};
+  // The id and the quarantine marker travel with the row. Both are facts about THIS store, and
+  // both were previously dropped here — the single place the whole `--all --json` export is built
+  // (`loadStorePatternsSync` = `loadStoreRecordsSync().map(recordToPattern)`), which is why
+  // `--forget`'s own "find them with `dz recall --all --json`" hint pointed at a file that could
+  // not answer. `quarantined` is emitted only when true, so absence keeps meaning "promoted".
+  const addressing: { dzId?: string; quarantined?: boolean } = {
+    ...(typeof r.id === 'string' && r.id !== '' ? { dzId: r.id } : {}),
+    ...(readQuarantineState(r).quarantined ? { quarantined: true } : {}),
+  };
   return {
     pattern: r.text,
     type: PATTERN_TYPES.has(r.outcome) ? (r.outcome as PatternRecord['type']) : 'lesson-learned',
@@ -506,6 +538,7 @@ export function recordToPattern(r: MemoryRecord): PatternRecord {
     ts: r.timestamp,
     source: r.metadata?.['source'] ?? 'dz-teach',
     ...pair,
+    ...addressing,
   };
 }
 

package/src/plugin.ts

@@ -27,6 +27,13 @@ export interface PluginManifest {
   readonly skills: readonly string[];
 }
 
+/** id→path index built from the registry, so the generator never guesses a layout. */
+function skillPathIndex(registry: { entries: readonly { id: string; pack: string; path?: string }[] }): Map<string, string> {
+  const m = new Map<string, string>();
+  for (const e of registry.entries) if (e.path !== undefined && e.path !== '') m.set(`${e.pack}/${e.id}`, e.path);
+  return m;
+}
+
 /** Generate .claude-plugin/ directory from registry. */
 export function generatePlugin(
   projectRoot: string,
@@ -61,16 +68,26 @@ export function generatePlugin(
   };
 
   const skillPacks = [...packMap.entries()].map(([name, count]) => ({
+    // `pack` is the REAL directory name; `name` is only the display short form. Deriving the key
+    // back by re-adding the `skills-` prefix broke the moment the catalogue learned packs that
+    // never had one (health-advisor, keysarium, …): the lookup missed and their entries listed
+    // zero skills.
+    pack: name,
     name: name.replace('skills-', ''),
     skills: count,
     description: packDescriptions[name] ?? `${count} skills`,
   }));
 
+  const pathById = skillPathIndex(registry);
+
   // Explicit skill paths for the full-suite plugin (source `./`): every skill
   // dir across every pack, relative to the repo root. This is what makes
   // `claude plugin details` report the real skill count instead of 0.
   const allSkillPaths = [...packSkillIds.entries()]
-    .flatMap(([pack, ids]) => ids.map((id) => `packages/@dzhechkov/${pack}/${id}`))
+    // Prefer the path the catalogue recorded; `<pack>/<id>` is only a fallback for entries built
+    // before the field existed. Reconstructing it is what produced unresolvable paths for skills
+    // that live under `skills/` or `templates/.claude/skills/`.
+    .flatMap(([pack, ids]) => ids.map((id) => pathById.get(`${pack}/${id}`) ?? `packages/@dzhechkov/${pack}/${id}`))
     .sort();
 
   const pluginJson = {
@@ -103,12 +120,17 @@ export function generatePlugin(
       ...skillPacks.map((pack) => ({
         name: `dz-${pack.name}`,
         displayName: `DZ ${pack.name.charAt(0).toUpperCase() + pack.name.slice(1)} Skills`,
-        source: `packages/@dzhechkov/skills-${pack.name}`,
+        source: `packages/@dzhechkov/${pack.pack}`,
         description: `${pack.skills} ${pack.name} skills — ${pack.description}`,
         keywords: [pack.name],
-        // Skill dirs sit at the pack source root, so they are listed relative
-        // to `source` here (`./<id>`) — required for Claude Code to discover them.
-        skills: (packSkillIds.get(`skills-${pack.name}`) ?? []).slice().sort().map((id) => `./${id}`),
+        // Listed relative to `source` — required for Claude Code to discover them. The path comes
+        // from the catalogue rather than from the assumption "skill dirs sit at the pack root",
+        // which holds for `skills-*` packs and for neither of the two other layouts.
+        skills: (packSkillIds.get(pack.pack) ?? []).slice().sort().map((id) => {
+          const full = pathById.get(`${pack.pack}/${id}`);
+          const base = `packages/@dzhechkov/${pack.pack}/`;
+          return full !== undefined && full.startsWith(base) ? `./${full.slice(base.length)}` : `./${id}`;
+        }),
       })),
     ],
   };