@dzhechkov/harness-core 0.8.11 → 0.8.21

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({

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/publish.ts

@@ -27,6 +27,17 @@ export interface PublishResult {
    * unmodified `publishPackages` call is byte-compatible with pre-gate behavior.
    */
   readonly claimCheck?: { readonly findings: number; readonly high: number } | undefined;
+  /**
+   * DRY-RUN ONLY, and the reason it exists is a measured incident. A dry run short-circuits
+   * BEFORE build, sign and pack (see the `opts.dryRun` branch below), so the package's own
+   * `prepublishOnly` gate never executes. On 2026-09-02 a clean dry run was read as evidence that
+   * publication would succeed; the real gate was RED — a stale signature baseline plus six
+   * `__pycache__/*.pyc` files already signed into the manifest. A preview that names only what it
+   * DID check reads as a pass for everything it skipped, which is the same failure class as a gate
+   * that infers success from silence. So a dry-run result carries the list of gates it did NOT run,
+   * and the CLI prints it. Absent on a real publish, where every gate actually ran.
+   */
+  readonly notVerified?: readonly string[] | undefined;
 }
 
 /** Full publish report. */
@@ -630,8 +641,22 @@ export function publishPackages(
     }
 
     if (opts.dryRun) {
-      results.push({ name: pkg.name, oldVersion, newVersion, status: 'skipped', claimCheck: claimCheckSummary });
-      landedInBatch.add(pkg.name); // preview: this package passed its gates and WOULD land
+      // NOT a statement that the package would publish cleanly — only that the gates checked ABOVE
+      // this line passed. Everything below it (build, re-sign, pack, the package's own
+      // `prepublishOnly`, the registry itself) is untouched by a dry run and is named as such.
+      const NOT_VERIFIED_BY_DRY_RUN = Object.freeze([
+        'prepublishOnly пакета (его собственный гейт публикации)',
+        'сборка dist из исходников',
+        'пере-подпись манифеста после бампа',
+        'содержимое тарбола (npm pack)',
+        'ответ реестра npm',
+      ]);
+      results.push({
+        name: pkg.name, oldVersion, newVersion, status: 'skipped',
+        claimCheck: claimCheckSummary,
+        notVerified: NOT_VERIFIED_BY_DRY_RUN,
+      });
+      landedInBatch.add(pkg.name);
       continue;
     }
 

package/src/registry.ts

@@ -363,8 +363,9 @@ function categoryFromPack(pack: string): string {
   // digitizer outputs like `skills-12factor` (The Twelve-Factor App). Future digitized public packs
   // (e.g. AOSA) should be added here or carry a `book`/digitized marker.
   if (pack.includes('book') || pack.includes('12factor')) return 'knowledge';
-  // Course/tutorial manufacturing (skills-tutorial-factory: package → Head-First edu-site course).
-  if (pack.includes('tutorial')) return 'learning';
+  // Learning and demo-site manufacturing: tutorial packs teach; the demo publisher records a
+  // product journey and emits a Pages-ready explanatory site.
+  if (pack.includes('tutorial') || pack.includes('demo-publisher')) return 'learning';
   // Packs that carry skills without the `skills-` prefix, catalogued since 2026-09-01. Each needs a
   // category or it lands in `other`, and a test rightly forbids that bucket: an uncategorised skill
   // cannot be filtered for, which is half of being findable.

package/src/score.ts

@@ -20,6 +20,8 @@
  * PURE: the CLI reads the artifact files; this module only classifies.
  */
 
+import { amendmentIdsIn } from './amendment-trace.js';
+
 export type DisciplineVerdict = 'pass' | 'partial' | 'absent';
 
 export interface DisciplineScore {
@@ -524,11 +526,21 @@ export function scoreRun(slug: string, artifacts: RunArtifacts): RunScorecard {
   // 7. Amendment confirmation — only when amendments EXIST; their absence is not a failure.
   //    Born in the PLAN/ideation: a stray "AM-7" in QE prose (e.g. another feature's test name)
   //    must not conjure the discipline (caught by the very first dogfood run).
-  const plannedAm = [...new Set(planText.match(/AM-\d+/g) ?? [])].sort();
+  // ONE reader of the `AM-*` token, shared with the row grammar and pinned against K2's by
+  // test/amendment-grammar-agreement.test.ts. It used to be a THIRD private contract here —
+  // `/AM-\d+/g`, which does not match `AM-CP-1` at all (MEASURED 2026-09-06:
+  // `'AM-CP-1'.match(/AM-\d+/g)` → `null`), so a plan whose amendments were all challenge-panel
+  // rows scored `plannedAm = []` and this whole discipline was skipped silently — no `absent`, no
+  // `partial`, just a smaller denominator. A check that silently checks nothing is the class the
+  // amendment gate exists to remove, and it had reappeared in the scorer.
+  const plannedAm = amendmentIdsIn(planText).sort();
   if (plannedAm.length > 0) {
-    // One stray AM-9 in QE must not satisfy AM-1..AM-2 (Codex QE #3): coverage is id-by-id.
-    const covered = plannedAm.filter((id) => qeText.includes(id));
-    const missing = plannedAm.filter((id) => !qeText.includes(id));
+    // One stray AM-9 in QE must not satisfy AM-1..AM-2 (Codex QE #3): coverage is id-by-id — and
+    // `includes` was not id-by-id: a planned `AM-1` read as covered by a report mentioning only
+    // `AM-10` (MEASURED — `'AM-10'.includes('AM-1')` → `true`). A substring is not an id.
+    const mentionedInQe = new Set(amendmentIdsIn(qeText));
+    const covered = plannedAm.filter((id) => mentionedInQe.has(id));
+    const missing = plannedAm.filter((id) => !mentionedInQe.has(id));
     add(
       'amendment-confirmation',
       'amendments carried into QE with confirmation',