@dzhechkov/harness-core 0.8.47 → 0.8.49

package/src/test-receipt.ts

@@ -21,7 +21,7 @@
 
 /** Одна запись журнала квитанций. Пишется ТОЛЬКО наблюдателем, видевшим код возврата 0. */
 export interface TestReceipt {
-  readonly v: 1;
+  readonly v: 1 | 2;
   /** Когда прогон закончился, ISO-8601. */
   readonly ts: string;
   /** Что именно было запущено — для сообщения об отказе, чтобы читатель мог повторить. */
@@ -39,7 +39,8 @@ export interface TestReceiptScopeState {
    * `never` — область не встречается ни в одной квитанции: прогона не было вовсе.
    * `changed` — квитанции есть, но ни одна не покрывает текущее содержимое.
    */
-  readonly why: 'never' | 'changed';
+  readonly why: 'never' | 'changed' | 'unobserved';
+  readonly unobservedReasons?: readonly string[];
   /** Время самой свежей квитанции, покрывавшей эту область в ЛЮБОМ виде; null при `never`. */
   readonly lastGreenAt: string | null;
 }
@@ -49,6 +50,76 @@ export type TestReceiptVerdict =
   | { readonly state: 'stale'; readonly uncovered: readonly TestReceiptScopeState[] }
   | { readonly state: 'not-established'; readonly reason: string };
 
+const canonicalPath = (path: unknown): path is string => typeof path === 'string' &&
+  !/^[A-Za-z]:|[\\\x00-\x1f\x7f-\x9f]/.test(path) && path.split('/').every((p) => p !== '' && p !== '.' && p !== '..');
+const canonicalScope = (scope: string) => ['tests', 'scripts', '.githooks'].includes(scope) ||
+  (canonicalPath(scope) && /^packages\/[^/]+(?:\/[^/]+)?$/.test(scope));
+const rootAssociations: Readonly<Record<string, readonly string[]>> = {
+  scripts: ['tests/test-receipt-script.test.mjs', 'tests/prepush-receipt-gate.test.mjs'],
+  '.githooks': ['tests/prepush-receipt-gate.test.mjs', 'tests/prepush-drift-gate.test.mjs'],
+};
+export function receiptTestPathMatchesScope(scope: string, path: string): boolean {
+  if (!canonicalScope(scope) || !canonicalPath(path)) return false;
+  if (scope === 'tests') return path.startsWith('tests/');
+  if (rootAssociations[scope]) return rootAssociations[scope]!.includes(path);
+  return ['src', 'test', 'tests'].some((dir) => path.startsWith(`${scope}/${dir}/`));
+}
+
+const positive = (n: unknown): n is number => Number.isSafeInteger(n) && (n as number) > 0;
+const object = (v: any): boolean => v !== null && typeof v === 'object' &&
+  [Object.prototype, null].includes(Object.getPrototypeOf(v)) && Reflect.ownKeys(v).every((k) =>
+    typeof k === 'string' && Object.getOwnPropertyDescriptor(v, k)?.enumerable === true);
+const keys = (v: any, expected: string[]): boolean => object(v) &&
+  Object.keys(v).length === expected.length && expected.every((k) => Object.hasOwn(v, k));
+const array = (v: any): v is any[] => Array.isArray(v) &&
+  Reflect.ownKeys(v).length === v.length + 1 && Object.keys(v).length === v.length && Object.keys(v).every((k, i) => k === String(i));
+function observed(receipt: any): boolean {
+  if (!keys(receipt, ['v', 'ts', 'command', 'observationId', 'schema', 'scopes', 'segments', 'evidence']) ||
+      receipt.v !== 2 || receipt.schema !== 'observed-test-execution-1' ||
+      typeof receipt.ts !== 'string' || !Number.isFinite(Date.parse(receipt.ts)) ||
+      new Date(receipt.ts).toISOString() !== receipt.ts || typeof receipt.command !== 'string' || !receipt.command ||
+      typeof receipt.observationId !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(receipt.observationId) ||
+      !object(receipt.scopes) || !object(receipt.evidence)) return false;
+  const scopes = Object.keys(receipt.scopes);
+  if (!scopes.length || !keys(receipt.evidence, scopes) || !scopes.every((scope) =>
+    canonicalScope(scope) && typeof receipt.scopes[scope] === 'string' && receipt.scopes[scope] !== '')) return false;
+  if (!array(receipt.segments) || !receipt.segments.length) return false;
+  const files: Map<string, number>[] = [];
+  for (const segment of receipt.segments) {
+    if (!keys(segment, ['runner', 'complete', 'failed', 'files']) ||
+        !['node-test', 'vitest'].includes(segment.runner) || segment.complete !== true || segment.failed !== 0 ||
+        !array(segment.files) || !segment.files.length) return false;
+    const counts = new Map<string, number>();
+    let total = 0;
+    for (const file of segment.files) {
+      if (!keys(file, ['path', 'executed']) || !canonicalPath(file.path) || !positive(file.executed) || counts.has(file.path)) return false;
+      counts.set(file.path, file.executed);
+      total += file.executed;
+      if (!Number.isSafeInteger(total)) return false;
+    }
+    files.push(counts);
+  }
+  return scopes.every((scope) => {
+    const evidence = receipt.evidence[scope];
+    if (!keys(evidence, ['executed', 'segments']) || !positive(evidence.executed) ||
+        !array(evidence.segments) || !evidence.segments.length) return false;
+    const indices = new Set<number>();
+    let total = 0;
+    for (const contribution of evidence.segments) {
+      if (!keys(contribution, ['index', 'paths']) || !Number.isSafeInteger(contribution.index) ||
+          contribution.index < 0 || contribution.index >= files.length || indices.has(contribution.index) ||
+          !array(contribution.paths) || !contribution.paths.length || new Set(contribution.paths).size !== contribution.paths.length) return false;
+      indices.add(contribution.index);
+      for (const path of contribution.paths) {
+        if (!canonicalPath(path) || !receiptTestPathMatchesScope(scope, path) || !files[contribution.index]!.has(path)) return false;
+        total += files[contribution.index]!.get(path)!;
+        if (!Number.isSafeInteger(total)) return false;
+      }
+    }
+    return total === evidence.executed;
+  });
+}
+
 /**
  * Чистое решение. Ничего не читает и не запускает — отпечатки и журнал подаёт вызывающий.
  *
@@ -79,13 +150,19 @@ export function decideTestReceipt(input: {
     const digest = current[scope]!;
     let seenAt: string | null = null;
     let covered = false;
+    const unobservedReasons = new Set<string>();
     for (const receipt of receipts) {
       const recorded = receipt.scopes[scope];
       if (typeof recorded !== 'string') continue;
+      if (!observed(receipt)) {
+        unobservedReasons.add(receipt.v === 1 ? 'legacy' : receipt.v !== 2 ? 'unsupported-version' : 'invalid-v2');
+        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 });
+    if (!covered) uncovered.push({ scope, digest, why: seenAt !== null ? 'changed' : unobservedReasons.size ? 'unobserved' : 'never',
+      lastGreenAt: seenAt, ...(seenAt === null && unobservedReasons.size ? { unobservedReasons: [...unobservedReasons].sort() } : {}) });
   }
 
   return uncovered.length === 0 ? { state: 'covered', scopes } : { state: 'stale', uncovered };
@@ -101,6 +178,15 @@ export function renderTestReceiptVerdict(verdict: TestReceiptVerdict): string {
   }
   const lines = verdict.uncovered.map((item) => item.why === 'never'
     ? `  · ${item.scope}: зелёного прогона не было НИ РАЗУ`
+    : item.why === 'unobserved' ? `  · ${item.scope}: missing observation — история без подтверждённого исполнения (${item.unobservedReasons?.join(', ')})`
     : `  · ${item.scope}: изменилась после последнего зелёного прогона (${item.lastGreenAt})`);
-  return [`test-receipt: НЕ ПОКРЫТО — ${verdict.uncovered.length} област(и):`, ...lines].join('\n');
+  const hints = verdict.uncovered.map(({ scope }) => {
+    if (scope.startsWith('packages/')) {
+      const wrapper = `${'../'.repeat(scope.split('/').length)}scripts/with-test-receipt.sh`;
+      return `  rerun from ${scope}: ${wrapper} ${scope} -- npx vitest run <test-file>; for Node tests use ${wrapper} ${scope} -- node --test <test-file>`;
+    }
+    const file = scope === 'scripts' ? 'tests/test-receipt-script.test.mjs' : 'tests/prepush-receipt-gate.test.mjs';
+    return `  rerun from repository root: scripts/with-test-receipt.sh ${scope} -- node --test ${file}`;
+  });
+  return [`test-receipt: НЕ ПОКРЫТО — ${verdict.uncovered.length} област(и):`, ...lines, ...hints].join('\n');
 }

package/src/workflow-run-dispatch.ts

@@ -80,6 +80,13 @@ export interface ProbeOutcome {
   id: string | null;
   wallMs: number;
   detail: string;
+  provenance?: {
+    schema: 'wf-probe-attempts-1'; complete: boolean; totalConsidered: number;
+    attempts: Array<{ ordinal: number; model: string | null; family: BridgeFamily; wrapperInvoked: boolean;
+      outcome: 'answered' | 'failed' | 'rejected'; selected: boolean;
+      reason: 'answered' | 'timeout' | 'spawn-error' | 'no-exit-code' | 'exit-nonzero' | 'unexpected-response' | 'invalid-candidate' }>;
+  } | null;
+  provenanceReason?: 'candidate-model-invalid' | 'wrapper-result-invalid' | null;
 }
 
 export interface Dispatcher {
@@ -342,6 +349,36 @@ function codexStructuredOutput(stdout: string): { structured: boolean; valid: bo
   return { structured: true, valid: !malformed && !failedTerminal, text, usage: result, reportedModel: reportedModels.size === 1 ? [...reportedModels][0]! : null };
 }
 
+/** Observe the existing wrapper seam; this does not attest OS child start. */
+function collectProbeMetadata(family: BridgeFamily) {
+  const attempts: NonNullable<ProbeOutcome['provenance']>['attempts'] = [];
+  let totalConsidered = 0;
+  let invalid: Exclude<ProbeOutcome['provenanceReason'], undefined> = null;
+  return {
+    record(id: string, wrapperInvoked: boolean, r: ChildRun | null, selected: boolean) {
+      const ordinal = ++totalConsidered;
+      if (wrapperInvoked && (typeof id !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(id))) invalid = 'candidate-model-invalid';
+      let reason: NonNullable<ProbeOutcome['provenance']>['attempts'][number]['reason'] = 'invalid-candidate';
+      if (r !== null) {
+        const typed = typeof r.stdout === 'string' && typeof r.stderr === 'string' && typeof r.timedOut === 'boolean'
+          && (r.exitCode === null || (Number.isSafeInteger(r.exitCode) && r.exitCode >= 0))
+          && (r.spawnError === null || (typeof r.spawnError === 'string' && r.spawnError.length > 0));
+        const consistent = typed && !(r.timedOut && (r.spawnError !== null || r.exitCode === 0))
+          && !(r.spawnError !== null && r.exitCode !== null) && !(selected && (r.timedOut || r.spawnError !== null || r.exitCode !== 0));
+        if (!consistent && invalid !== 'candidate-model-invalid') invalid = 'wrapper-result-invalid';
+        reason = r.timedOut ? 'timeout' : r.spawnError !== null ? 'spawn-error' : r.exitCode === null ? 'no-exit-code'
+          : r.exitCode !== 0 ? 'exit-nonzero' : selected ? 'answered' : 'unexpected-response';
+      }
+      if (ordinal <= 32) attempts.push({ ordinal, model: wrapperInvoked ? id : null, family, wrapperInvoked,
+        outcome: !wrapperInvoked ? 'rejected' : selected ? 'answered' : 'failed', reason, selected });
+    },
+    finish(): Pick<ProbeOutcome, 'provenance' | 'provenanceReason'> {
+      return { provenance: invalid === null ? { schema: 'wf-probe-attempts-1', complete: totalConsidered <= 32, totalConsidered, attempts } : null,
+        provenanceReason: invalid };
+    },
+  };
+}
+
 // ── the adapter factories (pure over the injected ChildRunner) ───────────────────────────────────
 
 function failed(family: BridgeFamily, model: string | null, wallMs: number, reason: DispatchReason, detail: string, outcome: 'null' | 'error' = 'null'): DispatchResult {
@@ -381,12 +418,16 @@ export function makeCodexExecDispatcher(run: ChildRunner, opts?: { bin?: string;
       const t0 = clock();
       const list = candidates.length > 0 ? candidates : ['gpt-5.5'];
       const started: string[] = [];
+      const observation = collectProbeMetadata('openai');
       for (const id of list) {
+        const wrapperInvoked = true;
         const r = await run(bin, codexProbeArgv(id), { stdinText: null, timeoutMs: 120_000, cwd: isolatedCwd(), detached: true });
         started.push(id);
-        if (interpretCodexProbe(r)) return { id, wallMs: clock() - t0, detail: `codex answered on ${id}` };
+        const selected = interpretCodexProbe(r);
+        observation.record(id, wrapperInvoked, r, selected);
+        if (selected) return { id, wallMs: clock() - t0, detail: `codex answered on ${id}`, ...observation.finish() };
       }
-      return { id: null, wallMs: clock() - t0, detail: `no codex candidate answered a probe (tried: ${started.join(', ')}) — an allowlist says an id is spellable, only a probe says it answers` };
+      return { id: null, wallMs: clock() - t0, detail: `no codex candidate answered a probe (tried: ${started.join(', ')}) — an allowlist says an id is spellable, only a probe says it answers`, ...observation.finish() };
     },
     dispatch: async (req) => {
       const t0 = clock();
@@ -435,14 +476,18 @@ export function makeClaudePDispatcher(run: ChildRunner, opts?: { bin?: string; i
       const t0 = clock();
       const list = candidates.length > 0 ? candidates : ['sonnet'];
       const tried: string[] = [];
+      const observation = collectProbeMetadata('claude');
       for (const id of list) {
         const argv = claudeProbeArgs(id);
         tried.push(id);
-        if (argv === null) continue; // an unsafe id is not spellable, let alone answerable
+        if (argv === null) { observation.record(id, false, null, false); continue; } // existing unsafe rejection
+        const wrapperInvoked = true;
         const r = await run(bin, argv, { stdinText: null, timeoutMs: 120_000, cwd: isolatedCwd(), detached: true });
-        if (interpretClaudeProbe({ stdout: r.stdout, exitCode: r.exitCode ?? 1 })) return { id, wallMs: clock() - t0, detail: `claude answered on ${id}` };
+        const selected = interpretClaudeProbe({ stdout: r.stdout, exitCode: r.exitCode ?? 1 });
+        observation.record(id, wrapperInvoked, r, selected);
+        if (selected) return { id, wallMs: clock() - t0, detail: `claude answered on ${id}`, ...observation.finish() };
       }
-      return { id: null, wallMs: clock() - t0, detail: `no claude candidate answered a probe (tried: ${tried.join(', ')})` };
+      return { id: null, wallMs: clock() - t0, detail: `no claude candidate answered a probe (tried: ${tried.join(', ')})`, ...observation.finish() };
     },
     dispatch: async (req) => {
       const t0 = clock();

package/src/workflow-run.ts

@@ -43,7 +43,7 @@ import { classifyFailure, errSnap, gateVerdict, joinRegion, stepContractLines, t
 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';
+import { CODEX_EXEC_XHIGH_TIMEOUT_MS, defangGateEchoes, type DispatchResult, type Dispatcher, type ProbeOutcome } from './workflow-run-dispatch.js';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Schemas / constants
@@ -178,6 +178,12 @@ export interface WfBudgetRow extends Pick<DispatchResult, 'tokensTotal' | 'token
   model: string | null;
   modelProvenance?: string;
   requestedModel?: string | null;
+  plannedModel?: string | null;
+  plannedModelSource?: 'plan-declared' | 'plan-omitted' | 'unavailable';
+  probeId?: string | null;
+  probeProvenance?: Exclude<ProbeOutcome['provenance'], undefined>;
+  probeSource?: 'dispatcher-child-seam' | 'scripted-dispatcher';
+  probeObservationReason?: 'producer-not-recorded' | 'id-factory-missing' | 'id-factory-invalid' | 'provenance-invalid' | 'candidate-model-invalid' | 'wrapper-result-invalid' | 'selected-model-invalid' | null;
   wallMs: number;
   tokensIn: number | null;
   tokensOut: number | null;
@@ -936,6 +942,35 @@ export interface RunStore {
   writeReqeDebt(record: object): void;
 }
 
+const safeRoutingModel = (value: unknown): value is string => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(value);
+function probeRecordReason(probe: ProbeOutcome, family: BridgeFamily): Exclude<WfBudgetRow['probeObservationReason'], undefined> {
+  const exact = (value: unknown, keys: string[]): value is Record<string, unknown> => value !== null && typeof value === 'object'
+    && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)
+    && Reflect.ownKeys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
+  if (probe.id !== null && !safeRoutingModel(probe.id)) return 'selected-model-invalid';
+  const present = [Object.hasOwn(probe, 'provenance'), Object.hasOwn(probe, 'provenanceReason')];
+  if (present.every(value => !value)) return 'producer-not-recorded';
+  if (!present.every(Boolean)) return 'provenance-invalid';
+  if (probe.provenance === null && (probe.provenanceReason === 'candidate-model-invalid' || probe.provenanceReason === 'wrapper-result-invalid')) return probe.provenanceReason;
+  const p = probe.provenance;
+  if (probe.provenanceReason !== null || !exact(p, ['schema', 'complete', 'totalConsidered', 'attempts']) || p.schema !== 'wf-probe-attempts-1'
+    || typeof p.complete !== 'boolean' || !Number.isSafeInteger(p.totalConsidered) || p.totalConsidered <= 0 || !Array.isArray(p.attempts)
+    || p.attempts.length !== Math.min(p.totalConsidered, 32) || p.complete !== (p.totalConsidered <= 32)) return 'provenance-invalid';
+  for (const [index, a] of p.attempts.entries()) {
+    if (!exact(a, ['ordinal', 'model', 'family', 'wrapperInvoked', 'outcome', 'reason', 'selected']) || a.ordinal !== index + 1
+      || a.family !== family || typeof a.wrapperInvoked !== 'boolean' || typeof a.selected !== 'boolean') return 'provenance-invalid';
+    const rejected = family === 'claude' && !a.wrapperInvoked && !a.selected && a.model === null && a.outcome === 'rejected' && a.reason === 'invalid-candidate';
+    const answered = a.wrapperInvoked && a.selected && safeRoutingModel(a.model) && a.outcome === 'answered' && a.reason === 'answered';
+    const failed = a.wrapperInvoked && !a.selected && safeRoutingModel(a.model) && a.outcome === 'failed'
+      && ['timeout', 'spawn-error', 'no-exit-code', 'exit-nonzero', 'unexpected-response'].includes(a.reason);
+    if (!(rejected || answered || failed)) return 'provenance-invalid';
+  }
+  const selected = p.attempts.filter(a => a.selected);
+  if (!p.complete ? selected.length !== 0 : probe.id === null ? selected.length !== 0
+    : selected.length !== 1 || selected[0]?.ordinal !== p.totalConsidered || selected[0]?.model !== probe.id) return 'provenance-invalid';
+  return null;
+}
+
 export interface SchedulerDeps {
   store: RunStore;
   dispatchers: Record<BridgeFamily, Dispatcher>;
@@ -944,6 +979,7 @@ export interface SchedulerDeps {
   /** Injected ISO clock (determinism, NFR-2). */
   now(): string;
   monotonicMs(): number;
+  newProbeId?: () => string;
   /**
    * TEST SEAM (named, never a casual flag): disables the landed barrier so the F5 mutant can show
    * the lying file-step passing. Default false; a run that sets it records `dispatcherOverride`.
@@ -987,6 +1023,7 @@ function failureClassOf(res: DispatchResult): FailureClass | null {
 }
 
 interface RunCtx {
+  probeIds: Partial<Record<BridgeFamily, string | null>>;
   inputs: RunnerInputs;
   pre: PreflightOk;
   deps: SchedulerDeps;
@@ -1062,15 +1099,34 @@ export async function runWorkflow(inputs: RunnerInputs, pre: PreflightOk, deps:
 
   const usedFamilies = [...new Set(Object.values(pre.families))];
   const probedIds: Partial<Record<BridgeFamily, string | null>> = {};
+  const probeIds: Partial<Record<BridgeFamily, string | null>> = {};
   let probeAgentCalls = 0;
   const probeDetail: Partial<Record<BridgeFamily, string>> = {};
   for (const family of usedFamilies) {
     const candidates = [...new Set(allSpecs(pre.projection).filter((s) => pre.families[s.stepId] === family).map((s) => s.model).filter((m): m is string => typeof m === 'string'))];
     const probe = await deps.dispatchers[family].probe(candidates);
     probeAgentCalls++;
+    let probeId: string | null = null;
+    let idReason: Exclude<WfBudgetRow['probeObservationReason'], undefined> = 'id-factory-missing';
+    if (deps.newProbeId) {
+      try {
+        const id = deps.newProbeId();
+        if (typeof id === 'string' && /^[0-9a-f]{32}$/.test(id)) {
+          probeId = id;
+          idReason = null;
+        } else idReason = 'id-factory-invalid';
+      } catch { idReason = 'id-factory-invalid'; }
+    }
+    const producerReason = probeRecordReason(probe, family);
+    const probeObservationReason = producerReason && producerReason !== 'producer-not-recorded' ? producerReason : idReason ?? producerReason;
+    probeIds[family] = probeId;
     store.appendBudgetRow({
       schema: WF_BUDGET_ROW_SCHEMA,
       kind: 'probe',
+      probeId,
+      probeProvenance: probeObservationReason === null ? probe.provenance! : null,
+      probeSource: deps.dispatcherOverride ? 'scripted-dispatcher' : 'dispatcher-child-seam',
+      probeObservationReason,
       runId: inputs.runId,
       projectRoot: inputs.projectRoot ?? inputs.cwdRoot,
       dispatchSeq: null,
@@ -1207,6 +1263,7 @@ export async function runWorkflow(inputs: RunnerInputs, pre: PreflightOk, deps:
 
   const opened = openTrace(inputs, pre, store, inputs.resume !== null);
   const ctx: RunCtx = {
+    probeIds,
     inputs,
     pre,
     deps,
@@ -1526,6 +1583,9 @@ async function dispatchOnce(
       family,
       model: res.modelUsed,
       requestedModel: model,
+      plannedModel: safeRoutingModel(spec.model) ? spec.model : null,
+      plannedModelSource: safeRoutingModel(spec.model) ? 'plan-declared' : spec.model == null ? 'plan-omitted' : 'unavailable',
+      probeId: ctx.probeIds[family] ?? null,
       modelProvenance: res.modelProvenance ?? (res.modelUsed === null ? 'not-recorded' : 'dispatcher-reported'),
       wallMs,
       tokensIn: res.tokensIn,