@dzhechkov/harness-core 0.8.39 → 0.8.41

package/src/store-lock.ts

@@ -57,7 +57,7 @@
  * one is honoured as held, same as any other lock.
  */
 
-import { mkdirSync, rmSync, statSync } from 'node:fs';
+import { existsSync, rmSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { lockSync } from 'proper-lockfile';
 
@@ -71,6 +71,23 @@ const MIN_STALE_MS = 2_000;
 /** Highest accepted environment override; keeps proper-lockfile's heartbeat timer in range. */
 const MAX_STALE_MS = 600_000;
 
+/** A store exists exactly when the project's .dz entry exists. */
+export function storeExists(projectRoot: string): boolean {
+  return existsSync(join(projectRoot, '.dz'));
+}
+
+/** Refusing a store-scoped lock must never seed a store. */
+export class StoreAbsentError extends Error {
+  readonly code = 'ESTOREABSENT';
+  constructor(readonly root: string, readonly lock: string) {
+    super(
+      `no store at ${root} — the lock ${lock} was not taken and nothing was created; ` +
+      'run `dz init` there, or pass --project <the real project root>',
+    );
+    this.name = 'StoreAbsentError';
+  }
+}
+
 /** Path of the lock guarding a project's pattern store (a DIRECTORY when held). */
 export function storeLockPath(projectRoot: string): string {
   return join(projectRoot, '.dz', 'store.lock');
@@ -201,8 +218,8 @@ export async function withStoreLock<T>(
   fn: () => Promise<T>,
   opts: StoreLockOptions = {},
 ): Promise<T> {
+  if (!storeExists(projectRoot)) throw new StoreAbsentError(projectRoot, 'store');
   const { staleMs, timeoutMs, pollMs } = resolveOpts(opts);
-  mkdirSync(join(projectRoot, '.dz'), { recursive: true });
   const started = Date.now();
   const deadline = started + timeoutMs;
   let compromised: Error | undefined;
@@ -240,8 +257,8 @@ export function withStoreLockSync<T>(
   fn: () => T,
   opts: StoreLockOptions = {},
 ): T {
+  if (!storeExists(projectRoot)) throw new StoreAbsentError(projectRoot, 'store');
   const { staleMs, timeoutMs, pollMs } = resolveOpts(opts);
-  mkdirSync(join(projectRoot, '.dz'), { recursive: true });
   const started = Date.now();
   const deadline = started + timeoutMs;
   let compromised: Error | undefined;

package/src/test-receipt.ts

@@ -0,0 +1,106 @@
+/**
+ * Квитанция зелёного прогона: «эта область исходников была протестирована ИМЕННО в этом виде».
+ *
+ * ЗАЧЕМ ЭТО ЕСТЬ. Два процессных грабля повторялись месяцами и повторились снова 21.09 ПОСЛЕ того,
+ * как напоминание о них было поднято: «объявил сделанным без проверки» (пять случаев) и «коммит без
+ * прогона тестов» (шесть). Напоминание — слой суждения, и он молчит, когда отказывает. Владелец
+ * согласился поднять проверку на слой 1, но с условием: коммиты должны остаться дешёвыми. Поэтому
+ * проверка стоит не на коммите, а на ПУШЕ, и спрашивает не «прогони тесты», а квитанцию.
+ *
+ * ПОЧЕМУ ПО ОБЛАСТЯМ, А НЕ ЦЕЛИКОМ. ИЗМЕРЕНО 21.09: полный прогон набора harness-cli на этой машине
+ * не завершается — надзиратель фоновых задач убивает его по памяти при любом дроблении. Гейт,
+ * требующий квитанцию ПОЛНОГО прогона, заблокировал бы каждый push навсегда. Квитанция покрывает
+ * названные области, и отказ касается только тех, что изменились без покрытия.
+ *
+ * ЧЕГО ЭТА ПРОВЕРКА НЕ ОБЕЩАЕТ, и это сказано здесь, а не в отчёте потом:
+ *  · она не запускает тесты и не знает, ХОРОШИ ли они — только что прогон был и был зелёным;
+ *  · она сравнивает СОДЕРЖИМОЕ рабочего дерева, а не набор пушимых коммитов;
+ *  · она ничего не говорит о коммитах, которые никогда не пушат;
+ *  · зелёный прогон ДРУГОЙ области не покрывает изменённую — это и есть смысл разбиения.
+ */
+
+/** Одна запись журнала квитанций. Пишется ТОЛЬКО наблюдателем, видевшим код возврата 0. */
+export interface TestReceipt {
+  readonly v: 1;
+  /** Когда прогон закончился, ISO-8601. */
+  readonly ts: string;
+  /** Что именно было запущено — для сообщения об отказе, чтобы читатель мог повторить. */
+  readonly command: string;
+  /** Область → отпечаток её содержимого на момент зелёного прогона. */
+  readonly scopes: Readonly<Record<string, string>>;
+}
+
+/** Состояние одной области в вердикте. */
+export interface TestReceiptScopeState {
+  readonly scope: string;
+  /** Отпечаток содержимого СЕЙЧАС. */
+  readonly digest: string;
+  /**
+   * `never` — область не встречается ни в одной квитанции: прогона не было вовсе.
+   * `changed` — квитанции есть, но ни одна не покрывает текущее содержимое.
+   */
+  readonly why: 'never' | 'changed';
+  /** Время самой свежей квитанции, покрывавшей эту область в ЛЮБОМ виде; null при `never`. */
+  readonly lastGreenAt: string | null;
+}
+
+export type TestReceiptVerdict =
+  | { readonly state: 'covered'; readonly scopes: readonly string[] }
+  | { readonly state: 'stale'; readonly uncovered: readonly TestReceiptScopeState[] }
+  | { readonly state: 'not-established'; readonly reason: string };
+
+/**
+ * Чистое решение. Ничего не читает и не запускает — отпечатки и журнал подаёт вызывающий.
+ *
+ * Три исхода, а не два, намеренно: «не установлено» — это НЕ «покрыто». Гейт, выводящий пропуск из
+ * пустого входа, тихо ломается на каждом новом способе получить пустой вход.
+ */
+export function decideTestReceipt(input: {
+  readonly current: Readonly<Record<string, string>>;
+  readonly receipts: readonly TestReceipt[];
+}): TestReceiptVerdict {
+  const current = input.current ?? {};
+  const scopes = Object.keys(current).sort();
+  if (scopes.length === 0) {
+    return { state: 'not-established', reason: 'ни одна наблюдаемая область не разрешилась — проверка была бы вакуумной' };
+  }
+  for (const scope of scopes) {
+    if (typeof current[scope] !== 'string' || current[scope] === '') {
+      return { state: 'not-established', reason: `отпечаток области ${scope} не вычислен — вердикт не о чем выносить` };
+    }
+  }
+
+  const receipts = (Array.isArray(input.receipts) ? input.receipts : []).filter(
+    (r): r is TestReceipt => !!r && typeof r === 'object' && r.scopes !== null && typeof r.scopes === 'object',
+  );
+
+  const uncovered: TestReceiptScopeState[] = [];
+  for (const scope of scopes) {
+    const digest = current[scope]!;
+    let seenAt: string | null = null;
+    let covered = false;
+    for (const receipt of receipts) {
+      const recorded = receipt.scopes[scope];
+      if (typeof recorded !== 'string') continue;
+      if (typeof receipt.ts === 'string' && (seenAt === null || receipt.ts > seenAt)) seenAt = receipt.ts;
+      if (recorded === digest) { covered = true; break; }
+    }
+    if (!covered) uncovered.push({ scope, digest, why: seenAt === null ? 'never' : 'changed', lastGreenAt: seenAt });
+  }
+
+  return uncovered.length === 0 ? { state: 'covered', scopes } : { state: 'stale', uncovered };
+}
+
+/** Одна строка для человека. Отказ обязан говорить, ЧТО запустить, а не только что всё плохо. */
+export function renderTestReceiptVerdict(verdict: TestReceiptVerdict): string {
+  if (verdict.state === 'covered') {
+    return `test-receipt: покрыто — ${verdict.scopes.length} област(и) в том же виде, в каком были зелёными`;
+  }
+  if (verdict.state === 'not-established') {
+    return `test-receipt: НЕ УСТАНОВЛЕНО — ${verdict.reason}. Это не пропуск и не отказ по существу`;
+  }
+  const lines = verdict.uncovered.map((item) => item.why === 'never'
+    ? `  · ${item.scope}: зелёного прогона не было НИ РАЗУ`
+    : `  · ${item.scope}: изменилась после последнего зелёного прогона (${item.lastGreenAt})`);
+  return [`test-receipt: НЕ ПОКРЫТО — ${verdict.uncovered.length} област(и):`, ...lines].join('\n');
+}

package/src/workflow-run.ts

@@ -42,6 +42,7 @@ import {
 import { classifyFailure, errSnap, gateVerdict, joinRegion, stepContractLines, type JoinOutcome } from './loop-run-semantics.js';
 import { checkpointInputHash, decideCheckpointResume, parseCheckpointRead, serializeCheckpoint } from './feature-adr-checkpoints.js';
 import { modelFamily, type BridgeFamily } from './qe-bridge.js';
+import { buildReqeDebt } from './reqe.js';
 import { CODEX_EXEC_XHIGH_TIMEOUT_MS, defangGateEchoes, type DispatchResult, type Dispatcher } from './workflow-run-dispatch.js';
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -1203,19 +1204,17 @@ export async function runWorkflow(inputs: RunnerInputs, pre: PreflightOk, deps:
 
   // a waived same-family QE step owes a machine debt, not a doc instruction (the FR-2.9 precedent)
   for (const w of pre.qeWaivers) {
-    // The FR-2.9 `reqe-due-1` shape VERBATIM (`reqe.ts` parseReqeDebt), because the debt is only
-    // real if `dz reqe` can read it — a record in a shape the reader rejects is a promise, not a
-    // debt. `qeFamily` equals `coderFamily` here: that identity IS the waiver.
-    store.writeReqeDebt({
-      schema: 'reqe-due-1',
+    // Use the shared builder so the waiver stays readable by every debt consumer.
+    store.writeReqeDebt(buildReqeDebt({
       slug: deps.slug ?? inputs.runId,
-      coderFamily: inputs.coderFamily,
-      qeFamily: inputs.coderFamily,
+      coderUsed: inputs.coderFamily,
+      qeReviewerUsed: inputs.coderFamily,
       qeGrade: null,
+      cause: 'same-family-fallback',
       reason: `dz workflow run ${inputs.runId}: step ${w.step} (x-role: qe) resolved to the CODER family ${inputs.coderFamily} and ran under --allow-same-family-qe — the cross-family guard was consciously suspended, so an independent review is OWED`,
       emittedAt: startedAt,
       runStamp: `${inputs.runId}:${pre.execFp.slice(0, 16)}`,
-    });
+    }));
   }
 
   // the PROBED ids (established above, before the resume decision) become this run's resolution