@dzhechkov/harness-core 0.4.4 → 0.5.0

package/src/guard.ts

@@ -73,6 +73,19 @@ export interface GuardFacts {
   readonly skillPacks?: readonly { readonly name: string; readonly nonRegistrable: readonly string[] }[];
   /** for readme-first: per publishable package, is a version bump staged without a README change? */
   readonly readmeFirst?: readonly { readonly name: string; readonly versionBumped: boolean; readonly readmeChanged: boolean }[];
+  /**
+   * for agents-md-policy-sync: result of the pure policy drift detector, gathered by the CLI.
+   * `applicable:false` is a repo whose canonical policy sources are unreadable; omission means the
+   * gatherer could not obtain evidence. `fenced` says whether the repo OPTED IN — i.e. its AGENTS.md
+   * already carries a `dz:policies` fence. The two combine to separate a repo that is out of scope
+   * (never opted in — silent) from one that opted in and then lost its sources (loud), so the shared
+   * `notes` channel does not carry a permanent "not applicable" line in every consumer repo.
+   */
+  readonly policyDrift?: {
+    readonly applicable: boolean;
+    readonly drifted: readonly string[];
+    readonly fenced?: boolean;
+  };
   /**
    * for lockfile-in-sync: what each workspace package DECLARES vs what pnpm-lock.yaml RECORDS for that
    * importer. `parsed:false` (or the fact absent) ⇒ the rule reports nothing — fail-open by construction,
@@ -227,6 +240,7 @@ export const DEFAULT_RULES: readonly GuardRule[] = [
   { id: 'readme-consistency', severity: 'soft', ops: ['publish'], description: 'README counts agree (CJM header vs All Commands, etc.)' },
   { id: 'skills-registrable', severity: 'soft', ops: ['publish'], description: 'every skill directory in a skill pack has a depth-1 SKILL.md (a buried or missing one ships un-registrable — the health-advisor 1.2.0 class)' },
   { id: 'readme-first', severity: 'soft', ops: ['publish'], description: 'a package with a staged version bump must update its own README.md in the same change (README-first)' },
+  { id: 'agents-md-policy-sync', severity: 'soft', ops: ['publish'], description: 'proves the AGENTS.md copy is in SYNC with its source — not that the runtime read or obeyed it; heal drift with dz agents-sync' },
   { id: 'lockfile-in-sync', severity: 'soft', ops: ['publish'], description: 'every workspace @dzhechkov/* dependency spec matches the specifier pnpm-lock.yaml records for that importer (a dep bump without a lockfile refresh breaks CI with ERR_PNPM_OUTDATED_LOCKFILE). SOFT-ONLY — a config cannot promote it to HARD' },
   { id: 'store-bloat-cap', severity: 'soft', ops: ['teach', 'consolidate'], description: 'the learned store is within its size cap' },
   // Description ASSEMBLED from STUB_MARKERS so guard.ts itself stays clean under the scan it defines
@@ -323,6 +337,16 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
     }
     return out;
   },
+  'agents-md-policy-sync': (f, _sev) => {
+    const fact = f.policyDrift;
+    if (!fact || fact.applicable !== true || !Array.isArray(fact.drifted)) return [];
+    const drifted = fact.drifted.filter((item) => typeof item === 'string');
+    return drifted.length === 0 ? [] : [{
+      rule: 'agents-md-policy-sync',
+      severity: 'soft',
+      detail: `${drifted.length} AGENTS.md policy section(s) are out of sync: ${drifted.slice(0, 8).join(', ')}${drifted.length > 8 ? '…' : ''} — heal with: dz agents-sync`,
+    }];
+  },
   'lockfile-in-sync': (f, _sev) => {
     // The 2026-07-28 CI break, mechanized: an overnight dep bump edited package.json and left
     // pnpm-lock.yaml stale, so `pnpm install --frozen-lockfile` died with ERR_PNPM_OUTDATED_LOCKFILE.
@@ -417,7 +441,7 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
  * may not understand a file, and "I might be wrong" plus "block the publish" is the wrong pair. Disabling
  * such a rule stays allowed — only the promotion is refused.
  */
-export const SOFT_ONLY_RULES: readonly string[] = ['lockfile-in-sync'];
+export const SOFT_ONLY_RULES: readonly string[] = ['lockfile-in-sync', 'agents-md-policy-sync'];
 
 /**
  * A well-formed PROMOTED rule: an id the engine does not know, made enforceable by a template +
@@ -533,6 +557,17 @@ export function evaluateGuard(facts: GuardFacts, rules: readonly GuardRule[] = D
       notes.push(`no-stubs: ${skipped} changed scannable file(s) not scanned (deleted/oversize/unreadable/beyond the file cap) — the stub scan is fail-open, so this is a coverage gap on the record, not a violation`);
     }
   }
+  if (checked.includes('agents-md-policy-sync')) {
+    // A repo that never opted in (no `dz:policies` fence in AGENTS.md) is OUT OF SCOPE, not
+    // inconclusive — noting it on every run would put a permanent line in a channel that exists to
+    // flag genuine coverage gaps, and a note that is always there is a note nobody reads.
+    // Opted in but sources unreadable IS a gap, and stays loud.
+    if (facts.policyDrift === undefined) {
+      notes.push('agents-md-policy-sync: policy drift evidence was unavailable; the advisory rule skipped with a recorded coverage gap, not a silent pass');
+    } else if (facts.policyDrift.applicable !== true && facts.policyDrift.fenced === true) {
+      notes.push('agents-md-policy-sync: this repository carries a dz:policies fence but its canonical policy sources are unreadable — the advisory rule could not compare, and that gap is on the record, not a silent pass');
+    }
+  }
   return { op, verdict, violations, checked, ...(notes.length > 0 ? { notes } : {}) };
 }
 

package/src/index.ts

@@ -24,8 +24,10 @@ export {
   GATE_FEATURE_IDS,
   computeParity,
   buildParityMatrix,
+  CAPABILITY_EVIDENCE,
+  findUnbackedCapabilities,
 } from './parity.js';
-export type { RuntimeCapability, FeatureForm, ParityFeature, ParityCell, ParityMatrixRow } from './parity.js';
+export type { RuntimeCapability, FeatureForm, ParityFeature, ParityCell, ParityMatrixRow, CapabilityEvidence, UnbackedCapability } from './parity.js';
 export * from './operations.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
@@ -196,6 +198,9 @@ export {
   serializeTrainingPair,
   trainingPairPath,
   trainingPairAppendCmd,
+  // wave1-instrument-repair (ADR-003 Condition 3): the persist allowlist + composite shape check.
+  codeCheckpointPersistAllowed,
+  codeStageResultShapeValid,
 } from './feature-adr-checkpoints.js';
 export type { CheckpointStage, CheckpointEntry, ResumeMode, ResumeDecision, ParsedCheckpointRead, TrainingPairFamily, TrainingPair, TrainingPairEvaluation, TrainingPairProvenance, TrainingPairTruncation } from './feature-adr-checkpoints.js';
 export {
@@ -257,6 +262,9 @@ export {
   shouldCompactRecallUsageLogSize,
   compactRecallUsageLog,
   compactRecallUsageLogChecked,
+  appendRecallUsage,
+  runtimeOf,
+  RUNTIMES,
 } from './recall-usage.js';
 export type {
   RecallUsageReadRecord,
@@ -271,7 +279,74 @@ export type {
   CompactRecallUsageOptions,
   CompactRecallUsageResult,
   CompactRecallUsageStatus,
+  AppendRecallUsageInput,
+  AppendRecallUsageHit,
+  Runtime,
 } from './recall-usage.js';
+
+/* crossrt-2-codex-hooks (leg 2 of umbrella 98ed3967) */
+export { mergeManagedHookEntries, hookCommandsOf } from './managed-hooks.js';
+export type { HookMergePlan, MergeManagedHookOptions, ManagedHookEntry } from './managed-hooks.js';
+export {
+  CODEX_MANAGED_HOOKS,
+  DZ_HOOK_HELPER_VERSION,
+  DZ_HOOK_TIMEOUT_SECONDS,
+  DZ_VETO_MATCHER,
+  buildHookCommand,
+  buildManagedEntries,
+  buildCodexHookManifest,
+  codexHooksPaths,
+  diffCodexHooks,
+  emitterWriteSet,
+  expectedTrustKey,
+  isDzManagedEntry,
+  isSafeForSingleQuote,
+  looksLikeDzEntry,
+  managedByEvent,
+  parseCodexRegistry,
+  parseCodexHookManifest,
+  planCodexHooks,
+  removeCodexHooks,
+  renderTrustBlock,
+  runtimeWriteSet,
+  selectOwnHookMetadata,
+  serializeCodexRegistry,
+  codexHookSha256,
+  trustEventName,
+  upsertTrustBlock,
+} from './codex-hooks.js';
+export type {
+  CodexHookEvent,
+  CodexHookId,
+  CodexHookManifest,
+  CodexHookManifestEntry,
+  CodexHooksPaths,
+  CodexHooksPlan,
+  CodexRegistry,
+  DriftReport,
+  HooksListHookMetadata,
+  HookTrustRow,
+  ManagedEntry,
+} from './codex-hooks.js';
+export {
+  DZ_VETO_MARKER,
+  DZ_VETO_WARN_MARKER,
+  RUNTIME_BLOCK_PHRASE,
+  classifyTrust,
+  classifyVetoProbe,
+  isReadyVerdict,
+  verifyExitCode,
+} from './codex-hooks-verify.js';
+export type {
+  CodexHookTrustStatus,
+  VetoProbeEvidence,
+  VetoProbeResult,
+  VetoTrust,
+  VetoVerdict,
+} from './codex-hooks-verify.js';
+export { SHELL_VETO_RULE_ID, resolveVetoMode, vetoShellCommand } from './shell-veto-policy.js';
+export type { VetoHit, VetoMode } from './shell-veto-policy.js';
+export { generateCodexHelpers, generateCodexRecallHelper, generateCodexVetoHelper } from './codex-hooks-assets.js';
 export {
   EVENT_CHAIN_SCOPE,
   EVENT_CHAIN_GENESIS_HASH,
@@ -423,9 +498,47 @@ export {
   needsCodeLandedBarrier,
   codeLandedBarrierPlan,
   codeLandedBarrierHasLanded,
+  // decideCodeLanding was NEVER in this named list (a pre-existing omission found by the ADR-002
+  // Confirmation-1 sweep). Its `predicate` union NARROWS in this release, which is a breaking change
+  // to a published output type — so it has to actually BE published to be honest about it.
+  decideCodeLanding,
   CODE_LANDED_BARRIER_SLEEPS_SECONDS,
+  // wave1-instrument-repair (ADR-003): the landed-barrier honesty surface. This list is NAMED, so a
+  // missing entry silently drops the export from the published package — ADR-002 Confirmation 1 is
+  // the test that catches exactly that.
+  LANDING_PROTOCOL_VERSION,
+  LANDING_HASH_TOKEN,
+  addExpectedCodeTarget,
+  extractExpectedCodeTargetsFromText,
+  sourceExpectedCodeTargets,
+  validateExpectedTargetsBlock,
+  posixCksum,
+  verifyPreCodeBaseline,
+  preCodeBaselineCaptureCmd,
+  parseBaselineCapture,
+  CODE_LANDING_PREDICATES,
+  parseLandingSignal,
+  codeLandingProbeCmd,
+} from './feature-adr-routing.js';
+export type {
+  StageOpts,
+  RoutingEnv,
+  UsageSignal,
+  UsageAction,
+  CodeLandingStatus,
+  CodeStageLandingStatus,
+  LandingInconclusiveReason,
+  CodeLandedBarrierPlan,
+  CodeLandingSnapshot,
+  CodeLandingDecision,
+  SourcedCodeTargets,
+  ExpectedTargetRejectReason,
+  ExpectedTargetsValidation,
+  BaselineEntry,
+  BaselineVerification,
+  ParsedBaselineCapture,
+  ParsedLandingSignal,
 } from './feature-adr-routing.js';
-export type { StageOpts, RoutingEnv, UsageSignal, UsageAction } from './feature-adr-routing.js';
 export {
   CLAUDE_USAGE_MODELS,
   computeUsage,
@@ -497,6 +610,9 @@ export * from './model-recommender.js';
 export * from './bto-optimize.js';
 export * from './discrimination-gate.js';
 export * from './guard.js';
+// Root AGENTS.md policy projection: pure anchor extraction/render/hash drift +
+// the shared-emitter I/O entry point exported from operations.
+export * from './agents-policy.js';
 // Lesson → guard-rule PROMOTION (feature guard-promotion, scout idea #1) — the cost-of-detection
 // ladder's elevator: moves a lesson from layer 5 (agent memory) to layer 1 (a deterministic rule),
 // but only after TWO consecutive shadow wins replayed over REAL commits. Never synthesises rule code.

package/src/loop-blobs.generated.ts

@@ -79,11 +79,11 @@ export const BLOBS: Record<string, LoopBlob> = {
   "codex-dispatch": {
     name: "codex-dispatch",
     version: "1.0.0",
-    contentHash: "e6a608d2856287aa4db2b2db769d2e7ea3ec76b6c7cf299d2e233b4d9d90d0cf",
+    contentHash: "140da3714d2507683b0a27fcb01fa449ea3cb1619f1a2e181aaf24291397642d",
     sourcePath: "packages/@dzhechkov/harness-core/src/feature-adr-routing.ts",
     requires: [],
     exports: ["codexDispatchMode","codexExecPlan","needsCodeLandedBarrier","decideCodeLanding"],
-    code: "const CODE_LANDING_PIPELINE_PREFIXES = ['features/', '.dz/', '.agentic-qe/', 'roam/'];\nfunction codeLandingEmptySignal(seconds) {\n    return 'changed=0 after ' + seconds + 's — genuinely not landed';\n}\nfunction needsCodeLandedBarrier(coderUsed) {\n    return coderUsed === 'codex' || coderUsed === 'codex-fallback';\n}\nfunction normalizeCodeLandingPath(path) {\n    let p = String(path || '').trim().replace(/\\\\/g, '/');\n    while (p.indexOf('./') === 0)\n        p = p.slice(2);\n    p = p.replace(/\\/+/g, '/');\n    if (!p)\n        return '';\n    if (p[0] === '/')\n        return '';\n    if (p === '..' || p.indexOf('../') === 0 || p.indexOf('/../') >= 0 || p.endsWith('/..'))\n        return '';\n    if (/[\\0\\r\\n\\t \"'\\x60$;&|<>*?()[\\]{}!]/.test(p))\n        return '';\n    if (p.endsWith('/'))\n        return '';\n    for (const prefix of CODE_LANDING_PIPELINE_PREFIXES) {\n        const bare = prefix.slice(0, -1);\n        if (p === bare || p.indexOf(prefix) === 0)\n            return '';\n    }\n    return p;\n}\nfunction filterPollableCodePaths(paths) {\n    const out = [];\n    const seen = new Set();\n    for (const path of paths) {\n        const normalized = normalizeCodeLandingPath(path);\n        if (!normalized || seen.has(normalized))\n            continue;\n        seen.add(normalized);\n        out.push(normalized);\n    }\n    return out;\n}\nfunction decideCodeLanding(snapshot) {\n    const maxWaitMs = Math.max(0, snapshot.maxWaitMs);\n    const elapsedMs = Math.max(0, snapshot.elapsedMs);\n    const elapsedSeconds = Math.floor(elapsedMs / 1000);\n    const expectedPaths = filterPollableCodePaths(snapshot.expectedPaths);\n    const changedPaths = filterPollableCodePaths(snapshot.changedEntries.map((entry) => entry.path));\n    const changed = new Set(changedPaths);\n    const matchedExpectedPaths = expectedPaths.filter((path) => changed.has(path));\n    if (expectedPaths.length > 0 && matchedExpectedPaths.length > 0) {\n        return {\n            status: 'landed',\n            changed: matchedExpectedPaths.length,\n            elapsedMs,\n            elapsedSeconds,\n            expectedPaths,\n            matchedExpectedPaths,\n            changedPaths,\n            predicate: 'expected-path',\n            qeSignalLine: 'CODEX-LANDING-SIGNAL status=landed changed=' +\n                matchedExpectedPaths.length +\n                ' after=' +\n                elapsedSeconds +\n                's predicate=expected-path matched=' +\n                matchedExpectedPaths.join(','),\n        };\n    }\n    if (expectedPaths.length === 0 && changedPaths.length > 0) {\n        return {\n            status: 'landed',\n            changed: changedPaths.length,\n            elapsedMs,\n            elapsedSeconds,\n            expectedPaths,\n            matchedExpectedPaths,\n            changedPaths,\n            predicate: 'any-code-change',\n            qeSignalLine: 'CODEX-LANDING-SIGNAL status=landed changed=' +\n                changedPaths.length +\n                ' after=' +\n                elapsedSeconds +\n                's predicate=any-code-change',\n        };\n    }\n    if (elapsedMs < maxWaitMs) {\n        return {\n            status: 'not-yet-flushed',\n            changed: 0,\n            elapsedMs,\n            elapsedSeconds,\n            expectedPaths,\n            matchedExpectedPaths: [],\n            changedPaths,\n            predicate: 'empty-before-timeout',\n            qeSignalLine: 'CODEX-LANDING-SIGNAL status=not-yet-flushed changed=0 after ' + elapsedSeconds + 's — not yet flushed',\n        };\n    }\n    const terminalSeconds = Math.ceil(maxWaitMs / 1000);\n    return {\n        status: 'genuinely-not-landed',\n        changed: 0,\n        elapsedMs,\n        elapsedSeconds: terminalSeconds,\n        expectedPaths,\n        matchedExpectedPaths: [],\n        changedPaths,\n        predicate: 'empty-after-timeout',\n        qeSignalLine: 'CODEX-LANDING-SIGNAL status=genuinely-not-landed ' + codeLandingEmptySignal(terminalSeconds),\n    };\n}\nconst WRAPPER_STAGES = { code: 1, plan: 1 };\nfunction codexDispatchMode(stage) {\n    return WRAPPER_STAGES[stage] ? 'wrapper' : 'exec';\n}\nconst CODEX_EXEC_PROMPT_CEILING_CHARS = 24000;\nfunction codexExecPlan(input) {\n    if (codexDispatchMode(input.stage) === 'wrapper') {\n        return { mode: 'wrapper', reason: 'deliverable is a file written out-of-band' };\n    }\n    if (!input.probedId) {\n        return { mode: 'claude', reason: 'no codex model id answered the probe' };\n    }\n    if (input.promptChars > CODEX_EXEC_PROMPT_CEILING_CHARS) {\n        return {\n            mode: 'claude',\n            reason: 'prompt is ' +\n                input.promptChars +\n                ' chars, over the ' +\n                CODEX_EXEC_PROMPT_CEILING_CHARS +\n                '-char codex exec ceiling (it would stall)',\n        };\n    }\n    return { mode: 'exec', reason: 'codex exec on ' + input.probedId };\n}",
+    code: "const CODE_LANDING_PIPELINE_PREFIXES = ['features/', '.dz/', '.agentic-qe/', 'roam/'];\nfunction codeLandingEmptySignal(seconds) {\n    return 'changed=0 after ' + seconds + 's — genuinely not landed';\n}\nfunction needsCodeLandedBarrier(coderUsed) {\n    return coderUsed === 'codex' || coderUsed === 'codex-fallback';\n}\nfunction stripCodeLandingPath(path) {\n    let p = String(path || '').trim().replace(/\\\\/g, '/');\n    while (p.indexOf('./') === 0)\n        p = p.slice(2);\n    return p.replace(/\\/+/g, '/');\n}\nfunction classifyCodeLandingPathReject(path) {\n    const p = stripCodeLandingPath(path);\n    if (!p)\n        return 'empty-after-strip';\n    if (p[0] === '/')\n        return 'absolute-path';\n    if (p === '..' || p.indexOf('../') === 0 || p.indexOf('/../') >= 0 || p.endsWith('/..'))\n        return 'traversal';\n    if (/[\\0\\r\\n\\t \"'\\x60$;&|<>*?()[\\]{}!]/.test(p))\n        return 'not-a-path';\n    if (p.endsWith('/'))\n        return 'not-a-path';\n    for (const prefix of CODE_LANDING_PIPELINE_PREFIXES) {\n        const bare = prefix.slice(0, -1);\n        if (p === bare || p.indexOf(prefix) === 0)\n            return 'pipeline-artifact-path';\n    }\n    return null;\n}\nfunction normalizeCodeLandingPath(path) {\n    return classifyCodeLandingPathReject(path) === null ? stripCodeLandingPath(path) : '';\n}\nfunction filterPollableCodePaths(paths) {\n    const out = [];\n    const seen = new Set();\n    for (const path of paths || []) {\n        const normalized = normalizeCodeLandingPath(path);\n        if (!normalized || seen.has(normalized))\n            continue;\n        seen.add(normalized);\n        out.push(normalized);\n    }\n    return out;\n}\nfunction isNewlyChanged(path, baseline, currentHashes) {\n    if (!baseline || !baseline.ok)\n        return false;\n    let recorded = null;\n    for (const entry of baseline.entries) {\n        if (entry.path === path) {\n            recorded = entry.hash;\n            break;\n        }\n    }\n    if (recorded === null)\n        return true;\n    const now = currentHashes ? currentHashes[path] : undefined;\n    if (now === undefined)\n        return false;\n    return now !== recorded;\n}\nfunction decideCodeLanding(snapshot) {\n    const maxWaitMs = Math.max(0, snapshot.maxWaitMs);\n    const elapsedMs = Math.max(0, snapshot.elapsedMs);\n    const elapsedSeconds = Math.floor(elapsedMs / 1000);\n    const expectedPaths = filterPollableCodePaths(snapshot.expectedPaths);\n    const changedPaths = filterPollableCodePaths(snapshot.changedEntries.map(function (entry) { return entry.path; }));\n    if (expectedPaths.length === 0) {\n        return {\n            status: 'inconclusive',\n            reason: 'empty-plan-block',\n            changed: 0,\n            elapsedMs: elapsedMs,\n            elapsedSeconds: elapsedSeconds,\n            expectedPaths: expectedPaths,\n            matchedExpectedPaths: [],\n            changedPaths: changedPaths,\n            predicate: 'no-expected-targets',\n            qeSignalLine: 'CODEX-LANDING-SIGNAL status=inconclusive predicate=no-expected-targets reason=empty-plan-block',\n        };\n    }\n    const baseline = snapshot.baseline;\n    if (!baseline || !baseline.ok) {\n        const reason = baseline && baseline.reason ? baseline.reason : 'no-baseline';\n        return {\n            status: 'inconclusive',\n            reason: reason,\n            changed: 0,\n            elapsedMs: elapsedMs,\n            elapsedSeconds: elapsedSeconds,\n            expectedPaths: expectedPaths,\n            matchedExpectedPaths: [],\n            changedPaths: changedPaths,\n            predicate: 'newly-changed',\n            qeSignalLine: 'CODEX-LANDING-SIGNAL status=inconclusive predicate=newly-changed reason=' + reason,\n        };\n    }\n    const changed = new Set(changedPaths);\n    const matchedExpectedPaths = expectedPaths.filter(function (path) {\n        return changed.has(path) && isNewlyChanged(path, baseline, snapshot.currentHashes);\n    });\n    if (matchedExpectedPaths.length > 0) {\n        return {\n            status: 'landed',\n            changed: matchedExpectedPaths.length,\n            elapsedMs: elapsedMs,\n            elapsedSeconds: elapsedSeconds,\n            expectedPaths: expectedPaths,\n            matchedExpectedPaths: matchedExpectedPaths,\n            changedPaths: changedPaths,\n            predicate: 'newly-changed',\n            qeSignalLine: 'CODEX-LANDING-SIGNAL status=landed changed=' +\n                matchedExpectedPaths.length +\n                ' after=' +\n                elapsedSeconds +\n                's predicate=newly-changed matched=' +\n                matchedExpectedPaths.join(','),\n        };\n    }\n    if (elapsedMs < maxWaitMs) {\n        return {\n            status: 'not-yet-flushed',\n            changed: 0,\n            elapsedMs: elapsedMs,\n            elapsedSeconds: elapsedSeconds,\n            expectedPaths: expectedPaths,\n            matchedExpectedPaths: [],\n            changedPaths: changedPaths,\n            predicate: 'empty-before-timeout',\n            qeSignalLine: 'CODEX-LANDING-SIGNAL status=not-yet-flushed changed=0 after ' + elapsedSeconds + 's — not yet flushed',\n        };\n    }\n    const terminalSeconds = Math.ceil(maxWaitMs / 1000);\n    return {\n        status: 'genuinely-not-landed',\n        changed: 0,\n        elapsedMs: elapsedMs,\n        elapsedSeconds: terminalSeconds,\n        expectedPaths: expectedPaths,\n        matchedExpectedPaths: [],\n        changedPaths: changedPaths,\n        predicate: 'empty-after-timeout',\n        qeSignalLine: 'CODEX-LANDING-SIGNAL status=genuinely-not-landed ' + codeLandingEmptySignal(terminalSeconds),\n    };\n}\nconst WRAPPER_STAGES = { code: 1, plan: 1 };\nfunction codexDispatchMode(stage) {\n    return WRAPPER_STAGES[stage] ? 'wrapper' : 'exec';\n}\nconst CODEX_EXEC_PROMPT_CEILING_CHARS = 24000;\nfunction codexExecPlan(input) {\n    if (codexDispatchMode(input.stage) === 'wrapper') {\n        return { mode: 'wrapper', reason: 'deliverable is a file written out-of-band' };\n    }\n    if (!input.probedId) {\n        return { mode: 'claude', reason: 'no codex model id answered the probe' };\n    }\n    if (input.promptChars > CODEX_EXEC_PROMPT_CEILING_CHARS) {\n        return {\n            mode: 'claude',\n            reason: 'prompt is ' +\n                input.promptChars +\n                ' chars, over the ' +\n                CODEX_EXEC_PROMPT_CEILING_CHARS +\n                '-char codex exec ceiling (it would stall)',\n        };\n    }\n    return { mode: 'exec', reason: 'codex exec on ' + input.probedId };\n}",
   },
   "challenge-panel": {
     name: "challenge-panel",

package/src/managed-hooks.ts

@@ -0,0 +1,129 @@
+/**
+ * The ONE event-level managed-hook merge (`crossrt-2-codex-hooks`, AM-3 / G-E).
+ *
+ * Both hook targets — Claude Code's `.claude/settings.json` and Codex's
+ * `$CODEX_HOME/hooks.json` — need the same operation: per event, KEEP every entry that is not ours
+ * (byte-identical, same order) and append the entries that are. Before this module the Claude half
+ * lived inline in `setup.ts` and the Codex half did not exist; a second dialect would have been the
+ * obvious way to write it and the wrong one.
+ *
+ * What differs between the targets is ONLY the attribution predicate, so that is the parameter:
+ * the Claude path passes its historical substring list verbatim (bytes must not move — AM-3), the
+ * Codex path passes sha-over-manifest (ADR-001 §3: dz never deletes what it cannot prove it wrote).
+ *
+ * The plan (AM-37) is explicit that the extracted block has **three** outputs, not one: the merged
+ * body, the REPORT tail string, and the no-write path (`changed === false`). A golden test on the
+ * merged bytes alone would pass while the report text and the no-write behaviour silently changed,
+ * so all three are part of {@link HookMergePlan}.
+ *
+ * Pure: no I/O, no clock, no environment.
+ *
+ * @packageDocumentation
+ */
+
+/** One hook registry entry, in either the matcher-group or the legacy flat shape. */
+export type ManagedHookEntry = unknown;
+
+/**
+ * Commands of a hook entry in EITHER shape: the valid matcher-group form
+ * `{matcher?, hooks:[{type,command}]}` or the legacy flat `{type,command}`.
+ *
+ * Deliberately duplicated from `setup.ts`'s `commandsOf` rather than imported: `setup.ts` imports
+ * this module, and the reverse edge would be a cycle. The two are pinned equal by a test.
+ */
+export function hookCommandsOf(entry: ManagedHookEntry): string[] {
+  const e = entry as { command?: unknown; hooks?: { command?: unknown }[] };
+  if (Array.isArray(e?.hooks)) return e.hooks.map((h) => String(h?.command ?? ''));
+  return [String(e?.command ?? '')];
+}
+
+export interface HookMergePlan {
+  /** The merged registry body, ready to serialize. */
+  readonly hooks: Record<string, ManagedHookEntry[]>;
+  /** False ⇒ the caller must NOT write (the `hooks already current` no-write path — AM-37). */
+  readonly changed: boolean;
+  /** The setup REPORT tail string. Part of the extracted block's contract, not decoration (AM-37). */
+  readonly report: string;
+  /** A legacy-shaped entry of ours was replaced (drives the Claude report wording). */
+  readonly replacedLegacy: boolean;
+  /** Entries kept because they are NOT ours, across the WHOLE registry. G-D's number. */
+  readonly foreignPreserved: number;
+  /**
+   * Entries that RESEMBLE ours but are not attributable to the manifest. They are KEPT and counted —
+   * never deleted (ADR-001 §3). Distinct from `replacedLegacy`, which is about our OWN old vintages.
+   */
+  readonly unattributable: number;
+}
+
+export interface MergeManagedHookOptions {
+  /** True ⇒ this entry is OURS and is replaced by the managed set for that event. */
+  readonly isManaged: (entry: ManagedHookEntry, event: string) => boolean;
+  /**
+   * True ⇒ this entry resembles ours but could not be attributed. Optional; when omitted nothing is
+   * counted. Never causes deletion — only counting and a warning upstream.
+   */
+  readonly looksLikeOurs?: (entry: ManagedHookEntry, event: string) => boolean;
+  /** True ⇒ this OURS entry was in a legacy shape/vintage (Claude path only). */
+  readonly isLegacy?: (entry: ManagedHookEntry, event: string) => boolean;
+  /** e.g. `'agentdb'` → `merged agentdb hooks (user hooks preserved)`. */
+  readonly reportLabel?: string;
+  /** Report text when nothing changed. */
+  readonly unchangedReport?: string;
+}
+
+/**
+ * Merge `managed` into `existingHooks` at EVENT level.
+ *
+ * - Events absent from `managed` are copied through untouched (including unknown ones), and their
+ *   entries still count toward `foreignPreserved` — the number answers "how many of the user's
+ *   entries did this registry hold and keep", not "how many survived the touched events".
+ * - Within a touched event, non-ours entries keep their relative order and object identity, then
+ *   the managed entries are appended.
+ * - `merge(merge(x)) === merge(x)`.
+ */
+export function mergeManagedHookEntries(
+  existingHooks: Record<string, ManagedHookEntry[]> | undefined,
+  managed: Record<string, ManagedHookEntry[]>,
+  options: MergeManagedHookOptions,
+): HookMergePlan {
+  const source = existingHooks ?? {};
+  const hooks: Record<string, ManagedHookEntry[]> = {};
+  for (const event of Object.keys(source)) {
+    hooks[event] = Array.isArray(source[event]) ? [...(source[event] as ManagedHookEntry[])] : [];
+  }
+
+  // Census FIRST, over the whole input, so the counts do not depend on which events are touched.
+  let foreignPreserved = 0;
+  let unattributable = 0;
+  for (const [event, entries] of Object.entries(source)) {
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (options.isManaged(entry, event)) continue;
+      foreignPreserved += 1;
+      if (options.looksLikeOurs?.(entry, event) === true) unattributable += 1;
+    }
+  }
+
+  let changed = false;
+  let replacedLegacy = false;
+  for (const event of Object.keys(managed)) {
+    const current = Array.isArray(hooks[event]) ? (hooks[event] as ManagedHookEntry[]) : [];
+    const kept = current.filter((entry) => {
+      const ours = options.isManaged(entry, event);
+      if (ours && options.isLegacy?.(entry, event) === true) replacedLegacy = true;
+      return !ours;
+    });
+    const next = [...kept, ...(managed[event] ?? [])];
+    if (JSON.stringify(next) !== JSON.stringify(current)) changed = true;
+    hooks[event] = next;
+  }
+
+  const label = options.reportLabel ?? 'managed';
+  const report = !changed
+    ? (options.unchangedReport ?? 'hooks already current')
+    : replacedLegacy
+      ? `replaced legacy dz hooks with ${label} hooks`
+      : `merged ${label} hooks (user hooks preserved)`;
+
+  return { hooks, changed, report, replacedLegacy, foreignPreserved, unattributable };
+}

package/src/mutation-gate.ts

@@ -317,6 +317,26 @@ function stripSgr(s: string): string {
 
 export type RunnerKind = 'node-test' | 'vitest' | 'unknown';
 
+/**
+ * Which runner's output shape is this? Extracted VERBATIM from `classifyRunFailure`'s two shape
+ * checks so the discrimination gate's evidence model can identify the runner of a GREEN run too —
+ * `classifyRunFailure` classifies RED runs only (its green branch returns a red-worded
+ * 'unrecognised'), so it cannot answer "which runner produced this pass?".
+ *
+ * ONE regex family per package (the ADR-001 driver): every runner-shape regex in harness-core
+ * lives here, and discrimination-gate.ts consumes this function instead of growing a second copy.
+ * Detection is from the OUTPUT SHAPE, not the command (an `npm test` alias hides the runner):
+ * node --test needs the TAP header AND node's `# duration_ms` trailer (tape emits TAP + `# fail`
+ * but not `# duration_ms`); vitest needs its `RUN v<semver>` banner or `Test Files` summary line.
+ * Anything else is 'unknown' — the honest, narrowed gap, never a silent trust mint.
+ */
+export function detectRunnerKind(rawOutput: string): RunnerKind {
+  const output = stripSgr(rawOutput);
+  if (/^TAP version \d+/m.test(output) && /^#\s*duration_ms\s+[\d.]+/m.test(output)) return 'node-test';
+  if (/^\s*RUN\s+v\d+\./m.test(output) || /^\s*Test Files\s/m.test(output)) return 'vitest';
+  return 'unknown';
+}
+
 export interface RunFailureClassification {
   /** which runner's output shape was recognised. */
   readonly runner: RunnerKind;
@@ -373,9 +393,11 @@ export interface RunFailureClassification {
  */
 export function classifyRunFailure(rawOutput: string): RunFailureClassification {
   const output = stripSgr(rawOutput);
+  // shape detection is shared with the discrimination gate's evidence model (detectRunnerKind above).
+  const runner = detectRunnerKind(rawOutput);
 
   // node --test (flat TAP, node ≥ 20 shape measured on v22.22.0)
-  if (/^TAP version \d+/m.test(output) && /^#\s*duration_ms\s+[\d.]+/m.test(output)) {
+  if (runner === 'node-test') {
     const lines = output.split('\n');
     let sawNotOk = false;
     for (let i = 0; i < lines.length; i++) {
@@ -407,7 +429,7 @@ export function classifyRunFailure(rawOutput: string): RunFailureClassification
   }
 
   // vitest (`vitest run`, shape measured on 3.2.4)
-  if (/^\s*RUN\s+v\d+\./m.test(output) || /^\s*Test Files\s/m.test(output)) {
+  if (runner === 'vitest') {
     const failedSuites = /\bFailed Suites\s+(\d+)\b/.exec(output);
     const suiteFail = /^\s*FAIL\s+(\S+)\s+\[\s*\1\s*\]/m.exec(output);
     if (failedSuites !== null || suiteFail !== null) {