@dzhechkov/harness-core 0.8.30 → 0.8.31

package/dist/apply-leg.js

@@ -0,0 +1,975 @@
+/**
+ * Apply-leg module (feature `setup-installs-apply-leg`, ADR-001 Decisions 1 and 2).
+ *
+ * The self-learning loop has three legs — COLLECT (session hooks → store), RANK (`dz teach` /
+ * `dz recall` / `dz consolidate`), APPLY (a `UserPromptSubmit` hook injects learned lessons back
+ * into the prompt via a resident embedding daemon). `dz setup` shipped the first two legs; the
+ * third lived ONLY as hand-committed files in this hub's own `.claude/helpers/` — a consumer who
+ * ran `dz setup --target claude-code --memory agentdb` got session hooks and a memory store, but no
+ * recall injection at all (00_complexity_assessment.md, MEASURED 2026-09-12: clean scratch installs
+ * on 0.8.10 and 0.8.22, with and without `--memory agentdb`, wrote no `UserPromptSubmit` entry).
+ *
+ * This module is the SOURCE of that third leg: the two helper files as versioned template
+ * generators (the same shape as `AGENTDB_WRITER_VERSION`/`generateAgentdbWriter` in `setup.ts`),
+ * the hook-registry entries `runSetup` merges into `settings.json`, and `applyLegStatus` — the ONE
+ * measurement `dz doctor` and `dz parity` both read, so neither can drift into declaring the leg
+ * present from a static capability table again (ADR-001 Decision 3, the "приборы врут" defect).
+ *
+ * Decision 2 (why `coreDistDir` is baked in, first candidate): a hook file lives in a CONSUMER
+ * project's `.claude/helpers/`, where `require('@dzhechkov/harness-core')` cannot resolve — Node
+ * resolves a bare specifier upward from the file, and the package is not above it in a global
+ * install. The old hard-coded `/usr/lib/node_modules/...` candidate assumed one specific npm
+ * prefix; a project set up from an nvm or `/usr/local` install found nothing. The fix mirrors
+ * `claude-hooks-assets.ts`'s destructive-guard hook: bake the INSTALLING copy's absolute `dist`
+ * directory into the generated body as the FIRST candidate (proven first at C-5), keep the
+ * project-local candidates as fallbacks for a consumer that vendors its own harness-core.
+ *
+ * @packageDocumentation
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { hookCommandsOf } from './managed-hooks.js';
+/**
+ * Version stamped into BOTH generated helper files as `// dz-apply-leg-version: N` (line 2, right
+ * after the shebang). Bump on ANY change to {@link recallHookSource} or {@link embedDaemonSource}'s
+ * output — `runSetup` regenerates a deployed helper whose stamp is older, without requiring
+ * `--force` (the same self-healing contract as `AGENTDB_WRITER_VERSION`).
+ *
+ * Bumped 2→3 (fix round 1, review Codex C, MEDIUM finding "hub twins непереносимы"):
+ * `recallHookSource`'s `loadCoreModule` candidate list is now built with a conditional spread so a
+ * `null` `coreDistDir` (the hub's own portable marker, C-6/finding-6) degrades cleanly to the
+ * project-relative fallbacks — the generated BYTES changed for every caller, hub and consumer alike.
+ */
+export const APPLY_LEG_VERSION = 3;
+/**
+ * Parse the `dz-apply-leg-version` stamp from a deployed helper file. Unlike
+ * `writerVersionOf` (which floors an absent stamp at `0`), this returns `-1` for "no stamp at
+ * all" per the plan contract (T1) — `0` is reserved for a future explicit `version 0` helper, and
+ * collapsing "never installed" into the same number as "installed at v0" would make
+ * `applyLegStatus` unable to tell the two apart.
+ */
+export function applyLegVersionOf(content) {
+    const m = /^\/\/ dz-apply-leg-version:\s*(\d+)/m.exec(content);
+    return m ? parseInt(m[1] ?? '0', 10) : -1;
+}
+/**
+ * Read back the `coreDistDir` baked into a deployed `recall-hook.cjs` by {@link recallHookSource}
+ * (fix round 1, review Codex C, MEDIUM finding "переезд ядра"): `undefined` when the file carries no
+ * recognisable `const CORE_DIST_DIR = …;` line at all (e.g. a pre-feature or hand-edited file),
+ * `null` for the hub's own portable marker, otherwise the baked absolute path. `runSetup` compares
+ * this against the CURRENT `coreDistDir` so a project whose npm/nvm relocated `harness-core` gets
+ * its helper rewritten even when {@link APPLY_LEG_VERSION} did not change — a version-only staleness
+ * check missed exactly this case (MEASURED: a stale baked path degrades the hook to permanent
+ * silence, never a thrown error, so nothing else would ever surface it).
+ */
+export function bakedCoreDistDirOf(content) {
+    const m = /^const CORE_DIST_DIR = (.+);$/m.exec(content);
+    if (!m)
+        return undefined;
+    const raw = m[1] ?? '';
+    if (raw === 'null')
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'string' ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Generate `.claude/helpers/recall-hook.cjs`. `coreDistDir` is baked in as the FIRST resolve
+ * candidate in `loadCoreModule` (Decision 2, AC-6/C-5) — an absolute path, supplied by the
+ * installer (`dz setup`'s CLI caller resolves its own installed `@dzhechkov/harness-core`).
+ *
+ * `coreDistDir === null` is the HUB's OWN portable marker (fix round 1, review Codex C, MEDIUM
+ * finding "hub twins непереносимы"): a checked-in file that bakes an ABSOLUTE checkout path fails
+ * the twins byte-identity test in every clone but the one it was generated from. The hub instead
+ * regenerates its two `.claude/helpers/*` files with `null`, which renders `const CORE_DIST_DIR =
+ * null;` and — since `loadCoreModule`'s candidate list below SKIPS a falsy `CORE_DIST_DIR` — falls
+ * straight through to the project-relative fallback candidates, the SAME `<project>/packages/
+ * @dzhechkov/harness-core/dist/<file>` path the hub's own `coreDistDir` would have baked anyway
+ * (`PROJECT` resolves from `CLAUDE_PROJECT_DIR`/`cwd()` at hook RUNTIME, not at generation time, so
+ * it is correct in any clone). A real consumer install still gets its installer's absolute path
+ * baked in as before — this is additive, not a behavior change for that case.
+ *
+ * Behaviourally identical to the pre-existing hand-committed hub file except for: the version
+ * stamp (new, line 2) and the candidate list in `loadCoreModule` (baked path first when present,
+ * `/usr/lib/...` dropped — FR-3).
+ */
+export function recallHookSource(coreDistDir) {
+    return `#!/usr/bin/env node
+// dz-apply-leg-version: ${APPLY_LEG_VERSION}
+/**
+ * \`UserPromptSubmit\` hook — the APPLY leg of dz's self-learning loop.
+ *
+ * A feedback loop has three legs: COLLECT → RANK → APPLY. dz collected automatically and never read
+ * back: of 18 hooks, none touched the pattern store, so 100+ learned lessons reached an agent's
+ * context only when \`feature-adr\` Step-0 asked or a human typed \`dz recall\`. The cost was concrete —
+ * a lesson that was ALREADY STORED ("Codex writes out-of-band; \`changed=0\` means NOT-YET") failed to
+ * prevent the same false grade-D a second time. This file is the missing leg.
+ *
+ * WHAT IT MUST NOT BECOME. agentic-qe has an apply leg and no rank leg: it injects the same five
+ * static guidance lines on every prompt regardless of topic, and only 10 of its 198 patterns were
+ * ever used. An apply leg without a floor trains the reader to ignore it. So: when nothing clears the
+ * MEASURED relevance floor this hook prints NOTHING AT ALL and exits 0.
+ *
+ * NEVER-BLOCK is the top safety property, above usefulness. Any failure — no daemon, no deps, a
+ * malformed payload, a slow socket — exits 0 in silence. A broken hook must never stall a turn.
+ */
+
+const net = require('node:net');
+const path = require('node:path');
+const fs = require('node:fs');
+const { pathToFileURL } = require('node:url');
+
+const PROJECT = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const CORE_DIST_DIR = ${coreDistDir === null ? 'null' : JSON.stringify(coreDistDir)};
+const SOCKET = process.env.DZ_EMBED_SOCKET || path.join(PROJECT, '.dz', 'embed.sock');
+const USAGE_LOG = process.env.DZ_RECALL_USAGE_LOG || path.join(PROJECT, '.dz', 'recall-usage.jsonl');
+const TIMEOUT_MS = Number(process.env.DZ_RECALL_HOOK_TIMEOUT_MS || 800);
+
+const safe = (fn, fb) => {
+  try {
+    return fn();
+  } catch {
+    return fb;
+  }
+};
+
+/** Read the whole of stdin, bounded. Returns '' on anything unexpected. */
+function readStdin() {
+  return safe(() => fs.readFileSync(0, 'utf-8'), '');
+}
+
+/** Extract the prompt from a UserPromptSubmit payload — the shapes Claude Code may send. */
+function extractPrompt(raw) {
+  const text = String(raw || '').trim();
+  if (text === '') return '';
+  const parsed = safe(() => JSON.parse(text), undefined);
+  if (parsed && typeof parsed === 'object') {
+    for (const k of ['prompt', 'user_prompt', 'userPrompt']) {
+      if (typeof parsed[k] === 'string' && parsed[k].trim() !== '') return parsed[k].trim();
+    }
+    return '';
+  }
+  return text; // plain, non-JSON text is the prompt
+}
+
+/**
+ * Load the pure policy from the built harness-core. It ships as ESM, so a \`.cjs\` hook cannot
+ * \`require()\` it — resolve the absolute path and use dynamic \`import()\`, exactly as
+ * \`claim-check-hook.cjs\` does. Unresolvable ⇒ the hook is inert (exit 0), never a block.
+ */
+async function loadCoreModule(fileName, predicate) {
+  const candidates = [
+    ...(CORE_DIST_DIR ? [path.join(CORE_DIST_DIR, fileName)] : []),
+    path.join(PROJECT, 'node_modules', '@dzhechkov', 'harness-core', 'dist', fileName),
+    path.join(PROJECT, 'packages', '@dzhechkov', 'harness-core', 'dist', fileName),
+  ];
+  for (const c of candidates) {
+    if (!fs.existsSync(c)) continue;
+    try {
+      const mod = await import(pathToFileURL(c).href);
+      if (predicate(mod)) return mod;
+    } catch {
+      /* try the next candidate */
+    }
+  }
+  return undefined;
+}
+
+async function loadPolicy() {
+  return loadCoreModule('recall-hook-policy.js', (mod) => typeof mod.selectHookHits === 'function');
+}
+
+/**
+ * Retro admission-debt directive (feature narrated-error-must-be-taught, ADR-001 D2/D3). The Stop
+ * hook's scan-tail arms \`.dz/retro-pending.json\` when the assistant admitted an error without a
+ * teach; THIS hook confronts the assistant on the very next prompt. Contract:
+ *  - sentinel absent ⇒ '' and ZERO extra work beyond one existsSync (the no-noise pin — output
+ *    stays byte-identical to a build without this feature);
+ *  - stale / other-session sentinel ⇒ '' (the debt belongs to a dead session; retro collected it);
+ *  - core module absent or old (no directive exports) ⇒ '' — inert, NEVER-BLOCK.
+ */
+const RETRO_PENDING = path.join(PROJECT, '.dz', 'retro-pending.json');
+async function retroDebtDirective(payload) {
+  if (!fs.existsSync(RETRO_PENDING)) return '';
+  const sentinel = safe(() => JSON.parse(fs.readFileSync(RETRO_PENDING, 'utf-8')), undefined);
+  if (!sentinel || typeof sentinel.snippet !== 'string' || sentinel.snippet === '') return '';
+  const mod = await loadCoreModule(
+    'session-retro.js',
+    (m) => typeof m.renderRetroDebtDirective === 'function' && typeof m.retroSentinelIsFresh === 'function',
+  );
+  if (!mod) return '';
+  return safe(() => {
+    const ctx = {
+      sessionId: payload && typeof payload.session_id === 'string' ? payload.session_id : undefined,
+      transcriptPath: payload && typeof payload.transcript_path === 'string' ? payload.transcript_path : undefined,
+      nowMs: Date.now(),
+    };
+    return mod.retroSentinelIsFresh(sentinel, ctx) ? String(mod.renderRetroDebtDirective(sentinel)) : '';
+  }, '');
+}
+
+async function loadUsagePolicy() {
+  return loadCoreModule('recall-usage.js', (mod) => typeof mod.formatRecallUsageRecord === 'function');
+}
+
+/** The event-chain primitives (ADR-001). Absent ⇒ records are written UNCHAINED, never blocked. */
+async function loadChainPolicy() {
+  return loadCoreModule('event-chain.js', (mod) => typeof mod.appendChainedLines === 'function' && typeof mod.guardedRewrite === 'function');
+}
+
+/**
+ * Tail facts of the usage log, read from its END — O(1) in the file size. The apply-leg hook runs on
+ * EVERY prompt, so re-reading the whole log per append would be a per-turn tax that eventually gets
+ * the hook switched off. Unreadable ⇒ the empty tail, and the caller starts a marked chain segment.
+ */
+function readLogTail(chain, file) {
+  return safe(() => {
+    if (!chain || typeof chain.readTailInfo !== 'function') return undefined;
+    if (!fs.existsSync(file)) return chain.EMPTY_LOG_TAIL;
+    const fd = fs.openSync(file, 'r');
+    try {
+      const size = fs.fstatSync(fd).size;
+      if (!Number.isFinite(size) || size <= 0) return chain.EMPTY_LOG_TAIL;
+      const want = Math.min(size, Number(chain.EVENT_CHAIN_TAIL_BYTES) || 65536);
+      const buf = Buffer.alloc(want);
+      fs.readSync(fd, buf, 0, want, size - want);
+      return chain.readTailInfo(buf.toString('utf-8'), { partial: want < size });
+    } finally {
+      try { fs.closeSync(fd); } catch { /* nothing to do */ }
+    }
+  }, chain && chain.EMPTY_LOG_TAIL);
+}
+
+function askDaemon(prompt) {
+  return new Promise((resolve) => {
+    if (!fs.existsSync(SOCKET)) return resolve(undefined);
+    let settled = false;
+    const done = (v) => {
+      if (settled) return;
+      settled = true;
+      safe(() => sock.destroy());
+      resolve(v);
+    };
+    const sock = net.connect(SOCKET);
+    const timer = setTimeout(() => done(undefined), TIMEOUT_MS);
+    timer.unref?.();
+    let buf = '';
+    sock.on('connect', () => sock.write(JSON.stringify({ op: 'recall', prompt, limit: 8 }) + '\\n'));
+    sock.on('data', (chunk) => {
+      buf += chunk.toString('utf8');
+      const nl = buf.indexOf('\\n');
+      if (nl === -1) return;
+      clearTimeout(timer);
+      const msg = safe(() => JSON.parse(buf.slice(0, nl)), undefined);
+      done(msg && Array.isArray(msg.hits) ? msg.hits : undefined);
+    });
+    sock.on('error', () => {
+      clearTimeout(timer);
+      done(undefined);
+    });
+  });
+}
+
+const REVIVE_LOCK = path.join(PROJECT, '.dz', 'embed-daemon.lock');
+const REVIVE_LOCK_FRESH_MS = 120_000; // model load takes ~45s; don't respawn while one is coming up
+function reviveDaemon() {
+  // CROSS-PROCESS lock: every prompt runs a fresh hook process, so a per-process flag let 20 queued
+  // prompts spawn 20 daemons while the first was still loading its model (Codex #5). A lockfile with
+  // a freshness window means at most one spawn per window, machine-wide.
+  safe(() => {
+    fs.mkdirSync(path.dirname(REVIVE_LOCK), { recursive: true });
+    // ATOMIC acquisition: \`wx\` fails if the lock exists — stat-then-write let every concurrent hook
+    // observe "no fresh lock" and spawn its own daemon (the exact burst this lock exists to stop).
+    try {
+      fs.writeFileSync(REVIVE_LOCK, String(process.pid), { flag: 'wx' });
+    } catch {
+      // Lock exists. Stale (older than the freshness window) → steal it by rewrite; fresh → yield.
+      try {
+        const st = fs.statSync(REVIVE_LOCK);
+        if (Date.now() - st.mtimeMs < REVIVE_LOCK_FRESH_MS) return;
+        fs.writeFileSync(REVIVE_LOCK, String(process.pid));
+      } catch {
+        return; // cannot inspect the lock — yield rather than storm
+      }
+    }
+    const { spawn } = require('child_process');
+    const daemon = path.join(PROJECT, '.claude', 'helpers', 'dz-embed-daemon.mjs');
+    if (!fs.existsSync(daemon)) return;
+    const child = spawn(process.execPath, [daemon], { detached: true, stdio: 'ignore' });
+    child.unref();
+  }, undefined);
+}
+
+function recordUsage(hits, usage, query, chain) {
+  safe(() => {
+    const ts = new Date().toISOString();
+    // One PROMPT = one event: the report must count prompts, not injected-hit rows (up to 3 per
+    // prompt), or readiness is fabricated from multiplicity.
+    const eventId = ts + ':' + Math.random().toString(36).slice(2, 10);
+    const records = [];
+    for (const h of hits || []) {
+      if (typeof h?.dzId !== 'string' || h.dzId.trim() === '') continue;
+      // query + runId make the log REPLAYABLE: without them it can say a lesson was used but never
+      // say for what, which made cold-vs-warm measurement unbuildable from the recorded history.
+      const runId = process.env.CLAUDE_CODE_SESSION_ID || undefined;
+      const full = typeof query === 'string' ? query.trim() : '';
+      const q = full !== '' ? full.slice(0, 200) : undefined;
+      // A truncated prefix cannot REPRODUCE the original recall — flagged so the report excludes it
+      // from replay readiness instead of counting a false pair.
+      const queryTruncated = full.length > 200 ? true : undefined;
+      const input = { dzId: h.dzId, score: h.score, ts, query: q, runId, eventId, queryTruncated };
+      const rec =
+        usage && typeof usage.buildRecallUsageRecord === 'function'
+          ? usage.buildRecallUsageRecord(input)
+          : { dzId: h.dzId, score: h.score, ts, ...(q ? { query: q } : {}), ...(runId ? { runId } : {}), eventId, ...(queryTruncated ? { queryTruncated } : {}) };
+      if (rec && typeof rec === 'object') records.push(rec);
+    }
+    if (records.length === 0) return;
+    // event-chain (ADR-001): seq + prevHash from the LAST LINE ONLY. If the chain module is absent
+    // (a broken install) the records are still written, unchained — a hole verify will name, which
+    // is the honest outcome; never-block outranks chain completeness.
+    const payload =
+      chain && typeof chain.appendChainedLines === 'function'
+        ? chain.appendChainedLines(records, readLogTail(chain, USAGE_LOG))
+        : records.map((r) => JSON.stringify(r) + '\\n').join('');
+    if (typeof payload !== 'string' || payload === '') return;
+    fs.mkdirSync(path.dirname(USAGE_LOG), { recursive: true });
+    fs.appendFileSync(USAGE_LOG, payload, 'utf-8');
+    compactUsageLogIfNeeded(usage, chain, ts);
+  }, undefined);
+}
+
+const COMPACT_LOCK = \`\${USAGE_LOG}.compact.lock\`;
+/** A compaction is milliseconds of work; anything older than this is a crashed holder. */
+const COMPACT_LOCK_FRESH_MS = 30_000;
+
+/**
+ * ATOMIC \`wx\` acquisition with a staleness window — the same pattern the daemon-revive lock uses.
+ * \`wx\` fails when the file exists, so two hooks cannot both believe they hold it (a stat-then-write
+ * check let every concurrent hook observe "free" and proceed, which is the burst this prevents).
+ */
+// The lock TOKEN identifies the owner: release must only ever remove the holder's OWN lock, and a
+// stale steal must be an atomic claim, not an overwrite two stealers can both "win" (Codex re-QE MED).
+const COMPACT_LOCK_TOKEN = \`\${process.pid}.\${Math.floor(Math.random() * 0xffffffff).toString(16)}\`;
+function acquireCompactLock() {
+  return (
+    safe(() => {
+      try {
+        fs.writeFileSync(COMPACT_LOCK, COMPACT_LOCK_TOKEN, { flag: 'wx' });
+        return true;
+      } catch {
+        const st = fs.statSync(COMPACT_LOCK); // throws ⇒ vanished ⇒ treat as busy, try next prompt
+        if (Date.now() - st.mtimeMs < COMPACT_LOCK_FRESH_MS) return false;
+        // Stale: unlink, then RE-RACE through \`wx\` — of N concurrent stealers exactly one wins;
+        // a plain overwrite here let every stealer proceed and each believed it held the lock.
+        try { fs.unlinkSync(COMPACT_LOCK); } catch { /* someone else already removed it */ }
+        fs.writeFileSync(COMPACT_LOCK, COMPACT_LOCK_TOKEN, { flag: 'wx' }); // throws ⇒ lost the race ⇒ busy
+        return true;
+      }
+    }, false) === true
+  );
+}
+/** Release ONLY our own lock: a token mismatch means a stealer legitimately took over — leave it. */
+function releaseCompactLock() {
+  safe(() => {
+    if (fs.readFileSync(COMPACT_LOCK, 'utf-8') === COMPACT_LOCK_TOKEN) fs.unlinkSync(COMPACT_LOCK);
+  }, undefined);
+}
+
+/** Append a one-line note where a human (and \`dz doctor\`) will see it. Best-effort, never blocks. */
+function noteEvent(event, detail) {
+  safe(() => {
+    fs.appendFileSync(
+      path.join(PROJECT, '.dz', 'sessions.jsonl'),
+      JSON.stringify({ event, ts: new Date().toISOString(), ...detail }) + '\\n',
+    );
+  }, undefined);
+}
+
+/**
+ * Compaction is the only path that REWRITES the evidence log, so it is the only path that can lose
+ * an append. It runs behind \`guardedRewrite\`: an exclusive lock, plus a re-read of the live file
+ * after computing the new text and before the rename — an append that landed in between aborts the
+ * attempt and is folded into the retry rather than being overwritten by it (Codex QE CRITICAL-1).
+ */
+function compactUsageLogIfNeeded(usage, chain, ts) {
+  safe(() => {
+    if (!usage || typeof usage.compactRecallUsageLogChecked !== 'function') return;
+    const maxBytes = Number(process.env.DZ_RECALL_USAGE_MAX_BYTES || usage.RECALL_USAGE_LOG_MAX_BYTES || 1048576);
+    const st = fs.statSync(USAGE_LOG);
+    const shouldCompact =
+      typeof usage.shouldCompactRecallUsageLogSize === 'function'
+        ? usage.shouldCompactRecallUsageLogSize(st.size, maxBytes)
+        : st.size > maxBytes;
+    if (!shouldCompact) return;
+    if (!chain || typeof chain.guardedRewrite !== 'function') return; // no guard ⇒ no rewrite
+
+    const io = {
+      read: () => safe(() => fs.readFileSync(USAGE_LOG, 'utf-8'), undefined),
+      replace: (text) => {
+        const tmp = \`\${USAGE_LOG}.\${process.pid}.tmp\`;
+        fs.writeFileSync(tmp, text, 'utf-8');
+        fs.renameSync(tmp, USAGE_LOG);
+      },
+      acquireLock: acquireCompactLock,
+      releaseLock: () => releaseCompactLock(),
+    };
+    const result = chain.guardedRewrite(io, (text) => {
+      const r = usage.compactRecallUsageLogChecked(text, { maxBytes, compactedAt: ts });
+      return { text: r.text, refusedDirty: r.status === 'refused-dirty', defects: r.defects };
+    });
+    // A refusal or a persistent race is a FINDING about the evidence base, not a no-op to swallow.
+    if (result.status === 'refused-dirty' || result.status === 'raced') {
+      noteEvent('recall-usage-compaction-' + result.status, {
+        attempts: result.attempts,
+        defects: (result.defects || []).slice(0, 3).map((d) => \`\${d.kind}@L\${d.line}\`),
+      });
+    }
+  }, undefined);
+}
+
+/** Emit additionalContext when non-empty; silence otherwise (the floor contract). */
+function emitContext(context) {
+  if (typeof context !== 'string' || context === '') return;
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: context },
+    }) + '\\n',
+  );
+}
+
+async function main() {
+  const raw = readStdin();
+  const payload = safe(() => JSON.parse(String(raw || '').trim()), undefined);
+  const prompt = extractPrompt(raw);
+
+  // The retro debt directive rides EVERY early-return path below: a down daemon or an empty prompt
+  // must not swallow the confrontation — the debt is independent of recall relevance. When the
+  // sentinel is absent this is one existsSync and debt === '' (byte-identical outputs to before).
+  const debt = await retroDebtDirective(payload);
+
+  if (prompt === '') return emitContext(debt);
+
+  const policy = await loadPolicy();
+  if (!policy) return emitContext(debt);
+
+  const hits = await askDaemon(prompt);
+  if (!hits) {
+    // SELF-HEAL (2026-07-28): the daemon is started at SessionStart only, so when it dies mid-way
+    // through a long-lived session NOTHING restarts it — the apply leg was silently dead for 19
+    // days (MEASURED: recall-usage.jsonl last record 2026-07-09, socket absent). Spawn it
+    // fire-and-forget so the NEXT prompt has it; this prompt stays uninjected (never-block).
+    reviveDaemon();
+    return emitContext(debt);
+  }
+  if (hits.length === 0) return emitContext(debt); // daemon alive, nothing relevant — silence is correct
+
+  const selection = policy.selectHookHits(prompt, hits);
+  // lesson-quarantine AM-2: an excluded hypothesis is logged, never a silent context shrink.
+  if (typeof selection.quarantinedExcluded === 'number' && selection.quarantinedExcluded > 0) {
+    try {
+      fs.appendFileSync(
+        path.join(PROJECT, '.dz', 'sessions.jsonl'),
+        JSON.stringify({ event: 'quarantine-excluded', ts: new Date().toISOString(), count: selection.quarantinedExcluded }) + '\\n',
+      );
+    } catch { /* best-effort */ }
+  }
+  const context = policy.renderHookContext(selection);
+  // The debt directive is PREPENDED so it is the first thing the model reads (before other work).
+  const combined = debt === '' ? context : context === '' ? debt : \`\${debt}\\n\${context}\`;
+  if (combined === '') return; // nothing cleared the floor — the whole point
+  emitContext(combined);
+
+  if (context !== '') {
+    const usage = await loadUsagePolicy();
+    const chain = await loadChainPolicy();
+    recordUsage(selection.hits, usage, prompt, chain);
+  }
+}
+
+main()
+  .catch(() => {})
+  .finally(() => process.exit(0));
+`;
+}
+/** `setTimeout`'s delay argument is a 32-bit signed int in Node — see {@link resolveIdleMs}. */
+export const IDLE_MS_INT32_MAX = 2_147_483_647;
+/**
+ * Pure mirror of the `IDLE_MS` resolution inlined into {@link embedDaemonSource}'s generated body
+ * (AM-10, dz-harness-hub issue #10 defect 7). Extracted (fix round 1, review Codex C, LOW finding)
+ * so the clamp/disable rule is unit-testable directly — the review noted the only prior proof was a
+ * LIVE process observed via its first stderr log line, which shows the log fired but not that the
+ * underlying arithmetic is right for every input class.
+ *
+ * A template string cannot `import` this function into the daemon's own runtime (it is generated
+ * text, not compiled code), so {@link embedDaemonSource} keeps its OWN copy of the same three rules —
+ * `apply-leg-twins.test.ts` pins the generated body to the same `IDLE_MS_INT32_MAX` constant this
+ * module exports, so the two cannot drift apart silently.
+ */
+export function resolveIdleMs(raw) {
+    if (!Number.isFinite(raw) || raw <= 0)
+        return { value: null, clamped: false };
+    if (raw > IDLE_MS_INT32_MAX)
+        return { value: IDLE_MS_INT32_MAX, clamped: true };
+    return { value: raw, clamped: false };
+}
+/**
+ * Generate `.claude/helpers/dz-embed-daemon.mjs`. Behaviourally identical to the pre-existing
+ * hand-committed hub file except for: the version stamp (new, line 2) and `resolveDeps()`, which
+ * now tries `@huggingface/transformers` before falling back to `@xenova/transformers` — AM-3,
+ * dz-harness-hub issue #10 defect 3: `agentdb >= 3.0.0-alpha` depends on the former, and an older
+ * agentdb install still carries the latter, so probing only one name silently starved the daemon
+ * on either side of that agentdb version boundary.
+ */
+export function embedDaemonSource() {
+    return `#!/usr/bin/env node
+// dz-apply-leg-version: ${APPLY_LEG_VERSION}
+/**
+ * Resident embedding + recall daemon for the \`dz recall\` APPLY leg.
+ *
+ * WHY IT EXISTS (measured, not assumed): loading the multilingual embedder costs ~1478 ms, while a
+ * warm embed of a query costs 6–8 ms. A \`UserPromptSubmit\` hook is a fresh process every turn, so
+ * without a resident model the hook would add ~2 s to every prompt and be switched off within a day.
+ * With this daemon the hook is a socket round-trip.
+ *
+ * ORPHAN SAFETY — the load-bearing property. Today (2026-07-09) two orphaned agentdb MCP servers,
+ * 19 h and 7 h old, were found rewriting a SQLite file whole-file several times per second and
+ * corrupting concurrent readers. A resident process that outlives its purpose is a liability. So:
+ *
+ *   - it EXITS after \`DZ_EMBED_IDLE_MS\` (default 30 min) with no request;
+ *   - it refuses to start if a live daemon already owns the socket (no duplicate herd);
+ *   - it removes a stale socket left by a crashed predecessor;
+ *   - it opens the pattern store READ-ONLY — it can never be the writer that tears a file;
+ *   - it exits on SIGINT/SIGTERM/SIGHUP and unlinks its socket.
+ *
+ * PROTOCOL — newline-delimited JSON over a unix socket:
+ *   → {"op":"recall","prompt":"…","limit":8}    ← {"hits":[{"dzId","pattern","score","domain"}]}
+ *   → {"op":"ping"}                              ← {"ok":true,"model":"…","uptimeMs":N}
+ *   → {"op":"stop"}                              ← {"ok":true}   (then exits)
+ *
+ * \`score\` is COSINE RELEVANCE in [0,1] — never the teaching reward. The caller applies the floor.
+ */
+
+import { createServer } from 'node:net';
+import { existsSync, unlinkSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createRequire } from 'node:module';
+import { connect } from 'node:net';
+
+const log = (...a) => console.error('[dz-embed]', ...a);
+
+/** Never let a diagnostic reach stdout — the hook that spawns us may be parsing it. */
+console.log = (...a) => console.error(...a);
+
+const PROJECT = process.env['DZ_PROJECT_ROOT'] ?? process.cwd();
+const SOCKET = process.env['DZ_EMBED_SOCKET'] ?? join(PROJECT, '.dz', 'embed.sock');
+// AM-10 (issue #10 defect 7): a setTimeout delay is a 32-bit signed int in Node — anything
+// above 2_147_483_647 ms silently becomes ~1ms (a "30 days" idle setting exited in ~1 second,
+// MEASURED). 0/NaN/negative disables the idle exit outright rather than firing immediately.
+const IDLE_MS_INT32_MAX = 2_147_483_647;
+const IDLE_MS_RAW = Number(process.env['DZ_EMBED_IDLE_MS'] ?? 30 * 60 * 1000);
+let IDLE_MS;
+if (!Number.isFinite(IDLE_MS_RAW) || IDLE_MS_RAW <= 0) {
+  IDLE_MS = null;
+  log('idle exit disabled (DZ_EMBED_IDLE_MS=' + IDLE_MS_RAW + ')');
+} else if (IDLE_MS_RAW > IDLE_MS_INT32_MAX) {
+  IDLE_MS = IDLE_MS_INT32_MAX;
+  log('idle clamp: ' + IDLE_MS_RAW + ' -> ' + IDLE_MS_INT32_MAX + ' ms');
+} else {
+  IDLE_MS = IDLE_MS_RAW;
+}
+const MODEL_FALLBACK = 'Xenova/paraphrase-multilingual-MiniLM-L12-v2';
+
+function configuredModel() {
+  try {
+    const cfg = JSON.parse(readFileSync(join(PROJECT, '.dz', 'config.json'), 'utf-8'));
+    const m = cfg?.memory?.agentdb?.embeddingModel ?? cfg?.memory?.embed?.model;
+    return typeof m === 'string' && m.trim() !== '' ? m.trim() : MODEL_FALLBACK;
+  } catch {
+    return MODEL_FALLBACK;
+  }
+}
+
+/** Is a daemon already listening? Resolves true only on a successful connect. */
+function socketAlive(path) {
+  return new Promise((resolve) => {
+    if (!existsSync(path)) return resolve(false);
+    const c = connect(path);
+    const done = (v) => {
+      c.destroy();
+      resolve(v);
+    };
+    c.on('connect', () => done(true));
+    c.on('error', () => done(false));
+    setTimeout(() => done(false), 500);
+  });
+}
+
+function resolveDeps() {
+  const req = createRequire(join(PROJECT, 'package.json'));
+  // agentdb >= 3.0.0-alpha depends on '@huggingface/transformers' (the '@xenova/transformers'
+  // fork it supersedes); older agentdb releases still pull '@xenova/transformers'. Neither is a
+  // DIRECT dependency of the project, so try each candidate via the project's own require AND via
+  // agentdb's own declared (possibly hoisted-elsewhere) require before giving up
+  // (dz-harness-hub issue #10 defect 3).
+  const candidates = ['@huggingface/transformers', '@xenova/transformers'];
+  let transformers;
+  let lastErr;
+  for (const name of candidates) {
+    try {
+      transformers = req.resolve(name);
+      break;
+    } catch (err) {
+      lastErr = err;
+      try {
+        transformers = createRequire(req.resolve('agentdb/package.json')).resolve(name);
+        break;
+      } catch (err2) {
+        lastErr = err2;
+      }
+    }
+  }
+  if (transformers === undefined) {
+    throw new Error('neither @huggingface/transformers nor @xenova/transformers could be resolved (' + String((lastErr && lastErr.message) || lastErr) + ')');
+  }
+  return { Database: req('better-sqlite3'), transformers };
+}
+
+const cos = (a, b) => {
+  let s = 0;
+  for (let i = 0; i < a.length; i += 1) s += a[i] * (b[i] ?? 0);
+  return s;
+};
+
+function dzIdOf(metadataJson) {
+  try {
+    const meta = JSON.parse(String(metadataJson || '{}'));
+    const id = meta?.dzId ?? meta?.dreamId;
+    return typeof id === 'string' && id.trim() !== '' ? id.trim() : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// lesson-quarantine: an unproven lesson is flagged so the hook POLICY can exclude it from
+// auto-inject (the daemon only reports; the decision lives in selectHookHits).
+function quarantinedOf(metadataJson) {
+  try {
+    return JSON.parse(String(metadataJson || '{}'))?.qStatus === 'quarantined';
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  if (await socketAlive(SOCKET)) {
+    log('a daemon already owns', SOCKET, '— exiting');
+    process.exit(0);
+  }
+  if (existsSync(SOCKET)) {
+    try {
+      unlinkSync(SOCKET); // stale socket from a crashed predecessor
+    } catch {
+      /* the bind below will fail loudly enough */
+    }
+  }
+
+  const started = Date.now();
+  const model = configuredModel();
+  let deps;
+  try {
+    deps = resolveDeps();
+  } catch (err) {
+    log('deps unavailable — not starting:', err?.message ?? err);
+    process.exit(0); // never a hard failure: the hook degrades to silence
+  }
+
+  const { pipeline } = await import(deps.transformers);
+  const extractor = await pipeline('feature-extraction', model);
+  const embed = async (text) => Array.from((await extractor(text, { pooling: 'mean', normalize: true })).data);
+
+  // READ-ONLY. This process must never be the writer that tears the file for a concurrent reader.
+  const dbPath = join(PROJECT, '.dz', 'agentdb.db');
+  const DZ_TASK_TYPES = ['dz-teach', 'dz-learning'];
+
+  function loadPatterns() {
+    if (!existsSync(dbPath)) return [];
+    const db = new deps.Database(dbPath, { readonly: true, fileMustExist: true });
+    try {
+      const ph = DZ_TASK_TYPES.map(() => '?').join(',');
+      // NOTE: the vector mirror carries no \`domain\` — that column lives in the lexical store. An
+      // earlier draft read \`tags[0]\` and cheerfully labelled every hit \`dz-backfill\`, which is the
+      // SOURCE marker, not a domain. Emitting a wrong label is worse than emitting none.
+      const rows = db
+        .prepare(
+          \`SELECT p.approach AS pattern, p.metadata AS metadata, e.embedding AS embedding
+             FROM reasoning_patterns p JOIN pattern_embeddings e ON e.pattern_id = p.id
+            WHERE p.task_type IN (\${ph})\`,
+        )
+        .all(...DZ_TASK_TYPES);
+      return rows.map((r) => {
+        const buf = r.embedding;
+        const vec = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+        return { dzId: dzIdOf(r.metadata), pattern: r.pattern, vec, quarantined: quarantinedOf(r.metadata) };
+      });
+    } finally {
+      db.close();
+    }
+  }
+
+  let patterns = loadPatterns();
+  let patternsAt = Date.now();
+  log(\`ready: \${patterns.length} pattern vectors, model \${model}, socket \${SOCKET}\`);
+
+  let idleTimer;
+  let lastActivityAt = Date.now();
+  const touch = () => {
+    lastActivityAt = Date.now();
+    clearTimeout(idleTimer);
+    if (IDLE_MS === null) return; // idle exit disabled (AM-10)
+    idleTimer = setTimeout(() => {
+      // Prints the ACTUAL elapsed time, not the configured IDLE_MS — the two used to be treated as
+      // interchangeable, but a clamped or reconfigured value made the log claim a wait that never
+      // happened (AM-10).
+      log(\`idle \${Date.now() - lastActivityAt} ms — exiting (orphan safety)\`);
+      shutdown(0);
+    }, IDLE_MS);
+    idleTimer.unref?.();
+  };
+
+  const server = createServer((sock) => {
+    touch();
+    let buf = '';
+    sock.on('data', async (chunk) => {
+      buf += chunk.toString('utf8');
+      let nl;
+      while ((nl = buf.indexOf('\\n')) !== -1) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        let reply;
+        try {
+          const msg = JSON.parse(line);
+          if (msg.op === 'ping') {
+            reply = { ok: true, model, uptimeMs: Date.now() - started, patterns: patterns.length };
+          } else if (msg.op === 'stop') {
+            sock.write(JSON.stringify({ ok: true }) + '\\n');
+            return shutdown(0);
+          } else if (msg.op === 'recall') {
+            // Reload the mirror if it changed on disk (a \`dz teach\` between turns).
+            if (Date.now() - patternsAt > 5000) {
+              try {
+                patterns = loadPatterns();
+              } catch {
+                /* keep the previous snapshot */
+              }
+              patternsAt = Date.now();
+            }
+            const prompt = typeof msg.prompt === 'string' ? msg.prompt : '';
+            if (prompt.trim() === '' || patterns.length === 0) {
+              reply = { hits: [] };
+            } else {
+              const qv = await embed(prompt);
+              const scored = patterns.map((p) => ({ dzId: p.dzId, pattern: p.pattern, score: cos(qv, p.vec), ...(p.quarantined ? { quarantined: true } : {}) }));
+              scored.sort((a, b) => b.score - a.score);
+              reply = { hits: scored.slice(0, Math.min(Number(msg.limit) || 8, 32)) };
+            }
+          } else {
+            reply = { error: \`unknown op \${String(msg.op)}\` };
+          }
+        } catch (err) {
+          reply = { error: err?.message ?? String(err) };
+        }
+        try {
+          sock.write(JSON.stringify(reply) + '\\n');
+        } catch {
+          /* client vanished */
+        }
+      }
+    });
+    sock.on('error', () => sock.destroy());
+  });
+
+  function shutdown(code) {
+    try {
+      server.close();
+    } catch {
+      /* ignore */
+    }
+    try {
+      if (existsSync(SOCKET)) unlinkSync(SOCKET);
+    } catch {
+      /* ignore */
+    }
+    process.exit(code);
+  }
+
+  for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.on(sig, () => shutdown(0));
+
+  server.listen(SOCKET, () => touch());
+  server.on('error', (err) => {
+    log('listen failed:', err?.message ?? err);
+    process.exit(0);
+  });
+}
+
+main().catch((err) => {
+  log('fatal:', err?.message ?? err);
+  process.exit(0); // a dead daemon must never fail a session
+});
+`;
+}
+/**
+ * The two hook-registry entries `runSetup` merges into `.claude/settings.json` (FR-1). Commands
+ * match the hub's own `.claude/settings.json` verbatim (`grep`-diffed against it at authoring time):
+ * the recall hook is invoked with a swallowed non-zero exit (`|| true`) so a broken hook body never
+ * fails a prompt, and the embed daemon is spawned detached via `nohup` + a backgrounding `sh -c`
+ * so `SessionStart` never waits on model load.
+ */
+export function applyLegHookEntries() {
+    return {
+        userPromptSubmit: {
+            hooks: [{
+                    type: 'command',
+                    command: 'node "${CLAUDE_PROJECT_DIR:-.}/.claude/helpers/recall-hook.cjs" 2>/dev/null || true',
+                }],
+        },
+        sessionStart: {
+            hooks: [{
+                    type: 'command',
+                    command: "sh -c 'nohup node \"${CLAUDE_PROJECT_DIR:-.}/.claude/helpers/dz-embed-daemon.mjs\" >/dev/null 2>&1 & exit 0'",
+                }],
+        },
+    };
+}
+/** Read one deployed helper's exists/version/unreadable facts. Never throws. */
+function readHelperStatus(path) {
+    const exists = existsSync(path);
+    if (!exists)
+        return { exists: false, version: -1 };
+    try {
+        return { exists: true, version: applyLegVersionOf(readFileSync(path, 'utf-8')) };
+    }
+    catch {
+        // Exists but could not be read (EISDIR — e.g. a directory left at the path — EACCES, a
+        // filesystem error mid-read, …). Distinct from absent: `missing-helpers` tells the reader to
+        // run `dz setup`, which does nothing for a file setup cannot even open (fix round 1, Q3).
+        return { exists: true, version: -1, unreadable: true };
+    }
+}
+/**
+ * ONE definition of "this command invokes our helper", shared by the installer (`setup.ts`
+ * `addIfMissing`) and the diagnostics (`applyLegStatus`) so they can never disagree (re-review
+ * Codex, third pass). A bare mention (`echo .claude/helpers/recall-hook.cjs`) is not an invocation:
+ * the helper path must follow a `node` word — directly, or inside the daemon's
+ * `sh -c 'nohup node "…"'` spawn. Forward slashes only: every command dz writes uses them.
+ */
+export function hookCommandInvokes(command, markerPath) {
+    const invoked = new RegExp('(^|[\\s;&|(])node\\s+[\'"]?[^\\s\'"]*' + markerPath.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&'));
+    return invoked.test(command);
+}
+/**
+ * A hook-registry entry naming `markerPath` is wired under `event` in the PARSED settings structure
+ * — never a raw substring scan over the whole file (fix round 1, HIGH finding 1). A comment, an
+ * unrelated field, or the marker under the WRONG event must not read as installed: only an actual
+ * `hooks.<event>[*].hooks[*].command` (or the legacy flat shape `hookCommandsOf` also understands)
+ * containing `markerPath` counts.
+ */
+function hookWiredUnder(settings, event, markerPath) {
+    const hooksSection = settings?.hooks;
+    const list = hooksSection && typeof hooksSection === 'object' ? hooksSection[event] : undefined;
+    if (!Array.isArray(list))
+        return false;
+    // Re-review Codex (B) finding: a bare substring (`echo .claude/helpers/recall-hook.cjs`) is not a
+    // hook. Our entries always INVOKE the helper — `node "<…>/.claude/helpers/<file>"` (directly, or
+    // inside the daemon's `sh -c 'nohup node "…"'`) — so the marker must follow a `node` invocation.
+    return list.some((entry) => hookCommandsOf(entry).some((cmd) => hookCommandInvokes(cmd, markerPath)));
+}
+/**
+ * Measure the apply leg's actual state in `root` — plain `fs` reads, no injection (mirrors
+ * `writerVersionOf`'s own read style): a diagnostic that needed dependency injection to be testable
+ * would be a diagnostic nobody could point at a REAL project either. Never throws (fix round 1, Q3):
+ * an unreadable helper is a named fact in the return value, not an exception that would otherwise
+ * blow through `dz doctor`'s outer try/catch (silence) or crash `dz parity` outright.
+ */
+export function applyLegStatus(root) {
+    const recallHookPath = join(root, '.claude', 'helpers', 'recall-hook.cjs');
+    const embedDaemonPath = join(root, '.claude', 'helpers', 'dz-embed-daemon.mjs');
+    const recallHook = readHelperStatus(recallHookPath);
+    const embedDaemon = readHelperStatus(embedDaemonPath);
+    let userPromptSubmitPresent = false;
+    let sessionStartPresent = false;
+    try {
+        const settings = JSON.parse(readFileSync(join(root, '.claude', 'settings.json'), 'utf-8'));
+        userPromptSubmitPresent = hookWiredUnder(settings, 'UserPromptSubmit', '.claude/helpers/recall-hook.cjs');
+        sessionStartPresent = hookWiredUnder(settings, 'SessionStart', '.claude/helpers/dz-embed-daemon.mjs');
+    }
+    catch {
+        // settings.json absent, unreadable, or not valid JSON — both stay false, the honest answer.
+    }
+    let backend = 'unknown';
+    try {
+        const cfg = JSON.parse(readFileSync(join(root, '.dz', 'config.json'), 'utf-8'));
+        if (cfg.memory?.backend === 'agentdb')
+            backend = 'agentdb';
+        else if (cfg.memory?.backend === 'jsonl')
+            backend = 'jsonl';
+    }
+    catch {
+        // config.json absent or unreadable — 'unknown' is the honest answer, not a guess.
+    }
+    const anyUnreadable = recallHook.unreadable === true || embedDaemon.unreadable === true;
+    const helpersPresent = recallHook.exists && embedDaemon.exists;
+    const helpersCurrent = helpersPresent && !anyUnreadable && recallHook.version >= APPLY_LEG_VERSION && embedDaemon.version >= APPLY_LEG_VERSION;
+    const hooksPresent = userPromptSubmitPresent && sessionStartPresent;
+    const installed = helpersCurrent && hooksPresent;
+    let reason;
+    if (!installed) {
+        reason = anyUnreadable
+            ? 'unreadable'
+            : !helpersPresent
+                ? 'missing-helpers'
+                : !helpersCurrent
+                    ? 'stale-version'
+                    : 'hooks-missing';
+    }
+    return {
+        installed,
+        ...(reason !== undefined ? { reason } : {}),
+        helpers: {
+            recallHook: { path: recallHookPath, exists: recallHook.exists, version: recallHook.version, ...(recallHook.unreadable ? { unreadable: true } : {}) },
+            embedDaemon: { path: embedDaemonPath, exists: embedDaemon.exists, version: embedDaemon.version, ...(embedDaemon.unreadable ? { unreadable: true } : {}) },
+        },
+        hooks: {
+            userPromptSubmit: { present: userPromptSubmitPresent },
+            sessionStart: { present: sessionStartPresent },
+        },
+        backend,
+    };
+}
+/**
+ * Human remedy text shared VERBATIM between `dz doctor` and `dz parity` for the two reasons this
+ * fix round adds machinery for (fix round 1, HIGH finding 2 / Q3 finding 7): `stale-version` and
+ * `unreadable`. Both instruments read the SAME {@link ApplyLegStatus}; routing them through the same
+ * text-producing function is what makes "тексты совпадают по причине" a structural guarantee rather
+ * than two hand-written strings that happen to agree today. The `missing-helpers`/`hooks-missing`
+ * wording is deliberately NOT unified here — `dz doctor` and `dz parity` already carried different
+ * (pre-existing, tested) phrasing for that case before this fix round, and unifying it was not asked.
+ */
+export function applyLegReasonMessage(status) {
+    if (status.reason === 'stale-version') {
+        const deployedMin = Math.min(status.helpers.recallHook.version, status.helpers.embedDaemon.version);
+        return `installed v${deployedMin}, current v${APPLY_LEG_VERSION} — re-run dz setup to upgrade (no --force needed)`;
+    }
+    if (status.reason === 'unreadable') {
+        const bad = [status.helpers.recallHook, status.helpers.embedDaemon]
+            .filter((h) => h.unreadable === true)
+            .map((h) => h.path);
+        return `cannot read deployed helper(s): ${bad.join(', ')} — fix or remove it and re-run: dz setup --target claude-code --memory agentdb`;
+    }
+    return 'not installed — run dz setup --target claude-code --memory agentdb';
+}
+//# sourceMappingURL=apply-leg.js.map