@dzhechkov/harness-core 0.8.38 → 0.8.40

package/src/experiment-assign.ts

@@ -0,0 +1,276 @@
+/**
+ * Deterministic, blocked arm assignment for a prospective ablation (ADR-001, ablation-c-start).
+ *
+ * WHY. The owner's question — does the Step-8 QE mode change task speed — is only answerable
+ * causally if the variant a task receives is decided by chance, BEFORE the work starts, and tied to
+ * the task's own identity so a repeated query for the same task never reassigns it. This module is
+ * that decision: a PURE function of `(experiment, stratum, seed, index)`. No filesystem, no clock,
+ * no network — the caller (the cli) owns the journal, the lock, and the "did work already start?"
+ * check; this module only computes.
+ *
+ * ALGORITHM — block randomization, one pair per arm-combination per block. `mulberry32` is the
+ * repo's ONLY pseudo-random generator (`compounding.ts` — "no second RNG in this repo"); reused
+ * here rather than adding a second stream. Block size is `arms.length * 2` — two occurrences of
+ * every arm per block, so a completed block is always perfectly balanced and `propensity` (the
+ * arm's actual share of its block) is a fixed `1 / arms.length` — never guessed, never assumed
+ * 0.5 by default (NFR-4). The block's own permutation is seeded from
+ * `fnv1a(JSON.stringify([experiment, stratum, seed, block]))` (a JSON-tuple, not a delimiter join —
+ * the same reason `workOrderDigestInput` in epoch-replay.ts uses tuples: a delimiter in `experiment`
+ * or `stratum` could otherwise make two different keys hash identically) — so different strata (and
+ * different experiments) never share a stream, and the SAME `(experiment, stratum, seed, index)`
+ * always rederives the SAME arm (A1 idempotency, A2 block balance, A3 propensity).
+ */
+
+import { fnv1a } from './feature-adr-checkpoints.js';
+import { mulberry32 } from './compounding.js';
+
+export interface AssignArmInput {
+  readonly experiment: string;
+  readonly stratum: string;
+  /** Pre-registered seed — fixed once, before any assignment is made. */
+  readonly seed: number;
+  /** 0-based ordinal of this task within its `(experiment, stratum)` sequence. */
+  readonly index: number;
+  /** The arms on offer, e.g. `['direct', 'reference']`. At least 2, all non-empty, all unique. */
+  readonly arms: readonly string[];
+}
+
+export type AssignArmResult =
+  | { readonly ok: true; readonly arm: string; readonly propensity: number; readonly block: number; readonly position: number }
+  | { readonly ok: false; readonly reason: string };
+
+function isNonEmptyString(v: unknown): v is string {
+  return typeof v === 'string' && v.trim() !== '';
+}
+
+/** Fisher-Yates, driven by the given deterministic RNG. Does not mutate its input. */
+function shuffle<T>(items: readonly T[], rand: () => number): T[] {
+  const out = items.slice();
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(rand() * (i + 1));
+    const tmp = out[i]!;
+    out[i] = out[j]!;
+    out[j] = tmp;
+  }
+  return out;
+}
+
+/**
+ * Deterministically assign one arm to task ordinal `index` within `(experiment, stratum)`. Refuses
+ * (never throws, never guesses) on any malformed input — empty strings, a non-integer seed/index, a
+ * negative index, fewer than two arms, duplicate or blank arm names.
+ */
+export function assignArm(input: AssignArmInput): AssignArmResult {
+  if (!isNonEmptyString(input?.experiment)) return { ok: false, reason: 'experiment: expected a non-empty string' };
+  if (!isNonEmptyString(input?.stratum)) return { ok: false, reason: 'stratum: expected a non-empty string' };
+  if (!Number.isInteger(input?.seed) || input.seed < 0) return { ok: false, reason: 'seed: expected a non-negative integer' };
+  if (!Number.isInteger(input?.index) || input.index < 0) return { ok: false, reason: 'index: expected a non-negative integer' };
+  if (!Array.isArray(input?.arms) || input.arms.length < 2) {
+    return { ok: false, reason: 'arms: expected an array of at least 2 arm names' };
+  }
+  if (!input.arms.every(isNonEmptyString)) return { ok: false, reason: 'arms: every arm name must be a non-empty string' };
+  const seen = new Set<string>();
+  for (const a of input.arms) {
+    if (seen.has(a)) return { ok: false, reason: `arms: duplicate arm name ${JSON.stringify(a)}` };
+    seen.add(a);
+  }
+
+  const blockSize = input.arms.length * 2; // two copies of every arm — always a perfect block
+  const block = Math.floor(input.index / input.arms.length / 2); // == Math.floor(index / blockSize)
+  const position = input.index % blockSize;
+
+  const key = JSON.stringify({ experiment: input.experiment, stratum: input.stratum, seed: input.seed, block });
+  const rand = mulberry32(parseInt(fnv1a(key), 16) >>> 0);
+  // Base card set for this block: every arm twice, in the input's own order — then permuted by the
+  // block-seeded stream, so the CONTENT of every block is fixed by construction (perfect balance)
+  // and only the ORDER is randomized.
+  const cards: string[] = [];
+  for (const a of input.arms) { cards.push(a); cards.push(a); }
+  const permuted = shuffle(cards, rand);
+  const arm = permuted[position]!;
+  const propensity = 2 / blockSize; // == 1 / arms.length — the arm's fixed, actual share of its block
+
+  return { ok: true, arm, propensity, block, position };
+}
+
+export interface AssignmentRecord {
+  readonly ts: string;
+  readonly experiment: string;
+  readonly taskId: string;
+  readonly stratum: string;
+  readonly seed: number;
+  readonly index: number;
+  readonly block: number;
+  readonly position: number;
+  readonly arm: string;
+  readonly propensity: number;
+  readonly assignedAt: string;
+}
+
+export interface ReadAssignmentsResult {
+  readonly records: readonly AssignmentRecord[];
+  /** Non-blank lines that did not parse as a valid assignment record. Never silently dropped: a
+   * caller checking "is this task assigned?" must be able to tell "no" from "the journal is
+   * unreadable here" (A5). */
+  readonly malformedLines: number;
+}
+
+/** fix-round-1 (Codex r1 HIGH #7): `new Date().toISOString()` is the ONLY producer of `ts`/
+ * `assignedAt` (see the cli's `experimentJournalPath` writer) — a record whose timestamp does not
+ * match that exact shape did not come from this code path, so it is corruption, not merely an
+ * unusual value. */
+const ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+function isValidIsoTimestamp(v: unknown): v is string {
+  // Lead delta after Codex r2 (MEDIUM): shape + `Date.parse` accepts impossible calendar dates —
+  // `2026-02-30T00:00:00.000Z` parses (it rolls into March) and passed. Round-tripping through
+  // `toISOString()` is the exact check: only a real instant re-serializes to the same string.
+  if (typeof v !== 'string' || !ISO_TIMESTAMP_RE.test(v)) return false;
+  const ms = Date.parse(v);
+  return Number.isFinite(ms) && new Date(ms).toISOString() === v;
+}
+
+/**
+ * PURELY STRUCTURAL: every field is present and the right TYPE. This is `readAssignments`'s gate —
+ * it decides whether a journal LINE parses at all (A5's `malformedLines`). It deliberately does NOT
+ * validate timestamp FORMAT, propensity RANGE, or arm MEMBERSHIP: a line that is well-typed but
+ * semantically wrong (a hand-edited `position:99`, `propensity:2`, a flipped `arm`) is exactly the
+ * "syntactically valid corruption" `verifyAssignmentRecord` below exists to catch — folding those
+ * checks in here would make a single semantically-tampered record poison `readAssignments` for
+ * every caller, including ones (like `status`'s per-task duration math) that need to name WHICH
+ * task is bad rather than refuse the whole read (fix-round-1 HIGH #7/#8 — see `verifyAssignmentRecord`).
+ */
+function isValidAssignmentRecord(v: unknown): v is AssignmentRecord {
+  if (typeof v !== 'object' || v === null) return false;
+  const r = v as Record<string, unknown>;
+  return (
+    isNonEmptyString(r['ts']) &&
+    isNonEmptyString(r['experiment']) &&
+    isNonEmptyString(r['taskId']) &&
+    isNonEmptyString(r['stratum']) &&
+    Number.isInteger(r['seed']) && (r['seed'] as number) >= 0 &&
+    Number.isInteger(r['index']) && (r['index'] as number) >= 0 &&
+    Number.isInteger(r['block']) && (r['block'] as number) >= 0 &&
+    Number.isInteger(r['position']) && (r['position'] as number) >= 0 &&
+    isNonEmptyString(r['arm']) &&
+    typeof r['propensity'] === 'number' && Number.isFinite(r['propensity'] as number) &&
+    isNonEmptyString(r['assignedAt'])
+  );
+}
+
+export type VerifyAssignmentResult =
+  | { readonly ok: true }
+  | {
+      readonly ok: false;
+      readonly reason: string;
+      /** Lead delta after Codex r2: `null` when the record failed on its SEED — there is nothing to
+       *  expect, because the tuple it would be derived from is itself the thing under suspicion. */
+      readonly expected: { readonly arm: string; readonly block: number; readonly position: number; readonly propensity: number } | null;
+      readonly actual: { readonly arm: string; readonly block: number; readonly position: number; readonly propensity: number };
+    };
+
+/**
+ * fix-round-1 (Codex r1 HIGH #7) — "syntactically valid journal corruption is accepted and returned
+ * as the task's assignment". A record that passes `isValidAssignmentRecord`'s SHAPE checks can still
+ * have been hand-edited to a different arm/block/position/propensity while keeping every field the
+ * right TYPE (e.g. flipping `arm:"direct"` to `arm:"reference"`, or `position:99`). The only way to
+ * catch that is to REDERIVE the assignment from the record's own tuple
+ * `(experiment, stratum, seed, index)` via the SAME pure `assignArm` that produced it, and compare —
+ * never trust the stored arm/block/position/propensity on their own. `arms` is the experiment's own
+ * registered arm set (from its `dz experiment init` config), passed in by the caller — this module
+ * stays pure and fs-free.
+ */
+export function verifyAssignmentRecord(record: AssignmentRecord, arms: readonly string[], pinnedSeed?: number): VerifyAssignmentResult {
+  // Lead delta after Codex r2 (BLOCKER): rederiving from `record.seed` proves the record is
+  // internally CONSISTENT, never that it is AUTHENTIC — a row carrying any seed at all passes,
+  // because the check compares the row with itself. The experiment's pinned seed (from its
+  // `dz experiment init` config, the one value fixed before the first assignment) is the trusted
+  // side of the comparison; a row that disagrees with it is tampered, however well-formed.
+  if (pinnedSeed !== undefined && record.seed !== pinnedSeed) {
+    return {
+      ok: false,
+      reason: `assignment-tampered: task ${JSON.stringify(record.taskId)} carries seed ${record.seed}, but experiment ${JSON.stringify(record.experiment)} is pinned to seed ${pinnedSeed} — a record's own seed can never authenticate it`,
+      expected: null,
+      actual: { arm: record.arm, block: record.block, position: record.position, propensity: record.propensity },
+    };
+  }
+  const recomputed = assignArm({ experiment: record.experiment, stratum: record.stratum, seed: record.seed, index: record.index, arms });
+  const actual = { arm: record.arm, block: record.block, position: record.position, propensity: record.propensity };
+  const expected = recomputed.ok
+    ? { arm: recomputed.arm, block: recomputed.block, position: recomputed.position, propensity: recomputed.propensity }
+    : { arm: '(tuple refused)', block: -1, position: -1, propensity: -1 };
+
+  if (!recomputed.ok) {
+    return {
+      ok: false,
+      reason: `assignment-tampered: task ${JSON.stringify(record.taskId)}'s stored tuple (experiment=${JSON.stringify(record.experiment)}, stratum=${JSON.stringify(record.stratum)}, seed=${record.seed}, index=${record.index}) no longer rederives a valid assignment (${recomputed.reason}) — the stored record does not match what assignArm would produce from its own tuple`,
+      expected,
+      actual,
+    };
+  }
+  if (expected.arm !== actual.arm || expected.block !== actual.block || expected.position !== actual.position || expected.propensity !== actual.propensity) {
+    return {
+      ok: false,
+      reason: `assignment-tampered: task ${JSON.stringify(record.taskId)}'s stored assignment does not match what assignArm rederives from its own tuple (experiment=${JSON.stringify(record.experiment)}, stratum=${JSON.stringify(record.stratum)}, seed=${record.seed}, index=${record.index}) — the journal line was modified after it was written`,
+      expected,
+      actual,
+    };
+  }
+  // fix-round-1 HIGH #7 (named explicitly in the brief, beyond what recompute-and-compare already
+  // implies): timestamp FORMAT, propensity RANGE, and arm MEMBERSHIP. Recompute already makes a
+  // WRONG arm/propensity/block/position fail above; these three checks catch what recompute cannot
+  // — `assignArm` never produces a `ts`/`assignedAt` at all (they are wall-clock, not derived from
+  // the tuple), so a hand-edited "not-a-date" needs its own check.
+  if (!isValidIsoTimestamp(record.ts) || !isValidIsoTimestamp(record.assignedAt)) {
+    return {
+      ok: false,
+      reason: `assignment-tampered: task ${JSON.stringify(record.taskId)}'s ts/assignedAt is not a valid ISO-8601 UTC timestamp (ts=${JSON.stringify(record.ts)}, assignedAt=${JSON.stringify(record.assignedAt)})`,
+      expected,
+      actual,
+    };
+  }
+  if (!(record.propensity >= 0 && record.propensity <= 1)) {
+    return {
+      ok: false,
+      reason: `assignment-tampered: task ${JSON.stringify(record.taskId)}'s propensity ${record.propensity} is outside the valid [0,1] range`,
+      expected,
+      actual,
+    };
+  }
+  if (!arms.includes(record.arm)) {
+    return {
+      ok: false,
+      reason: `assignment-tampered: task ${JSON.stringify(record.taskId)}'s arm ${JSON.stringify(record.arm)} is not one of this experiment's registered arms (${arms.join(', ')})`,
+      expected,
+      actual,
+    };
+  }
+  return { ok: true };
+}
+
+/**
+ * Parse a JSONL assignments journal (one record per line) into records, WITHOUT touching the
+ * filesystem — the caller reads the file, this only parses its text (NFR-1: the core stays
+ * `node:fs`-free). A line that is blank is skipped silently (append-only files end in a trailing
+ * newline); a line that is non-blank but does not parse as JSON, or parses to something missing a
+ * required field, counts toward `malformedLines` and is otherwise ignored — corruption is named, not
+ * folded into "not assigned" (A5).
+ */
+export function readAssignments(text: string): ReadAssignmentsResult {
+  const records: AssignmentRecord[] = [];
+  let malformedLines = 0;
+  for (const raw of String(text ?? '').split('\n')) {
+    const line = raw.trim();
+    if (line === '') continue;
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      malformedLines++;
+      continue;
+    }
+    if (isValidAssignmentRecord(parsed)) records.push(parsed);
+    else malformedLines++;
+  }
+  return { records, malformedLines };
+}

package/src/feature-adr-checkpoints.ts

@@ -267,11 +267,11 @@ export function decideCheckpointResume(opts: {
 /** Serialize one checkpoint line, or null when the result is null/oversize/unserializable —
  * the caller logs the skip loudly; a missing checkpoint only costs a re-run, never corrupts.
  * A null result is never persisted (Codex QE #8: it would later parse as a resumable entry). */
-export function serializeCheckpoint(stage: string, inputHash: string, result: unknown): string | null {
+export function serializeCheckpoint(stage: string, inputHash: string, result: unknown, ts?: string): string | null {
   if (result === null || result === undefined) return null;
   let line: string;
   try {
-    line = JSON.stringify({ stage, inputHash, result });
+    line = JSON.stringify({ stage, inputHash, result, ...(ts === undefined ? {} : { ts }) });
   } catch {
     return null;
   }
@@ -289,6 +289,9 @@ export interface ParsedCheckpointRead {
  * command's stdout. */
 export const CHECKPOINT_LS_SENTINEL = '---FA-CKPT-LS---';
 
+/** A writer-produced UTC instant. A malformed supplied value is unmeasured, not a bad record. */
+const CHECKPOINT_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+
 /** Parse the read-back agent's stdout: JSONL entries (LAST occurrence of a stage wins — a re-run
  * overwrites by append), then the sentinel ON ITS OWN LINE, then one artifact path per line
  * (relative to the feature dir). The sentinel match is LINE-ANCHORED: JSON.stringify never emits
@@ -308,7 +311,11 @@ export function parseCheckpointRead(text: string): ParsedCheckpointRead {
     try {
       const e = JSON.parse(t) as CheckpointEntry;
       if (e && typeof e === 'object' && typeof e.stage === 'string' && typeof e.inputHash === 'string' && 'result' in e && e.result !== null && e.result !== undefined) {
-        out.entries[e.stage] = e;
+        const { ts, ...entry } = e;
+        // Narrow to `string` before the spread: under exactOptionalPropertyTypes an optional
+        // `ts?: string` refuses `string | undefined`, and an unmeasured record must carry NO key
+        // rather than an explicit undefined.
+        out.entries[e.stage] = typeof ts === 'string' && CHECKPOINT_TIMESTAMP.test(ts) ? { ...entry, ts } : entry;
       } else {
         // last-wins holds for BAD records too: a stage-identifiable null/invalid record ERASES the
         // older entry for that stage instead of silently reactivating it (Codex QE r2 #6).
@@ -345,11 +352,19 @@ export function checkpointReadCmd(fdirAbs: string): string {
 
 /** The one Bash command the write agent runs: mkdir the state dir, then append ONE line. The line
  * is single-quote-escaped as a whole — JSON.stringify output never contains literal newlines, so
- * printf '%s\n' emits exactly one record. */
+ * printf '%s\n' emits exactly one record.
+ *
+ * The record's `ts` is stamped SHELL-SIDE (`date -u`), the same idiom the decision-recall ledger
+ * uses, because the workflow sandbox forbids `Date` and this function must stay pure. A line that
+ * is not a JSON object falls back to the plain append: an unstamped record beats a lost one, and
+ * the return type stays `string` so no caller grows a new failure path. */
 export function checkpointAppendCmd(fdirAbs: string, line: string): string {
   const dir = shellQuote(fdirAbs + '/.fa-state');
   const file = shellQuote(fdirAbs + '/.fa-state/checkpoints.jsonl');
-  return 'mkdir -p ' + dir + " && printf '%s\\n' " + shellQuote(line) + ' >> ' + file;
+  const plain = 'mkdir -p ' + dir + " && printf '%s\\n' " + shellQuote(line) + ' >> ' + file;
+  if (typeof line !== 'string' || !line.startsWith('{')) return plain;
+  return 'ts=$(date -u +%Y-%m-%dT%H:%M:%SZ); mkdir -p ' + dir
+    + ' && { printf \'{"ts":"%s",\' "$ts"; printf \'%s\\n\' ' + shellQuote(line.slice(1)) + '; } >> ' + file;
 }
 
 // ─────────────────────────────────────────────────────────────────────────────

package/src/feature-adr-envelope.ts

@@ -34,6 +34,18 @@ export interface ExperimentEnvelopeChosen {
    * (usage-override, session-inherited fallback) is recorded HERE explicitly — arms stay the set that
    * was actually offered; the winner is never appended to them after the fact. */
   readonly overrides?: Readonly<Record<string, string>>;
+  /**
+   * ablation-c-start (ADR-001, T3; fix-round-1 BLOCKER #2): the pre-registered ablation-C arm
+   * (`direct` | `reference`) for THIS run, filled only when `args.experiment`/`args.taskId` were
+   * given AND the workflow successfully RESOLVED an existing assignment for that task via
+   * `dz experiment resolve` — never taken from a caller-supplied arm option (that was the BLOCKER
+   * fix-round-1 found: a caller could set the arm to anything, with zero journal entry). Deliberately
+   * a SEPARATE field from `mode` — `mode` already means "same-family vs cross-family reviewer" (a
+   * different axis) — so setting `qeMode` never redefines what `mode` has always meant. Absent (not
+   * `null`) when no arm was resolved, so `JSON.stringify` drops the key and an unflagged run's
+   * envelope stays byte-identical to before this feature (NFR-2).
+   */
+  readonly qeMode?: string;
 }
 
 export interface ExperimentEnvelopePolicy {
@@ -104,7 +116,12 @@ export function buildExperimentEnvelope(input: BuildExperimentEnvelopeInput): Ex
     treeSha: input.treeSha,
     treeShaReason: input.treeSha === null ? (input.treeShaReason ?? 'unavailable') : null,
     arms: { mode: [...input.arms.mode], stages: { ...input.arms.stages } },
-    chosen: { mode: input.chosen.mode, stages: { ...input.chosen.stages }, overrides: { ...(input.chosen.overrides ?? {}) } },
+    chosen: {
+      mode: input.chosen.mode,
+      stages: { ...input.chosen.stages },
+      overrides: { ...(input.chosen.overrides ?? {}) },
+      ...(input.chosen.qeMode !== undefined ? { qeMode: input.chosen.qeMode } : {}),
+    },
     policy: { ...input.policy },
     evaluator: { ...input.evaluator },
   };
@@ -217,6 +234,12 @@ export function validateExperimentEnvelope(value: unknown): { ok: true } | { ok:
       return { ok: false, reason: `chosen.stages.${stage}: "${String(spec)}" is not a member of arms.stages.${stage} (${offered.join('|')}) and not declared in chosen.overrides` };
     }
   }
+  // ablation-c-start (ADR-001, T3): qeMode is OPTIONAL — absent on every run this feature does not
+  // touch — but when present must be a non-empty string, same shape rule as every other envelope
+  // field (never a silently-accepted empty label).
+  if (chosen.qeMode !== undefined && !isNonEmptyString(chosen.qeMode)) {
+    return { ok: false, reason: 'chosen.qeMode: expected a non-empty string when present' };
+  }
 
   if (!isPlainObject(v.policy)) return { ok: false, reason: 'policy: expected an object' };
   const policy = v.policy;

package/src/feature-adr-routing.ts

@@ -1675,6 +1675,10 @@ export function codexDispatchMode(stage: string): CodexDispatch {
  * SCOPE — `codexReviewCommand` (the diff defines it) and `scopedQePrompt` ("read ONLY these files").
  * This constant is retained as a sanity bound on an absurd payload, and is no longer claimed as the
  * thing that prevents a stall.
+ *
+ * THIS IS THE ONLY DEFINITION. `workflow-run-dispatch.ts` re-exports it rather than declaring its
+ * own twin (it used to, and nothing compared the two). The direction is forced: this module is
+ * lifted verbatim into the workflow sandbox by `scripts/gen-loop-blobs.mjs`, so it may not import.
  */
 export const CODEX_EXEC_PROMPT_CEILING_CHARS = 24_000;
 

package/src/feature-tier.ts

@@ -1,7 +1,20 @@
 import type { FeatureTier } from './guard-volume.js';
 
+/**
+ * Начало строки, на котором тир ещё считается ОБЪЯВЛЕННЫМ, а не упомянутым в прозе: необязательный
+ * маркер списка (`-`, `*`, `+`, `1.`), необязательный заголовок и необязательное выделение.
+ *
+ * Маркер списка добавлен 2026-09-21 по измерению: `00_complexity_assessment.md` фичи
+ * `amendment-seams` несёт строку `- **Tier: S** — …`, и парсер её НЕ видел. Следствие было не
+ * косметическим: `dz contract-check --slug amendment-seams` отвечал NOT-ESTABLISHED с диагнозом
+ * «required ADR directory cannot be resolved», хотя в самом приборе есть верная ветка «тиру S
+ * каталог ADR не требуется» — она просто никогда не исполнялась, потому что тир читался как
+ * неизвестный. То есть вердикт называл не ту причину и отправлял чинить не то (бэклог 5d436aa6).
+ */
+const TIER_LINE_START = /^\s*(?:[-*+]\s+|\d+[.)]\s+)?(?:##+\s*)?(?:\*\*)?(?:Tier|Тир)(?=$|[\s:*])/iu;
+
 function tiersAfterMarkers(line: string): FeatureTier[] {
-  if (!/^\s*(?:##\s*)?(?:\*\*)?(?:Tier|Тир)(?=$|[\s:*])/iu.test(line)) return [];
+  if (!TIER_LINE_START.test(line)) return [];
   const tiers: FeatureTier[] = [];
   for (const marker of line.matchAll(/Tier|Тир/giu)) {
     const markerIndex = marker.index ?? 0;

package/src/guard.ts

@@ -1338,6 +1338,18 @@ export interface GuardAuditRecord {
   readonly observations?: readonly GuardObservation[];
   /** set when the operator overrode a block with `--force <reason>` — the override is logged, never silent. */
   readonly override?: { readonly forced: true; readonly reason: string };
+  /**
+   * Ids of every rule this run EVALUATED — `checked` plus `notEstablished`, because both mean the
+   * rule was active for the op and got its turn.
+   *
+   * Why the log needs it (backlog 1bee49dd): a guard rule's zero-firing state is its HEALTHY state,
+   * so `violations[]` cannot tell a working safety net from a dead rule. MEASURED 2026-09-21 on
+   * `.dz/guard-audit.jsonl`: 1854 rows, 26 default rules, 6 of which never appear in any violations
+   * array — and 4 of those 6 are not allowlisted, so the moment the report's history floor is met
+   * they would be named dead for doing their job. The evaluation set was already computed in
+   * `GuardResult`; only the record dropped it.
+   */
+  readonly evaluated?: readonly string[];
 }
 
 /** Build the audit record for a guard evaluation (+ an optional forced-override reason). Pure. */
@@ -1350,9 +1362,21 @@ export function auditRecord(result: GuardResult, ts: string, override?: { reason
     ...(Array.isArray(result.notes) && result.notes.length > 0 ? { notes: result.notes } : {}),
     ...(Array.isArray(result.observations) && result.observations.length > 0 ? { observations: result.observations } : {}),
     ...(override && typeof override.reason === 'string' ? { override: { forced: true, reason: override.reason } } : {}),
+    ...(evaluatedRuleIds(result).length > 0 ? { evaluated: evaluatedRuleIds(result) } : {}),
   };
 }
 
+/**
+ * Every rule that got its turn this run, sorted and de-duplicated. A rule with no input still RAN —
+ * calling that "not evaluated" would reintroduce the very conflation this field exists to remove.
+ */
+export function evaluatedRuleIds(result: GuardResult): string[] {
+  const ids = new Set<string>();
+  for (const id of Array.isArray(result.checked) ? result.checked : []) if (typeof id === 'string' && id !== '') ids.add(id);
+  for (const id of Array.isArray(result.notEstablished) ? result.notEstablished : []) if (typeof id === 'string' && id !== '') ids.add(id);
+  return [...ids].sort();
+}
+
 /** The exit-code contract: a block is non-zero unless forced; a warn/pass is zero. */
 export function guardExitCode(result: GuardResult, forced: boolean): number {
   return result.verdict === 'block' && !forced ? 1 : 0;

package/src/index.ts

@@ -78,6 +78,8 @@ export {
 } from './parity.js';
 export type { RuntimeCapability, FeatureForm, ParityFeature, ParityCell, ParityReportCell, ParityMatrixRow, CapabilityEvidence, UnbackedCapability, ProbedRuntimeVersions } from './parity.js';
 export * from './operations.js';
+export { checkInstrumentFreshness, checkRankingState } from './doctor-instrument.js';
+export type { InstrumentFreshness, InstrumentCheckInput, InstrumentCheckResult, RankingStateCheckInput, RankingStateCheckResult } from './doctor-instrument.js';
 // workflows.ts: the ADR-005 templates are RETIRED (feature loop-designer, AM-6) — the module is a
 // deprecation shim (empty WORKFLOW_NAMES). BREAKING for external harness-core consumers of
 // WorkflowTemplate/WORKFLOWS/getWorkflow — deliberately channeled through the 0.x MINOR bump and
@@ -116,6 +118,7 @@ export * from './trace-bundle.js';
 export { BLOBS as LOOP_BLOBS, LOOP_BLOB_NAMES, BLOB_COVERAGE_MANIFEST } from './loop-blobs.generated.js';
 export type { LoopBlob } from './loop-blobs.generated.js';
 export * from './sign.js';
+export * from './publish-source-scope.js';
 export * from './swarm-brief.js';
 export * from './skill-schema.js';
 export { createSkill } from './create-skill.js';
@@ -136,7 +139,7 @@ export type { RepoBoundaryIo } from './repo-boundary.js';
 export type { LedgerBackfillPlan, LedgerBackfillRow, RunCostFacts } from './ledger-backfill.js';
 export type { SweepResult, DriftedSkill, SyncResult, SyncCanonicalOptions } from './skill-drift.js';
 export { benchmarkSkill, benchmarkSkills, compareSkills } from './benchmark.js';
-export { buildRegistry, searchRegistry, filterByCategory, skillPackBaseDirs, discoverSkillPackDirs, discoverSkillCarryingDirs, discoverVerifiablePackDirs } from './registry.js';
+export { buildRegistry, buildShowcaseRegistry, searchRegistry, filterByCategory, skillPackBaseDirs, discoverSkillPackDirs, discoverSkillCarryingDirs, discoverVerifiablePackDirs, packScope, verifiedScopeNote } from './registry.js';
 export { tokenize, stemToken, stems } from './stem.js';
 // Package skill-layout resolution (feature dz-install-npx-init) — the ONE seam that knows where an
 // npm package keeps its skills (flat / templates/.claude/skills / skills). `cmdInstall` calls it;
@@ -144,7 +147,7 @@ export { tokenize, stemToken, stems } from './stem.js';
 export * from './package-skill-layouts.js';
 export { recommend } from './recommend.js';
 export { pretrain } from './pretrain.js';
-export { loadPatterns, loadSessions, computePatternBoost, readLearningConfig, readMemoryLearningConfig, BOOST_CAP, recordPattern, recordLessonForms, loadStorePatternsSync, loadStoreRecords, findExactLesson, patternToRecord, recordToPattern, patternRecordId, patternIdentityOf, dreamRecordId, isMirrorableLearning, consolidateSessions, recallPatterns, pruneNoisePatterns, removePatternsByIds, snapshotStore, readReinforcementState, encodeReinforcementState, reinforcePattern, updateReinforcementState, storeStats, lessonDeltaReport, lessonDeltaMap, readQuarantineState, encodeQuarantineState, promotePatterns, quarantineExpiryCandidates, pruneQuarantinePatterns } from './patterns.js';
+export { loadPatterns, loadSessions, computePatternBoost, readLearningConfig, readMemoryLearningConfig, BOOST_CAP, recordPattern, recordLessonForms, loadStorePatternsSync, loadStoreRecords, findExactLesson, patternToRecord, recordToPattern, patternRecordId, patternIdentityOf, dreamRecordId, isMirrorableLearning, consolidateSessions, recallPatterns, pruneNoisePatterns, removePatternsByIds, snapshotStore, readReinforcementState, encodeReinforcementState, reinforcePattern, resolveReinforceTarget, updateReinforcementState, storeStats, lessonDeltaReport, lessonDeltaMap, readQuarantineState, encodeQuarantineState, promotePatterns, quarantineExpiryCandidates, pruneQuarantinePatterns } from './patterns.js';
 export { normalizeLessonForms, validateClassTemplate, lessonPairIdOf, mergeLessonFormHits, mergeLessonMatchedForms } from './lesson-generalization.js';
 export { withStoreLock, withStoreLockSync, storeLockPath, StoreLockTimeoutError, StoreLockCompromisedError, STALE_LOCK_MS, LOCK_TIMEOUT_MS } from './store-lock.js';
 export type { StoreLockOptions } from './store-lock.js';
@@ -304,6 +307,13 @@ export type {
   StoreMarkWriteOptions,
   StoreResetReceipt,
 } from './store-guard.js';
+export { planStoreGuardPrune } from './store-guard-prune.js';
+export type {
+  StoreGuardPruneBucket,
+  StoreGuardPruneEntry,
+  StoreGuardPrunePlan,
+  StoreGuardPruneDeps,
+} from './store-guard-prune.js';
 export { statuslineData, readFeatureAdrState, writeFeatureAdrState, featureAdrStateDir, featureAdrStatePath, writeFeatureAdrStateDetailed, renderFeatureAdrPhaseLine } from './statusline.js';
 export type { StatuslineData, StatuslineStoreHealth, FeatureAdrState, WriteFeatureAdrStateInput, WriteFeatureAdrStateResult } from './statusline.js';
 export {
@@ -501,6 +511,7 @@ export {
 } from './amendment-trace.js';
 export {
   RECORD_MAX_LINE_CHARS,
+  INCOMPLETE_REASON_CODES,
   decideRecordWrite,
   decideReadBack,
   recordVerdictLine,
@@ -528,7 +539,7 @@ export type {
 } from './feature-adr-envelope.js';
 export { decidePublishSigning, decidePostSigningVerification, decideSignableSet, publishSigningLine, signableSetLine } from './publish-signing.js';
 export type { PublishSigningVerdict, PublishSigningDecision, SignableSetDecision } from './publish-signing.js';
-export type { RecordKind, RecordVerdict, RecordDecision, LedgerEnrichInput, LedgerPriceEntry, ParsedModelSpec, TaskIdLookup } from './run-records.js';
+export type { RecordKind, RecordVerdict, RecordDecision, LedgerEnrichInput, LedgerPriceEntry, ParsedModelSpec, TaskIdLookup, IncompleteReasonCode } from './run-records.js';
 export type { AmendmentAmbiguity, AmendmentRow, AmendmentVerdict, AmendmentResolution, AmendmentOutcome, AmendmentDecision, PlanCoverageGap } from './amendment-trace.js';
 // contract-checklist (ADR-001): pure extraction, canonical rendering, typed report parsing, and
 // exact per-item verification. Filesystem discovery/containment stays in harness-cli.
@@ -755,7 +766,7 @@ export type {
   ChainDefectAges,
   ChainedJournal,
 } from './event-chain.js';
-export { decideProvenance, environmentCanMintProvenance, publishArgv, discoverPackages, publishPackages, bumpPatch, compareVersions, findUnpackagedSkills, findUnpublishedWorkspaceFloors, rewriteWorkspaceSpecs, orderByDependencies, syncReadmeVersion, isChangelogEntryLine, changelogRegion, planReadmeVersionSync } from './publish.js';
+export { decideProvenance, environmentCanMintProvenance, publishArgv, matchesPublishFilter, discoverPackages, publishPackages, bumpPatch, compareVersions, findUnpackagedSkills, findUnpublishedWorkspaceFloors, rewriteWorkspaceSpecs, orderByDependencies, syncReadmeVersion, isChangelogEntryLine, changelogRegion, planReadmeVersionSync } from './publish.js';
 export type { ReadmeVersionSyncPlan, ReadmeSyncRewrite } from './publish.js';
 export { RELEASE_LINE_RE, findReleaseLine, rewriteReleaseLine } from './release-line.js';
 export * from './course-staleness.js';
@@ -773,6 +784,7 @@ export {
   planReleaseGates,
   classifyGateExecutions,
   buildFailureIssue,
+  shouldRetryGhWithoutToken,
   buildReleaseNotes,
   releaseTagName,
   firstOutputLine,
@@ -872,7 +884,7 @@ export type {
   McpSeverity,
   McpCapability,
 } from './mcp-scan.js';
-export type { RegistryEntry, Registry } from './registry.js';
+export type { RegistryEntry, Registry, ShowcaseRegistry, ShowcaseSkill } from './registry.js';
 export type { BenchmarkCheck, BenchmarkScore, BenchmarkReport, CompareResult } from './benchmark.js';
 export {
   specToOpts,
@@ -1148,6 +1160,11 @@ export * from './compounding.js';
 // Advisory command-invocation telemetry + deadwood report (feature dz-deadwood).
 export * from './cmd-usage.js';
 
+// Deterministic, blocked arm assignment for a prospective ablation (feature ablation-c-start,
+// ADR-001): pure — no fs, no clock, reuses `mulberry32` (the repo's only PRNG).
+export { assignArm, readAssignments, verifyAssignmentRecord } from './experiment-assign.js';
+export type { AssignArmInput, AssignArmResult, AssignmentRecord, ReadAssignmentsResult, VerifyAssignmentResult } from './experiment-assign.js';
+
 // Cold-vs-warm EPOCH RUNNER (feature epoch-replay, scout idea #4) — the RESULT leg to compounding's
 // readiness leg. Orchestrates + scores; never calls a model. SUPPORTED requires two DISJOINT Wilson
 // intervals; INCONCLUSIVE is a first-class honest outcome.

package/src/loop-blobs.generated.ts

@@ -52,11 +52,11 @@ export const BLOBS: Record<string, LoopBlob> = {
   "checkpoints": {
     name: "checkpoints",
     version: "1.2.0",
-    contentHash: "a44560c6036fd143b7a3f125fec00fa8b91c3c06ac5b9e1ecfb83d27a5211e9b",
+    contentHash: "b602357649042d6b8aa68b5ca5593f7f5c483fdb36a287742e7b27bda8a2a6c7",
     sourcePath: "packages/@dzhechkov/harness-core/src/feature-adr-checkpoints.ts",
     requires: [],
     exports: ["CHECKPOINT_STAGES","STAGE_ARTIFACTS","CHECKPOINT_MAX_RESULT_CHARS","CKPT_SCHEMA_VERSION","fnv1a","fnv1a64","checkpointInputHash","resumeMode","decideCheckpointResume","serializeCheckpoint","CHECKPOINT_LS_SENTINEL","parseCheckpointRead","shellQuote","checkpointReadCmd","checkpointAppendCmd","DESIGN_SUBSTAGES","designStageKey","decideDesignFanResume","parseArtifactProbe","ROUTER_CONTRACT_TOKEN"],
-    code: "const CHECKPOINT_STAGES = ['router', 'design', 'plan', 'code', 'qe', 'fleet'];\nconst STAGE_ARTIFACTS = {\n    router: '00_complexity_assessment.md',\n    design: '01_requirements.md',\n    plan: '06_implementation_plan.md',\n    code: '07_code_changes/change_manifest.md',\n    qe: '08_qe_report.md',\n    fleet: '09_fleet_qe_assessment.md',\n};\nconst CHECKPOINT_MAX_RESULT_CHARS = 12000;\nconst CKPT_SCHEMA_VERSION = 'fa-ckpt-3';\nconst ROUTER_CONTRACT_TOKEN = 'router-writes-00-v1';\nfunction fnv1a(str) {\n    let h = 0x811c9dc5;\n    for (let i = 0; i < str.length; i++) {\n        h ^= str.charCodeAt(i);\n        h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;\n    }\n    return h.toString(16).padStart(8, '0');\n}\nfunction fnv1a64(str) {\n    return fnv1a(str) + fnv1a('fa-ckpt-salt' + str);\n}\nfunction checkpointInputHash(stage, parts) {\n    return fnv1a64(JSON.stringify([CKPT_SCHEMA_VERSION, stage, ...parts.map((p) => (p === undefined ? null : p))]));\n}\nfunction resumeMode(raw) {\n    return raw === 'never' ? 'never' : raw === 'force' ? 'force' : 'auto';\n}\nconst DESIGN_SUBSTAGES = ['requirements', 'adr', 'qcsd', 'architecture'];\nfunction designStageKey(sub) {\n    return 'design:' + sub;\n}\nfunction decideDesignFanResume(opts) {\n    const missingSubstages = [];\n    opts.required.forEach((sub, i) => {\n        const r = opts.results[i];\n        if (r === null || r === undefined)\n            missingSubstages.push(sub);\n    });\n    const missingArtifacts = [];\n    let probeMissing = false;\n    if (opts.artifacts.length > 0) {\n        if (opts.postRunListing === null)\n            probeMissing = true;\n        else\n            for (const rel of opts.artifacts)\n                if (!opts.postRunListing.has(rel))\n                    missingArtifacts.push(rel);\n    }\n    const reason = missingSubstages.length > 0 ? 'substage-missing'\n        : probeMissing ? 'probe-not-established'\n            : missingArtifacts.length > 0 ? 'artifact-missing'\n                : 'ok';\n    return { complete: reason === 'ok', missingSubstages, missingArtifacts, reason };\n}\nfunction decideCheckpointResume(opts) {\n    if (opts.mode === 'never')\n        return { resume: false, reason: 'mode-never' };\n    if (!opts.entry || opts.entry.result === null || opts.entry.result === undefined) {\n        return { resume: false, reason: 'no-checkpoint' };\n    }\n    if (opts.entry.inputHash !== opts.inputHash)\n        return { resume: false, reason: 'stale-input' };\n    if (opts.mode === 'force')\n        return { resume: true, reason: 'resumed-force' };\n    const required = opts.artifactRel === null ? [] : (typeof opts.artifactRel === 'string' ? [opts.artifactRel] : opts.artifactRel);\n    for (const rel of required) {\n        if (!opts.listing.has(rel))\n            return { resume: false, reason: 'artifact-missing' };\n    }\n    return { resume: true, reason: 'resumed' };\n}\nfunction serializeCheckpoint(stage, inputHash, result) {\n    if (result === null || result === undefined)\n        return null;\n    let line;\n    try {\n        line = JSON.stringify({ stage, inputHash, result });\n    }\n    catch {\n        return null;\n    }\n    if (typeof line !== 'string' || line.length > CHECKPOINT_MAX_RESULT_CHARS)\n        return null;\n    return line;\n}\nconst CHECKPOINT_LS_SENTINEL = '---FA-CKPT-LS---';\nfunction parseCheckpointRead(text) {\n    const out = { entries: {}, listing: new Set(), malformedLines: 0 };\n    const raw = String(text ?? '');\n    const lines = raw.split('\\n');\n    const sentinelAt = lines.findIndex((l) => l.trim() === CHECKPOINT_LS_SENTINEL);\n    const body = sentinelAt === -1 ? lines : lines.slice(0, sentinelAt);\n    const ls = sentinelAt === -1 ? [] : lines.slice(sentinelAt + 1);\n    for (const line of body) {\n        const t = line.trim();\n        if (t === '')\n            continue;\n        try {\n            const e = JSON.parse(t);\n            if (e && typeof e === 'object' && typeof e.stage === 'string' && typeof e.inputHash === 'string' && 'result' in e && e.result !== null && e.result !== undefined) {\n                out.entries[e.stage] = e;\n            }\n            else {\n                if (e && typeof e === 'object' && typeof e.stage === 'string')\n                    delete out.entries[e.stage];\n                out.malformedLines++;\n            }\n        }\n        catch {\n            out.malformedLines++;\n        }\n    }\n    for (const line of ls) {\n        const t = line.trim();\n        if (t !== '')\n            out.listing.add(t);\n    }\n    return out;\n}\nfunction shellQuote(s) {\n    return \"'\" + String(s).replace(/'/g, \"'\\\\''\") + \"'\";\n}\nfunction checkpointReadCmd(fdirAbs) {\n    const q = shellQuote(fdirAbs);\n    return ('cat ' + q + '/.fa-state/checkpoints.jsonl 2>/dev/null || true; ' +\n        \"echo '\" + CHECKPOINT_LS_SENTINEL + \"'; \" +\n        'cd ' + q + ' 2>/dev/null && find . -maxdepth 2 -type f 2>/dev/null | sed \"s|^\\\\./||\" || true');\n}\nfunction checkpointAppendCmd(fdirAbs, line) {\n    const dir = shellQuote(fdirAbs + '/.fa-state');\n    const file = shellQuote(fdirAbs + '/.fa-state/checkpoints.jsonl');\n    return 'mkdir -p ' + dir + \" && printf '%s\\\\n' \" + shellQuote(line) + ' >> ' + file;\n}\nfunction parseArtifactProbe(opts) {\n    if (opts.stdout === null || opts.stdout === undefined)\n        return null;\n    const known = new Map();\n    for (const rel of opts.required)\n        known.set('HAVE:' + rel, rel);\n    const found = new Set();\n    let sentinels = 0;\n    for (const raw of String(opts.stdout).split('\\n')) {\n        const line = raw.trim();\n        if (line === '')\n            continue;\n        if (line === opts.sentinel) {\n            sentinels++;\n            continue;\n        }\n        if (sentinels > 0)\n            return null;\n        const rel = known.get(line);\n        if (rel === undefined)\n            return null;\n        found.add(rel);\n    }\n    if (sentinels !== 1)\n        return null;\n    return found;\n}",
+    code: "const CHECKPOINT_STAGES = ['router', 'design', 'plan', 'code', 'qe', 'fleet'];\nconst STAGE_ARTIFACTS = {\n    router: '00_complexity_assessment.md',\n    design: '01_requirements.md',\n    plan: '06_implementation_plan.md',\n    code: '07_code_changes/change_manifest.md',\n    qe: '08_qe_report.md',\n    fleet: '09_fleet_qe_assessment.md',\n};\nconst CHECKPOINT_MAX_RESULT_CHARS = 12000;\nconst CKPT_SCHEMA_VERSION = 'fa-ckpt-3';\nconst ROUTER_CONTRACT_TOKEN = 'router-writes-00-v1';\nfunction fnv1a(str) {\n    let h = 0x811c9dc5;\n    for (let i = 0; i < str.length; i++) {\n        h ^= str.charCodeAt(i);\n        h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;\n    }\n    return h.toString(16).padStart(8, '0');\n}\nfunction fnv1a64(str) {\n    return fnv1a(str) + fnv1a('fa-ckpt-salt' + str);\n}\nfunction checkpointInputHash(stage, parts) {\n    return fnv1a64(JSON.stringify([CKPT_SCHEMA_VERSION, stage, ...parts.map((p) => (p === undefined ? null : p))]));\n}\nfunction resumeMode(raw) {\n    return raw === 'never' ? 'never' : raw === 'force' ? 'force' : 'auto';\n}\nconst DESIGN_SUBSTAGES = ['requirements', 'adr', 'qcsd', 'architecture'];\nfunction designStageKey(sub) {\n    return 'design:' + sub;\n}\nfunction decideDesignFanResume(opts) {\n    const missingSubstages = [];\n    opts.required.forEach((sub, i) => {\n        const r = opts.results[i];\n        if (r === null || r === undefined)\n            missingSubstages.push(sub);\n    });\n    const missingArtifacts = [];\n    let probeMissing = false;\n    if (opts.artifacts.length > 0) {\n        if (opts.postRunListing === null)\n            probeMissing = true;\n        else\n            for (const rel of opts.artifacts)\n                if (!opts.postRunListing.has(rel))\n                    missingArtifacts.push(rel);\n    }\n    const reason = missingSubstages.length > 0 ? 'substage-missing'\n        : probeMissing ? 'probe-not-established'\n            : missingArtifacts.length > 0 ? 'artifact-missing'\n                : 'ok';\n    return { complete: reason === 'ok', missingSubstages, missingArtifacts, reason };\n}\nfunction decideCheckpointResume(opts) {\n    if (opts.mode === 'never')\n        return { resume: false, reason: 'mode-never' };\n    if (!opts.entry || opts.entry.result === null || opts.entry.result === undefined) {\n        return { resume: false, reason: 'no-checkpoint' };\n    }\n    if (opts.entry.inputHash !== opts.inputHash)\n        return { resume: false, reason: 'stale-input' };\n    if (opts.mode === 'force')\n        return { resume: true, reason: 'resumed-force' };\n    const required = opts.artifactRel === null ? [] : (typeof opts.artifactRel === 'string' ? [opts.artifactRel] : opts.artifactRel);\n    for (const rel of required) {\n        if (!opts.listing.has(rel))\n            return { resume: false, reason: 'artifact-missing' };\n    }\n    return { resume: true, reason: 'resumed' };\n}\nfunction serializeCheckpoint(stage, inputHash, result, ts) {\n    if (result === null || result === undefined)\n        return null;\n    let line;\n    try {\n        line = JSON.stringify({ stage, inputHash, result, ...(ts === undefined ? {} : { ts }) });\n    }\n    catch {\n        return null;\n    }\n    if (typeof line !== 'string' || line.length > CHECKPOINT_MAX_RESULT_CHARS)\n        return null;\n    return line;\n}\nconst CHECKPOINT_LS_SENTINEL = '---FA-CKPT-LS---';\nconst CHECKPOINT_TIMESTAMP = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?Z$/;\nfunction parseCheckpointRead(text) {\n    const out = { entries: {}, listing: new Set(), malformedLines: 0 };\n    const raw = String(text ?? '');\n    const lines = raw.split('\\n');\n    const sentinelAt = lines.findIndex((l) => l.trim() === CHECKPOINT_LS_SENTINEL);\n    const body = sentinelAt === -1 ? lines : lines.slice(0, sentinelAt);\n    const ls = sentinelAt === -1 ? [] : lines.slice(sentinelAt + 1);\n    for (const line of body) {\n        const t = line.trim();\n        if (t === '')\n            continue;\n        try {\n            const e = JSON.parse(t);\n            if (e && typeof e === 'object' && typeof e.stage === 'string' && typeof e.inputHash === 'string' && 'result' in e && e.result !== null && e.result !== undefined) {\n                const { ts, ...entry } = e;\n                out.entries[e.stage] = typeof ts === 'string' && CHECKPOINT_TIMESTAMP.test(ts) ? { ...entry, ts } : entry;\n            }\n            else {\n                if (e && typeof e === 'object' && typeof e.stage === 'string')\n                    delete out.entries[e.stage];\n                out.malformedLines++;\n            }\n        }\n        catch {\n            out.malformedLines++;\n        }\n    }\n    for (const line of ls) {\n        const t = line.trim();\n        if (t !== '')\n            out.listing.add(t);\n    }\n    return out;\n}\nfunction shellQuote(s) {\n    return \"'\" + String(s).replace(/'/g, \"'\\\\''\") + \"'\";\n}\nfunction checkpointReadCmd(fdirAbs) {\n    const q = shellQuote(fdirAbs);\n    return ('cat ' + q + '/.fa-state/checkpoints.jsonl 2>/dev/null || true; ' +\n        \"echo '\" + CHECKPOINT_LS_SENTINEL + \"'; \" +\n        'cd ' + q + ' 2>/dev/null && find . -maxdepth 2 -type f 2>/dev/null | sed \"s|^\\\\./||\" || true');\n}\nfunction checkpointAppendCmd(fdirAbs, line) {\n    const dir = shellQuote(fdirAbs + '/.fa-state');\n    const file = shellQuote(fdirAbs + '/.fa-state/checkpoints.jsonl');\n    const plain = 'mkdir -p ' + dir + \" && printf '%s\\\\n' \" + shellQuote(line) + ' >> ' + file;\n    if (typeof line !== 'string' || !line.startsWith('{'))\n        return plain;\n    return 'ts=$(date -u +%Y-%m-%dT%H:%M:%SZ); mkdir -p ' + dir\n        + ' && { printf \\'{\"ts\":\"%s\",\\' \"$ts\"; printf \\'%s\\\\n\\' ' + shellQuote(line.slice(1)) + '; } >> ' + file;\n}\nfunction parseArtifactProbe(opts) {\n    if (opts.stdout === null || opts.stdout === undefined)\n        return null;\n    const known = new Map();\n    for (const rel of opts.required)\n        known.set('HAVE:' + rel, rel);\n    const found = new Set();\n    let sentinels = 0;\n    for (const raw of String(opts.stdout).split('\\n')) {\n        const line = raw.trim();\n        if (line === '')\n            continue;\n        if (line === opts.sentinel) {\n            sentinels++;\n            continue;\n        }\n        if (sentinels > 0)\n            return null;\n        const rel = known.get(line);\n        if (rel === undefined)\n            return null;\n        found.add(rel);\n    }\n    if (sentinels !== 1)\n        return null;\n    return found;\n}",
   },
   "training-pairs": {
     name: "training-pairs",