@dzhechkov/harness-core 0.3.134 → 0.3.136

package/sbom.json

@@ -25,7 +25,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "372b0c006527c97bdd9be951af4843f3c02206db197bcab9e62c5940e48cf761"
+          "content": "e8d5cf556d6c03587d16b792f9f3ca48a8724ba8485ae7a595b4dabf2e891a98"
         }
       ]
     },
@@ -569,6 +569,46 @@
         }
       ]
     },
+    {
+      "type": "file",
+      "name": "dist/compounding.d.ts",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ec191d943989b0c7d96acb31ab31eefc16a539751cd1c94e3af20105a152beff"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "dist/compounding.d.ts.map",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7c78039462fbb3b4990907d8bcc7821b8d46b4962bc6b79397605eb195127f6b"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "dist/compounding.js",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "c0500edbd72a22e8850a231078849147a445956d3e9c5894c06d257a4dad5197"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "dist/compounding.js.map",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "dfbf44a32606c8ad92fbd21a88ca615f9944802ff3d2d12de8fccbb1036dfad0"
+        }
+      ]
+    },
     {
       "type": "file",
       "name": "dist/cost-scoring.d.ts",
@@ -1015,7 +1055,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "63b513058606e37cf080176b76be65b33f21ded4f05b25e78ec56e3a978ac16b"
+          "content": "a6cd04473eff318f35da483c58a5b16d158c81ed6a838c4ea0ab5772498f0f61"
         }
       ]
     },
@@ -1025,7 +1065,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "92b4313165d607a7acb9321f490801f8b5d24a202050f7363f5df4836e4fc1de"
+          "content": "a9dfb77a1bff8eade9cfa4c0aa7c6af26704fd60b38756dd6c19e7dc935cbe19"
         }
       ]
     },
@@ -1035,7 +1075,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "dd5e32274dee6e2bc787977f4dca188101e77ac74bc9599be56286ba12a3c32f"
+          "content": "585e0b9a9a7d010b35877f5e24e5aafe8dd83efe75f271faa13d0ef49458a294"
         }
       ]
     },
@@ -1045,7 +1085,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "5e47bad5dd4e137a9ac61272419e6ad2f23166069776d5db364bc0d8f9d8dee3"
+          "content": "67b706874322e3616d90a9679ee719d4718a28f871a83bddd7ad9815b7bd5b9e"
         }
       ]
     },
@@ -1145,7 +1185,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "4ba4f80508fd7d959c49a88eb7995effe1807b891518d6089e4dec50ac2fd1f2"
+          "content": "a1316ae9b953735335d02280177b4ae845e0e5c8452ea14113fa86327a786bc1"
         }
       ]
     },
@@ -1155,7 +1195,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "a6f6d044e09f7678305296491ab43dabf454eec798d4b3bfcd167220f6fd3d96"
+          "content": "32c16d8d0793279e60f892fdc8daaa70aeda74d9948c54a3fe6fa4cdf21cc2ea"
         }
       ]
     },
@@ -1165,7 +1205,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "0a8cd9f2fe6ff4d3a9c5bf7a342e8480eb0a221a0755a118d6788297cbeccded"
+          "content": "674495cbb7a24844e82bbc70c7ac825c84f3572144acf310ab49f2ae791ddf7e"
         }
       ]
     },
@@ -1535,7 +1575,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "1524e786d8d1eaf4777fc34b0cb66c5f1e01af78abca29361eaec17fff9a6e5c"
+          "content": "d938a195e56fac7103c659ba939c9838421eede40b5f81ae1928b6cc372429e4"
         }
       ]
     },
@@ -1545,7 +1585,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "e4f528ac602e93ff3b4709d7f4b2def3f72dc0bf064b247574b5c9fc3d4a6470"
+          "content": "82a5f94b7a1ee8b70e80e36b85bb3d9c2fee68330dd4ec81aee11c81a14ea372"
         }
       ]
     },
@@ -1555,7 +1595,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "9b0121f2f8c345dc634b55e4ce9ad42aa6ab126844b1b374dbe4e7f7fa47bc1d"
+          "content": "4530f6d3bd52aa1caade1ec732dca19aeb8cc2400a2c5281b054b24a32e89a19"
         }
       ]
     },
@@ -1565,7 +1605,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "dc8993d52df53cbb95e1f93cd4bf35f592d540dd23a31820dc48014600fba154"
+          "content": "d33bc9b0ba04f134cb8a36dc8f5c801a8c245dd8e55c05785a3fb77116d8085d"
         }
       ]
     },
@@ -2345,7 +2385,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "398863280426f933afb7f962cb5ee51f71dc42188df364cb33f4ee07d09f7c68"
+          "content": "c4587f4494a98d98aebf81919a3626742302ef8a56fb698541c860496edd326f"
         }
       ]
     },
@@ -2355,7 +2395,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "6e7be0ee532ac474926d8a557c8f160ec1d689262930116ee08a326115f9648d"
+          "content": "f21b532a45cb8902ee73614c321ab843f69d0c7f9bfb1d027f78344c21b93d67"
         }
       ]
     },
@@ -2365,7 +2405,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "3c5b965649ba792514532aefee4a48f3b47b37b3bc764ddc294fce0fb9a36d80"
+          "content": "49010990ed212f5660d3ef506416b128ead1ae83797117ec577b0f263c679961"
         }
       ]
     },
@@ -2455,7 +2495,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "b55b94412729f754ffb2ab36807d6bcf0eadbd5690fbeb7d143190c45fd36e0e"
+          "content": "87dd771f68992eb5ed6d6cfd4d6e1148f684b574eea49c8c669c2b7573c8d97e"
         }
       ]
     },
@@ -2589,6 +2629,16 @@
         }
       ]
     },
+    {
+      "type": "file",
+      "name": "src/compounding.ts",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "2f051ebc8d86b6de4d359a5482c25b8cee59261a790599ced85c20162e0c87b1"
+        }
+      ]
+    },
     {
       "type": "file",
       "name": "src/cost-scoring.ts",
@@ -2705,7 +2755,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "c224021d9de3fbfd777ad74dc2d65baefa112b98e6fcee8eeac4bc0c83fa8b60"
+          "content": "90df35fb71d36b4e2b38eaad98acc6437cb26036b7b021e10cae2bc99d5546fd"
         }
       ]
     },
@@ -2735,7 +2785,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "78143fffb04e9ed2f428847966084fbec503e2cd0286664767acc34c7cc3af48"
+          "content": "80b292202fad0be0e9939f67641f16987e93f962b547b56e9771d9ae9a7c94b1"
         }
       ]
     },
@@ -2825,7 +2875,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "df8499d9a4394b8ec257c2359d358f5113ff9c70c78949806f060c0317692cfb"
+          "content": "4fc2483e6142f5b1f11fd6c2b810be2a25171835551320ef0fde3e296962f693"
         }
       ]
     },
@@ -3025,7 +3075,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "e2b01c71101c2cdfa076a26148e1c26b37d28204ac33b561d98e89cdc30d238f"
+          "content": "a74ad3ca87279e0cb808a40dd8f18f52efed5c6f37f45f8186ea573c4a610fdd"
         }
       ]
     },
@@ -3189,6 +3239,16 @@
         }
       ]
     },
+    {
+      "type": "file",
+      "name": "test/compounding.test.ts",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "125ae7b36ad75488d4dd35edc585fc1523691c3f156d3ac0a3b891fd804645d1"
+        }
+      ]
+    },
     {
       "type": "file",
       "name": "test/cost-scoring.test.ts",
@@ -3735,7 +3795,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "3159f518ee1cad89a8ed4f996361d1584188811232f7aa8f03af4985b072cda7"
+          "content": "09b9c4ed5bf879e71a6940df7255db9d61c160061e34a7ff596733eaf7775de9"
         }
       ]
     },

package/src/compounding.ts

@@ -0,0 +1,314 @@
+/**
+ * `dz compounding` — does the learning loop actually PAY? (feature compounding, scout C2)
+ *
+ * Ported from rUv's darwin-mode (`security/compounding.ts`, `security/ablation.ts`,
+ * `bench/{stats,promotion}.ts`) with an honesty split the port map demanded:
+ *   - the STATS machinery ports verbatim (seeded mulberry32, bootstrap lower-95, decidePromotion,
+ *     the min-n >= 5 rule — darwin's own FDR calibration shows n=3 gives a 33% false-discovery rate);
+ *   - darwin's MEASUREMENT legs do NOT port: its FP-drop leg ignores the passed corpus (a fixture),
+ *     `withoutMemory` is hard-coded 0, and "warm" is injected state — theatrical, exactly what this
+ *     repo's claim-check culture forbids. The measurements here are dz-native, over data that exists.
+ *
+ * The report NEVER fakes a verdict: a gate without enough samples says INSUFFICIENT_DATA — after the
+ * 2026-07-28 inventory found the apply-leg log dead for 19 days, "no data" is a finding, not a pass.
+ *
+ * Everything here is PURE: callers gather facts (files, store rows); this module only computes.
+ */
+
+// ── Seeded statistics (verbatim-shape port from darwin-mode bench/stats.ts) ──
+
+/** Deterministic PRNG — same seed, same stream, byte-identical reports. */
+export function mulberry32(seed: number): () => number {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+export const BOOTSTRAP_RESAMPLES = 5000;
+/** Below this many samples PER ARM a comparison is noise: darwin's own FDR calibration measured a
+ *  0.332 empirical false-discovery rate at n=3. */
+export const MIN_SAMPLES_PER_ARM = 5;
+
+export interface BootstrapDelta {
+  readonly meanDelta: number;
+  /** 2.5th percentile of the resampled deltas — the promotion decision reads THIS, not the mean. */
+  readonly lower95: number;
+  readonly samples: number;
+}
+
+/** Paired bootstrap over per-item deltas (b[i] - a[i]). */
+export function bootstrapDelta(a: readonly number[], b: readonly number[], seed = 42): BootstrapDelta | null {
+  // PAIRED means paired: unequal lengths silently truncated a decisive observation and promoted on
+  // the remainder; a sparse/NaN entry is not an observation at all (Codex #9).
+  if (a.length !== b.length || a.length === 0) return null;
+  if (![...a, ...b].every((x) => typeof x === 'number' && Number.isFinite(x))) return null;
+  const n = a.length;
+  const deltas: number[] = [];
+  for (let i = 0; i < n; i++) deltas.push((b[i] ?? 0) - (a[i] ?? 0));
+  const rand = mulberry32(seed);
+  const means: number[] = [];
+  for (let r = 0; r < BOOTSTRAP_RESAMPLES; r++) {
+    let sum = 0;
+    for (let i = 0; i < n; i++) sum += deltas[Math.floor(rand() * n)] ?? 0;
+    means.push(sum / n);
+  }
+  means.sort((x, y) => x - y);
+  const meanDelta = deltas.reduce((s, d) => s + d, 0) / n;
+  // Conservative nearest-rank percentile: ceil(B*p)-1. floor(B*p) sat one slot ABOVE the 2.5th
+  // percentile and could flip a reject into a promote at the boundary (Codex #10 — a defect darwin
+  // itself inherits; ported faithfully was still ported wrong).
+  const lower95 = means[Math.max(0, Math.ceil(BOOTSTRAP_RESAMPLES * 0.025) - 1)] ?? 0;
+  return { meanDelta, lower95, samples: n };
+}
+
+export type PromotionVerdict = 'promote' | 'reject' | 'insufficient-data';
+
+/** Darwin's decision rule: a positive mean is not enough — the LOWER bound must clear zero. */
+export function decidePromotion(delta: BootstrapDelta | null, minDelta = 0): PromotionVerdict {
+  // NaN samples compared false against the minimum and PROMOTED (Codex #9) — every field must be a
+  // real number and the count a real integer before any decision exists.
+  if (
+    delta === null ||
+    !Number.isInteger(delta.samples) ||
+    delta.samples < MIN_SAMPLES_PER_ARM ||
+    !Number.isFinite(delta.meanDelta) ||
+    !Number.isFinite(delta.lower95) ||
+    !Number.isFinite(minDelta)
+  ) {
+    return 'insufficient-data';
+  }
+  return delta.meanDelta > minDelta && delta.lower95 > 0 ? 'promote' : 'reject';
+}
+
+// ── The dz-native facts the CLI gathers ─────────────────────────────
+
+export interface LessonRow {
+  readonly dzId: string;
+  readonly uses: number;
+  readonly quarantined: boolean;
+  readonly reward: number | null;
+}
+
+export interface UsageEvent {
+  readonly dzId: string;
+  readonly ts: string;
+  readonly query?: string;
+  readonly runId?: string;
+  /** One id per PROMPT: the hook writes one row per injected hit (up to 3 per prompt), and counting
+   *  rows as independent replay pairs fabricated readiness (Codex #1). */
+  readonly eventId?: string;
+  /** A truncated query cannot reproduce the original recall — it must not count (Codex #3). */
+  readonly queryTruncated?: boolean;
+}
+
+export interface GuardEvent {
+  readonly ts: string;
+  readonly verdict: string;
+  readonly rules: readonly string[]; // violated rule ids
+}
+
+export interface CompoundingFacts {
+  readonly lessons: readonly LessonRow[];
+  readonly usage: readonly UsageEvent[];
+  readonly guard: readonly GuardEvent[];
+  readonly nowTs: string;
+}
+
+// ── The report ──────────────────────────────────────────────────────
+
+export interface PoolPayoff {
+  readonly total: number;
+  /** Ever surfaced by the APPLY leg (hook injection) — the strict payoff bar. */
+  readonly injectedEver: number;
+  /** Touched by ANY recall path (store `uses` counter). */
+  readonly touchedEver: number;
+  readonly neverTouched: number;
+  readonly quarantined: number;
+  /** Fraction of the pool that is write-only under the strict bar. */
+  readonly writeOnlyRatio: number;
+}
+
+export interface GuardRuleTrajectory {
+  readonly rule: string;
+  readonly firstHalfViolations: number;
+  readonly secondHalfViolations: number;
+  readonly firstHalfAudits: number;
+  readonly secondHalfAudits: number;
+  /** Improvement is judged on the RATE (violations per audit), not raw counts: ten violations in a
+   *  hundred early audits vs one in one late audit is a WORSENING, not progress (Codex #7). */
+  readonly improved: boolean;
+}
+
+export type ReadinessVerdict = 'ready' | 'insufficient-data';
+
+export interface ReplayReadiness {
+  /** UNIQUE, untruncated prompt events — the pairs a cold-vs-warm replay needs. */
+  readonly replayablePairs: number;
+  readonly minNeeded: number;
+  /** READINESS only. `promote`/`reject` exist solely after a real cold/warm A-B has been run and
+   *  bootstrapped — readiness must never look like a result (Codex #1). */
+  readonly verdict: ReadinessVerdict;
+  readonly note: string;
+}
+
+export interface InstrumentationHealth {
+  readonly lastUsageTs: string | null;
+  readonly gapDays: number | null;
+  /** True when the newest usage record is recent enough to trust the leg is alive. */
+  readonly applyLegLive: boolean;
+}
+
+export interface CompoundingReport {
+  readonly pool: PoolPayoff;
+  readonly guardTrajectory: readonly GuardRuleTrajectory[];
+  readonly replay: ReplayReadiness;
+  readonly instrumentation: InstrumentationHealth;
+  /** The one-line honest answer. */
+  readonly verdict: string;
+}
+
+const APPLY_LEG_STALE_DAYS = 7;
+
+export function assembleCompoundingReport(facts: CompoundingFacts): CompoundingReport {
+  const { lessons, usage, guard } = facts;
+
+  // 1. Pool payoff — the "loops need all three legs" question, quantified.
+  const injectedIds = new Set(usage.map((u) => u.dzId));
+  const injectedEver = lessons.filter((l) => injectedIds.has(l.dzId)).length;
+  const touchedEver = lessons.filter((l) => l.uses > 0 || injectedIds.has(l.dzId)).length;
+  const total = lessons.length;
+  const pool: PoolPayoff = {
+    total,
+    injectedEver,
+    touchedEver,
+    neverTouched: total - touchedEver,
+    quarantined: lessons.filter((l) => l.quarantined).length,
+    writeOnlyRatio: total === 0 ? 0 : (total - injectedEver) / total,
+  };
+
+  // 2. Guard trajectory — do the same mistakes recur less over time? Split the record span in half
+  //    by TIME (not by count: a busy afternoon must not masquerade as an era).
+  // Only events with a PARSEABLE timestamp participate; a span of zero has no halves (Codex #7).
+  const guardTimed = guard
+    .map((g) => ({ ...g, ms: Date.parse(g.ts) }))
+    .filter((g) => Number.isFinite(g.ms))
+    .sort((a, b) => a.ms - b.ms);
+  const trajectory: GuardRuleTrajectory[] = [];
+  const t0 = guardTimed.length > 0 ? guardTimed[0]!.ms : 0;
+  const t1 = guardTimed.length > 0 ? guardTimed[guardTimed.length - 1]!.ms : 0;
+  if (guardTimed.length >= 2 && t1 > t0) {
+    const mid = t0 + (t1 - t0) / 2;
+    let firstAudits = 0;
+    let secondAudits = 0;
+    for (const g of guardTimed) {
+      if (g.ms <= mid) firstAudits += 1;
+      else secondAudits += 1;
+    }
+    const perRule = new Map<string, { first: number; second: number }>();
+    for (const g of guardTimed) {
+      const inFirst = g.ms <= mid;
+      for (const rule of g.rules) {
+        const e = perRule.get(rule) ?? { first: 0, second: 0 };
+        if (inFirst) e.first += 1;
+        else e.second += 1;
+        perRule.set(rule, e);
+      }
+    }
+    // Both halves must contain OBSERVATIONS for a rate comparison to mean anything.
+    if (firstAudits > 0 && secondAudits > 0) {
+      for (const [rule, e] of [...perRule.entries()].sort()) {
+        const firstRate = e.first / firstAudits;
+        const secondRate = e.second / secondAudits;
+        trajectory.push({
+          rule,
+          firstHalfViolations: e.first,
+          secondHalfViolations: e.second,
+          firstHalfAudits: firstAudits,
+          secondHalfAudits: secondAudits,
+          improved: secondRate < firstRate,
+        });
+      }
+    }
+  }
+
+  // 3. Replay readiness — cold-vs-warm needs (query -> injected lesson) pairs. They were never
+  //    recorded before 2026-07-28, so this gate REPORTS accrual instead of faking a verdict.
+  const replayKeys = new Set<string>();
+  for (const u of usage) {
+    if (typeof u.query !== 'string' || u.query.trim() === '') continue;
+    if (u.queryTruncated === true) continue; // a prefix is not the prompt
+    // one prompt = one pair, however many hits it injected
+    replayKeys.add(u.eventId ?? `${u.runId ?? ''}|${u.ts}|${u.query}`);
+  }
+  const replayablePairs = replayKeys.size;
+  const replay: ReplayReadiness = {
+    replayablePairs,
+    minNeeded: MIN_SAMPLES_PER_ARM,
+    verdict: replayablePairs >= MIN_SAMPLES_PER_ARM ? 'ready' : 'insufficient-data',
+    note:
+      replayablePairs >= MIN_SAMPLES_PER_ARM
+        ? `${replayablePairs} unique prompt event(s) recorded — a cold-vs-warm replay can now be RUN (readiness, not a result)`
+        : `${replayablePairs} unique prompt event(s); ${MIN_SAMPLES_PER_ARM} needed — queries are recorded as of 2026-07-28, data is accruing`,
+  };
+
+  // 4. Instrumentation health — "no data" must be a finding, never a silent pass.
+  // Liveness compares RAW milliseconds (a 7d23h gap floored to "7 days" read as live), rejects
+  // garbage timestamps, and treats a FUTURE timestamp beyond small clock skew as evidence of a
+  // broken clock, not of liveness (Codex #8).
+  const usageTimed = usage
+    .map((u) => ({ ts: u.ts, ms: Date.parse(u.ts) }))
+    .filter((u) => Number.isFinite(u.ms))
+    .sort((a, b) => a.ms - b.ms);
+  const lastUsage = usageTimed.length > 0 ? usageTimed[usageTimed.length - 1]! : null;
+  const nowMs = Date.parse(facts.nowTs);
+  const CLOCK_SKEW_MS = 60_000;
+  const gapMs = lastUsage && Number.isFinite(nowMs) ? nowMs - lastUsage.ms : null;
+  const gapValid = gapMs !== null && gapMs >= -CLOCK_SKEW_MS;
+  const instrumentation: InstrumentationHealth = {
+    lastUsageTs: lastUsage?.ts ?? null,
+    gapDays: gapValid ? Math.max(0, Math.floor(gapMs / 86_400_000)) : null,
+    applyLegLive: gapValid && gapMs <= APPLY_LEG_STALE_DAYS * 86_400_000,
+  };
+
+  const improvedRules = trajectory.filter((t) => t.improved).length;
+  const verdict = [
+    `pool: ${injectedEver}/${total} lessons ever injected (${Math.round(pool.writeOnlyRatio * 100)}% write-only under the strict bar)`,
+    trajectory.length > 0 ? `guard: ${improvedRules}/${trajectory.length} rules recur less in the later half` : 'guard: not enough history',
+    `cold-vs-warm: ${replay.verdict === 'insufficient-data' ? 'INSUFFICIENT DATA (accruing)' : 'READY to measure'}`,
+    instrumentation.applyLegLive ? 'apply leg: live' : 'apply leg: STALE — fix the instrumentation before trusting anything above',
+  ].join(' · ');
+
+  return { pool, guardTrajectory: trajectory, replay, instrumentation, verdict };
+}
+
+export function renderCompoundingReport(r: CompoundingReport): string {
+  const out: string[] = [];
+  out.push('dz compounding — does the learning loop pay? (honest report: gates without data say so)');
+  out.push('');
+  out.push(`  POOL PAYOFF: ${r.pool.total} lessons · ${r.pool.injectedEver} ever injected by the apply leg · ${r.pool.touchedEver} touched by any recall · ${r.pool.neverTouched} never touched · ${r.pool.quarantined} quarantined`);
+  out.push(`    write-only ratio (strict bar): ${(r.pool.writeOnlyRatio * 100).toFixed(0)}%`);
+  out.push('');
+  if (r.guardTrajectory.length > 0) {
+    out.push('  GUARD TRAJECTORY (violations, first half vs second half of the audit span):');
+    for (const t of r.guardTrajectory) {
+      out.push(`    ${t.improved ? '↓' : '·'} ${t.rule}: ${t.firstHalfViolations} → ${t.secondHalfViolations}`);
+    }
+  } else {
+    out.push('  GUARD TRAJECTORY: not enough audit history to split');
+  }
+  out.push('');
+  out.push(`  COLD-VS-WARM REPLAY: ${r.replay.note}`);
+  out.push(
+    `  INSTRUMENTATION: last apply-leg record ${r.instrumentation.lastUsageTs ?? 'never'}` +
+      (r.instrumentation.gapDays !== null ? ` (${r.instrumentation.gapDays}d ago)` : '') +
+      ` — ${r.instrumentation.applyLegLive ? 'live' : 'STALE'}`,
+  );
+  out.push('');
+  out.push(`  VERDICT: ${r.verdict}`);
+  return out.join('\n');
+}

package/src/index.ts

@@ -321,3 +321,8 @@ export * from './delivery-check.js';
 // Skill-registration gate (feature skills-verify, ADR-001) — static layout scan + the deterministic
 // `system/init` listing. Fail-closed: an unobservable registration is `inconclusive`, never `pass`.
 export * from './skills-verify.js';
+
+// Learning-loop payoff measurement (feature compounding, scout C2) — seeded stats ported verbatim
+// from darwin-mode; measurements are dz-native and NEVER fake a verdict (INSUFFICIENT_DATA is a
+// finding, not a pass).
+export * from './compounding.js';

package/src/operations.ts

@@ -749,6 +749,30 @@ export async function runDoctor(options: { projectRoot: string }): Promise<Docto
         detail: `deployed writer v${deployed} < current v${AGENTDB_WRITER_VERSION} — re-run dz setup to upgrade (no --force needed)`,
       });
     }
+    // APPLY-LEG LIVENESS (2026-07-28): the recall hook injects lessons only while the embed daemon's
+    // socket is alive, and the daemon is started at SessionStart only — when it died mid-way through a
+    // long-lived session the whole apply leg went silently dark for 19 days (MEASURED:
+    // recall-usage.jsonl last record 2026-07-09 with the socket absent). A dead leg must be VISIBLE.
+    try {
+      const settingsPath = join(root, '.claude', 'settings.json');
+      if (existsSync(settingsPath)) {
+        const settingsText = readFileSync(settingsPath, 'utf-8');
+        const applyLegWired = settingsText.includes('recall-hook.cjs') && settingsText.includes('dz-embed-daemon.mjs');
+        if (applyLegWired) {
+          const sockAlive = existsSync(join(root, '.dz', 'embed.sock'));
+          checks.push({
+            name: 'apply-leg alive (embed daemon)',
+            ok: sockAlive,
+            detail: sockAlive
+              ? 'embed.sock present — recall injection can run'
+              : 'embed.sock ABSENT: the recall hook is wired but cannot inject (the hook self-heals on the next prompt; a persistent absence means the daemon cannot start)',
+          });
+        }
+      }
+    } catch {
+      /* doctor never throws on a diagnostic */
+    }
+
     // Version drift between the local agentdb copy and the .mcp.json pin (gap G7)
     try {
       const localVer = (JSON.parse(readFileSync(join(root, 'node_modules', 'agentdb', 'package.json'), 'utf-8')) as { version?: string }).version;