@dzhechkov/harness-core 0.8.6 → 0.8.11

package/src/lesson-generalization.ts

@@ -0,0 +1,115 @@
+import { createHash } from 'node:crypto';
+
+export type LessonForm = 'specific' | 'class';
+export type LessonMatchedForm = 'specific' | 'class' | 'both';
+
+export interface LessonFormsInput {
+  readonly specific: string;
+  readonly classForm?: string;
+  readonly classAdvisory?: string;
+}
+
+export interface LessonFormRankedHit<T> {
+  readonly key: string;
+  readonly value: T;
+  readonly matchedForm: LessonForm;
+}
+
+export interface MergedLessonFormHit<T> {
+  readonly key: string;
+  readonly value: T;
+  readonly matchedForm: LessonMatchedForm;
+  readonly score: number;
+}
+
+export function normalizeLessonForms(specific: string, classInput?: unknown): LessonFormsInput {
+  if (classInput === undefined || (typeof classInput === 'string' && classInput.trim() === '')) {
+    return { specific };
+  }
+  if (typeof classInput !== 'string') {
+    return { specific, classAdvisory: 'class form must be text; the specific lesson was kept' };
+  }
+  return { specific, classForm: classInput.trim() };
+}
+
+function normalizedText(value: string): string {
+  return value.normalize('NFC').toLocaleLowerCase('und').replace(/\s+/gu, ' ').trim();
+}
+
+function escapedLiteral(value: string): string {
+  return normalizedText(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\s+/g, '\\s+');
+}
+
+export function validateClassTemplate(
+  specific: string,
+  classTemplate: string,
+): { readonly ok: true } | { readonly ok: false; readonly reason: string } {
+  const slot = /:([A-Za-z][A-Za-z0-9_-]*)/g;
+  const parts: string[] = [];
+  let slots = 0;
+  let cursor = 0;
+  for (const match of classTemplate.matchAll(slot)) {
+    const index = match.index ?? 0;
+    const literal = classTemplate.slice(cursor, index);
+    if (literal.includes(':')) return { ok: false, reason: 'invalid :slot name' };
+    parts.push(escapedLiteral(literal), '(.+?)');
+    slots += 1;
+    cursor = index + match[0].length;
+  }
+  const tail = classTemplate.slice(cursor);
+  if (tail.includes(':')) return { ok: false, reason: 'invalid :slot name' };
+  if (slots === 0) return { ok: false, reason: 'class form must contain at least one :slot' };
+  parts.push(escapedLiteral(tail));
+  try {
+    return new RegExp(`^${parts.join('')}$`, 'u').test(normalizedText(specific))
+      ? { ok: true }
+      : { ok: false, reason: 'class form does not syntactically cover the specific lesson' };
+  } catch {
+    return { ok: false, reason: 'class form contains an invalid template' };
+  }
+}
+
+export function lessonPairIdOf(specific: string, classTemplate: string, ts: string): string {
+  const digest = createHash('sha256')
+    .update(`${specific}\u0000${classTemplate}\u0000${ts}`)
+    .digest('hex')
+    .slice(0, 16);
+  return `lesson-pair:${digest}`;
+}
+
+export function mergeLessonMatchedForms(
+  left: LessonMatchedForm | undefined,
+  right: LessonMatchedForm | undefined,
+): LessonMatchedForm | undefined {
+  if (left === undefined) return right;
+  if (right === undefined || left === right) return left;
+  return 'both';
+}
+
+export function mergeLessonFormHits<T>(
+  specificHits: readonly LessonFormRankedHit<T>[],
+  classHits: readonly LessonFormRankedHit<T>[],
+  limit: number,
+): MergedLessonFormHit<T>[] {
+  interface Acc { value: T; specific: boolean; classForm: boolean; score: number }
+  const merged = new Map<string, Acc>();
+  const add = (hit: LessonFormRankedHit<T>, rank: number): void => {
+    const current = merged.get(hit.key) ?? { value: hit.value, specific: false, classForm: false, score: 0 };
+    if (hit.matchedForm === 'specific') current.specific = true;
+    else current.classForm = true;
+    current.score += 1 / (60 + rank + 1);
+    merged.set(hit.key, current);
+  };
+  specificHits.forEach(add);
+  classHits.forEach(add);
+  const safeLimit = Number.isFinite(limit) ? Math.max(0, Math.trunc(limit)) : merged.size;
+  return [...merged.entries()]
+    .sort((a, b) => b[1].score - a[1].score || a[0].localeCompare(b[0]))
+    .slice(0, safeLimit)
+    .map(([key, hit]) => ({
+      key,
+      value: hit.value,
+      matchedForm: hit.specific && hit.classForm ? 'both' : hit.classForm ? 'class' : 'specific',
+      score: hit.score,
+    }));
+}

package/src/mutation-gate.ts

@@ -108,6 +108,10 @@ export interface MutationObservation {
   readonly rebaselineExitCode?: number | null;
   /** named no-exit reason for the restored-tree attribution run, when it produced none. */
   readonly rebaselineFailureReason?: string;
+  /** parsed failing files from a RED restored-tree run; absent when no red rebaseline ran. */
+  readonly rebaselineAttribution?: BaselineAttribution;
+  /** bounded log proving an internal runner failure received at most one retry. */
+  readonly internalAttemptLog?: string;
 }
 
 export interface MutationEntryResult {
@@ -135,6 +139,60 @@ export interface MutationEntryResult {
   readonly detail: string;
 }
 
+// ── Internal runner crash containment — exactly one retry, both attempts observable ───────────
+
+export type InternalRunnerAttemptOutcome = 'completed' | 'runner-internal-error';
+
+export interface InternalRunnerAttempt {
+  readonly attempt: 1 | 2;
+  readonly outcome: InternalRunnerAttemptOutcome;
+  readonly detail: string;
+}
+
+export interface InternalRunnerRetryResult<T> {
+  /** The completed attempt's value. null means both attempts threw internally. */
+  readonly value: T | null;
+  readonly attempts: readonly InternalRunnerAttempt[];
+  /** Closed by construction: a runner receives either zero retries or exactly one. */
+  readonly internalRetries: 0 | 1;
+  /** Named reason consumed by the existing no-exit → INCONCLUSIVE arm. */
+  readonly failureReason?: `runner-internal-error: ${string}`;
+}
+
+function internalRunnerErrorHead(error: unknown): string {
+  const raw = error instanceof Error ? error.message : String(error);
+  const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() || 'unknown internal runner error';
+  return Array.from(firstLine).slice(0, 160).join('');
+}
+
+/**
+ * Run one internal runner invocation. Only a THROWN internal error is retried; normal green/red
+ * observations and ordinary no-exit observations are values and therefore never retried.
+ */
+export function runWithOneInternalRetry<T>(runner: () => T): InternalRunnerRetryResult<T> {
+  const attempts: InternalRunnerAttempt[] = [];
+  for (const attempt of [1, 2] as const) {
+    try {
+      const value = runner();
+      attempts.push({ attempt, outcome: 'completed', detail: `attempt ${attempt}: completed` });
+      return { value, attempts, internalRetries: attempt === 1 ? 0 : 1 };
+    } catch (error) {
+      const head = internalRunnerErrorHead(error);
+      attempts.push({
+        attempt,
+        outcome: 'runner-internal-error',
+        detail: `attempt ${attempt}: runner-internal-error: ${head}`,
+      });
+    }
+  }
+  return {
+    value: null,
+    attempts,
+    internalRetries: 1,
+    failureReason: 'runner-internal-error: persistent after 2/2 attempts',
+  };
+}
+
 // ── Registry parsing — declarative DATA, validated loudly ─────────────────────────────────────
 
 const SAFE_ID = /^[a-z0-9][a-z0-9-]{0,79}$/;
@@ -495,21 +553,114 @@ export function classifyRunFailure(rawOutput: string): RunFailureClassification
 
 // ── Baseline (rule 3's runnability half) ──────────────────────────────────────────────────────
 
+export type BaselineAttributionSource = 'node-test' | 'vitest' | 'unparseable';
+
+export interface BaselineAttribution {
+  readonly parsedFrom: BaselineAttributionSource;
+  /** Package-relative failing paths, in first-seen order. */
+  readonly failingFiles: readonly string[];
+  /** Failing paths that match a registry file exactly (or by package-relative suffix). */
+  readonly covered: readonly string[];
+  /** Failing paths with no matching registry file. */
+  readonly extraneous: readonly string[];
+}
+
+function normaliseReportedFile(raw: string): string | null {
+  let value = raw.trim().replace(/^['"]|['"]$/g, '').replace(/:\d+(?::\d+)?$/, '');
+  value = value.replace(/\\/g, '/');
+  const testSegment = value.lastIndexOf('/test/');
+  if (testSegment >= 0) value = value.slice(testSegment + 1);
+  if (!value.includes('/') || !/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(value)) return null;
+  return value;
+}
+
+/** Parse the failing FILE paths already exposed by supported node --test and vitest shapes. */
+export function attributeBaselineRedness(
+  rawOutput: string,
+  registryFiles: readonly string[],
+): BaselineAttribution {
+  const output = stripSgr(rawOutput);
+  const files: string[] = [];
+  const add = (raw: string): void => {
+    const file = normaliseReportedFile(raw);
+    if (file !== null && !files.includes(file)) files.push(file);
+  };
+
+  const vitestMatches = [...output.matchAll(/^\s*FAIL\s+(\S+)/gm)];
+  for (const match of vitestMatches) add(match[1] ?? '');
+
+  const tapMatches = [...output.matchAll(/^not ok \d+\s+-\s+(.+)$/gm)];
+  for (const match of tapMatches) add(match[1] ?? '');
+  for (const match of output.matchAll(/^\s*location:\s*['"]([^'"]+)['"]\s*$/gm)) {
+    add(match[1] ?? '');
+  }
+
+  const parsedFrom: BaselineAttributionSource = files.length === 0
+    ? 'unparseable'
+    : vitestMatches.length > 0 ? 'vitest' : 'node-test';
+  if (parsedFrom === 'unparseable') {
+    return { parsedFrom, failingFiles: [], covered: [], extraneous: [] };
+  }
+
+  const normalisedRegistry = registryFiles
+    .map((file) => normaliseReportedFile(file) ?? file.replace(/\\/g, '/'));
+  const covered = files.filter((file) => normalisedRegistry.some((registryFile) =>
+    file === registryFile || file.endsWith(`/${registryFile}`) || registryFile.endsWith(`/${file}`)));
+  const extraneous = files.filter((file) => !covered.includes(file));
+  return { parsedFrom, failingFiles: files, covered, extraneous };
+}
+
+export type BaselineFailureReason =
+  | 'runner-internal-error'
+  | 'runner-no-exit'
+  | 'extraneous-red-in-allowlist'
+  | 'baseline-red-covered-files'
+  | 'baseline-red-files-unparseable';
+
 export interface BaselineResult {
   readonly ok: boolean;
   readonly detail: string;
+  readonly reason?: BaselineFailureReason;
 }
 
 /**
  * A RED baseline in the scratch copy is a SETUP error, never a mutation result: every subsequent
  * "red under mutation" would be noise, and every "green" a lie about an unrunnable copy.
  */
-export function classifyBaseline(exitCode: number | null, runFailureReason?: string): BaselineResult {
+export function classifyBaseline(
+  exitCode: number | null,
+  runFailureReason?: string,
+  attribution?: BaselineAttribution,
+): BaselineResult {
   if (exitCode === 0) return { ok: true, detail: 'baseline suite green in the scratch copy' };
   if (exitCode === null) {
-    return { ok: false, detail: `baseline suite produced no exit code (${runFailureReason ?? 'unknown timeout/spawn failure'}) — the copy is not runnable; fix the copy, do not read this as a mutation result` };
+    const internal = runFailureReason?.startsWith('runner-internal-error:') === true;
+    return {
+      ok: false,
+      reason: internal ? 'runner-internal-error' : 'runner-no-exit',
+      detail: `baseline INCONCLUSIVE — suite produced no exit code (${runFailureReason ?? 'unknown timeout/spawn failure'}) — the copy is not runnable; do not read this as a mutation result`,
+    };
   }
-  return { ok: false, detail: `baseline suite RED (exit ${exitCode}) in the UNMUTATED scratch copy — a broken copy cannot prove anything; fix the copy (node_modules link? path-dependent test?) before trusting any verdict` };
+  if (attribution === undefined || attribution.parsedFrom === 'unparseable') {
+    return {
+      ok: false,
+      reason: 'baseline-red-files-unparseable',
+      detail: `baseline suite RED (exit ${exitCode}) in the UNMUTATED scratch copy — failing files: unparseable from runner output — the broken copy cannot prove anything`,
+    };
+  }
+  const failing = `failing files: ${attribution.failingFiles.join(', ')}`;
+  if (attribution.extraneous.length > 0 && attribution.covered.length === 0) {
+    return {
+      ok: false,
+      reason: 'extraneous-red-in-allowlist',
+      detail: `baseline suite RED (exit ${exitCode}) in the UNMUTATED scratch copy — ${failing} — extraneous red in the testCommand allowlist; the registry entries themselves are not disproven`,
+    };
+  }
+  return {
+    ok: false,
+    reason: 'baseline-red-covered-files',
+    detail: `baseline suite RED (exit ${exitCode}) in the UNMUTATED scratch copy — ${failing} — broken-copy baseline redness touches registry-covered files; fix the copy before evaluating mutations`,
+  };
 }
 
 // ── Classification (rules 1 + 2, and the drop decision) ───────────────────────────────────────
@@ -549,7 +700,7 @@ export function classifyBaseline(exitCode: number | null, runFailureReason?: str
  *     while the contract still holds is the early warning, reported loudly so a human re-pins
  *     `observed` or investigates — silently normalising it would erase the signal.
  */
-export function classifyMutationOutcome(obs: MutationObservation): MutationEntryResult {
+function classifyMutationOutcomeWithoutAttemptLog(obs: MutationObservation): MutationEntryResult {
   const e = obs.entry;
   const minFailing = e.minFailing ?? 1;
   const base = {
@@ -653,12 +804,15 @@ export function classifyMutationOutcome(obs: MutationObservation): MutationEntry
   // not come back green, so the suite is flaky and an unrelated neighbour may be what went red.
   // Not attributable ⇒ INCONCLUSIVE (a failure, never a pass).
   if (obs.rebaselineExitCode !== undefined && obs.rebaselineExitCode !== 0) {
+    const failing = obs.rebaselineAttribution === undefined || obs.rebaselineAttribution.parsedFrom === 'unparseable'
+      ? 'failing files: unparseable from runner output'
+      : `failing files: ${obs.rebaselineAttribution.failingFiles.join(', ')}`;
     return {
       ...base,
       applied: true,
       verdict: 'INCONCLUSIVE',
       drop: false,
-      detail: `suite red under the mutation BUT the restored baseline did not reproduce green (${obs.rebaselineExitCode === null ? `no exit code: ${obs.rebaselineFailureReason ?? 'unknown timeout / spawn failure'}` : `exit ${obs.rebaselineExitCode}`}) — the suite is flaky; the redness is not attributable to the protection and may be an unrelated neighbour`,
+      detail: `suite red under the mutation BUT the restored baseline did not reproduce green (${obs.rebaselineExitCode === null ? `no exit code: ${obs.rebaselineFailureReason ?? 'unknown timeout / spawn failure'}` : `exit ${obs.rebaselineExitCode}`}) — mutation did not revert / flaky restored-tree route; ${failing}; the redness is not attributable to the protection`,
     };
   }
 
@@ -698,6 +852,12 @@ export function classifyMutationOutcome(obs: MutationObservation): MutationEntry
   };
 }
 
+export function classifyMutationOutcome(obs: MutationObservation): MutationEntryResult {
+  const result = classifyMutationOutcomeWithoutAttemptLog(obs);
+  if (obs.internalAttemptLog === undefined) return result;
+  return { ...result, detail: `${result.detail}; ${obs.internalAttemptLog}` };
+}
+
 /** Verdicts that fail the gate. INCONCLUSIVE and NOT_APPLIED fail (inconclusive ≠ pass). */
 const FAILING_VERDICTS: ReadonlySet<MutationVerdict> = new Set(['UNDEFENDED', 'RECEIPT_MISMATCH', 'NOT_APPLIED', 'BELOW_MIN', 'MUTATION_UNPARSEABLE', 'MUTATION_LOAD_FATAL', 'OVER_FAILING', 'INCONCLUSIVE']);
 

package/src/operations.ts

@@ -57,6 +57,17 @@ import { describeSkillLoadFailure, discoverSkillIds, loadSkillFromDir } from './
 import type { SkillApplyFailure, SkillLoadFailure } from './skills.js';
 import { TARGETS } from './targets.js';
 import type { TargetName } from './targets.js';
+import {
+  TARGET_INTEGRATIONS,
+  aggregateIntegrationManifests,
+  notRequestedOutcomes,
+  refusedOutcome,
+  staticPolicyOutcomes,
+  type IntegrationOutcome,
+  type IntegrationManifestSource,
+} from './target-integrations.js';
+import { applyIntegrationFragments, IntegrationApplyError, type IntegrationApplyFault } from './integration-apply.js';
+import { verifyTargetIntegration, type IntegrationProcessPort } from './integrations-verify.js';
 import {
   AGENTS_MD_BUDGET_WARN_FRACTION,
   CODEX_PROJECT_DOC_MAX_BYTES,
@@ -87,6 +98,24 @@ export interface InitOptions {
   readonly select?: readonly string[];
   /** When set, generate platform-specific enrichment files alongside SKILL.md. */
   readonly enrich?: boolean;
+  /** Exact content-bound digest printed by the first integration-aware run. */
+  readonly allowIntegrations?: string;
+  /** Explicit hook opt-out; maps hooks to not-requested. */
+  readonly noHooks?: boolean;
+  /** Explicit skills-only opt-out, even when selected skills carry manifests. */
+  readonly noIntegrations?: boolean;
+  /** Live verification is load-bearing; requesting this flag makes requested integrations refuse. */
+  readonly noVerify?: boolean;
+  /** Injectable process boundary for deterministic integration tests. */
+  readonly integrationProcessPort?: IntegrationProcessPort;
+  /** Test-only fault at the carrier/ownership-journal durability boundary. */
+  readonly integrationApplyFault?: IntegrationApplyFault;
+  /**
+   * Install-level manifest sources. The CLI supplies this only on the first
+   * per-directory run so companion planning, authorization, and probing happen
+   * exactly once across every discovered skill pack.
+   */
+  readonly integrationManifestSources?: readonly IntegrationManifestSource[];
 }
 
 /** Per-skill outcome of {@link runInit}. */
@@ -130,6 +159,10 @@ export interface InitReport {
    * any per-skill loop.
    */
   readonly applyFailures: readonly SkillApplyFailure[];
+  /** Exactly two ordered companion outcomes: MCP, then hooks. */
+  readonly integrations: readonly [IntegrationOutcome, IntegrationOutcome];
+  /** Safe digest used by `--allow-integrations`; absent when no manifest exists. */
+  readonly integrationDigest?: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -266,6 +299,8 @@ export interface AgentsMdInitOptions {
   readonly projectRoot: string;
   /** When set, install only these skill ids (a preset selection). */
   readonly select?: readonly string[] | undefined;
+  readonly noHooks?: boolean;
+  readonly noIntegrations?: boolean;
 }
 
 /** The parts of a single-file managed-Markdown target that vary by filename. */
@@ -367,6 +402,28 @@ function runInitSingleFileMd(options: AgentsMdInitOptions, config: SingleFileMdC
   }
   const missing = selection === undefined ? [] : selection.filter((id) => !discovered.has(id));
 
+  let aggregate = { manifest: undefined, digest: undefined } as ReturnType<typeof aggregateIntegrationManifests>;
+  try {
+    if (options.noIntegrations !== true) {
+      aggregate = aggregateIntegrationManifests(picked.map(({ id, skillsDir }) => ({ skillId: id, skillDir: skillsDir })));
+    }
+  } catch (error) {
+    const remediation = error instanceof Error ? error.message : String(error);
+    return {
+      target: config.target,
+      skillsDir: joinedDir,
+      projectRoot: options.projectRoot,
+      skills: [],
+      missing,
+      failures: [],
+      applyFailures: [],
+      integrations: [
+        refusedOutcome(config.target, 'mcp', 'MANIFEST_INVALID', remediation),
+        refusedOutcome(config.target, 'hooks', 'MANIFEST_INVALID', remediation),
+      ],
+    };
+  }
+
   // Skip-and-collect: one unloadable skill must not discard the whole aggregation.
   const failures: SkillLoadFailure[] = [];
   const loaded: { id: string; section: string }[] = [];
@@ -397,7 +454,19 @@ function runInitSingleFileMd(options: AgentsMdInitOptions, config: SingleFileMdC
 
   // No apply failures are possible here: the single write is outside every per-skill
   // loop, so a write error propagates as itself rather than being attributed to a skill.
-  return { target: config.target, skillsDir: joinedDir, projectRoot: options.projectRoot, skills, missing, failures, applyFailures: [] };
+  return {
+    target: config.target,
+    skillsDir: joinedDir,
+    projectRoot: options.projectRoot,
+    skills,
+    missing,
+    failures,
+    applyFailures: [],
+    integrations: options.noIntegrations === true
+      ? notRequestedOutcomes(config.target)
+      : staticPolicyOutcomes(config.target, aggregate.manifest, options.noHooks === true),
+    ...(aggregate.digest !== undefined ? { integrationDigest: aggregate.digest } : {}),
+  };
 }
 
 /**
@@ -546,6 +615,8 @@ export async function runInit(options: InitOptions): Promise<InitReport> {
       skillsDirs: [options.skillsDir],
       projectRoot: options.projectRoot,
       select: options.select,
+      ...(options.noHooks !== undefined ? { noHooks: options.noHooks } : {}),
+      ...(options.noIntegrations !== undefined ? { noIntegrations: options.noIntegrations } : {}),
     });
   }
   // gemini is likewise a flattening single-file target — aggregate into ONE root
@@ -555,6 +626,8 @@ export async function runInit(options: InitOptions): Promise<InitReport> {
       skillsDirs: [options.skillsDir],
       projectRoot: options.projectRoot,
       select: options.select,
+      ...(options.noHooks !== undefined ? { noHooks: options.noHooks } : {}),
+      ...(options.noIntegrations !== undefined ? { noIntegrations: options.noIntegrations } : {}),
     });
   }
 
@@ -568,6 +641,78 @@ export async function runInit(options: InitOptions): Promise<InitReport> {
   const missing = selection === undefined
     ? []
     : selection.filter((id) => !discovered.includes(id));
+  const manifestSources: readonly IntegrationManifestSource[] = options.integrationManifestSources
+    ?? ids.map((id) => ({ skillId: id, skillDir: options.skillsDir }));
+  let aggregate = { manifest: undefined, digest: undefined } as ReturnType<typeof aggregateIntegrationManifests>;
+  try {
+    if (options.noIntegrations !== true) aggregate = aggregateIntegrationManifests(manifestSources);
+  } catch (error) {
+    const remediation = error instanceof Error ? error.message : String(error);
+    return {
+      target: options.target,
+      skillsDir: options.skillsDir,
+      projectRoot: options.projectRoot,
+      skills: [],
+      missing,
+      failures: [],
+      applyFailures: [],
+      integrations: [
+        refusedOutcome(options.target, 'mcp', 'MANIFEST_INVALID', remediation),
+        refusedOutcome(options.target, 'hooks', 'MANIFEST_INVALID', remediation),
+      ],
+    };
+  }
+
+  let integrations: readonly [IntegrationOutcome, IntegrationOutcome] = notRequestedOutcomes(options.target);
+  let eligibleClaudePlan: ReturnType<(typeof TARGET_INTEGRATIONS)['claude-code']['plan']> | undefined;
+  if (aggregate.manifest !== undefined && options.noIntegrations !== true) {
+    if (options.target !== 'claude-code') {
+      integrations = staticPolicyOutcomes(options.target, aggregate.manifest, options.noHooks === true);
+    } else {
+      const mcpRequested = Object.keys(aggregate.manifest.mcpServers ?? {}).length > 0;
+      const hooksRequested = (aggregate.manifest.hooks?.length ?? 0) > 0 && options.noHooks !== true;
+      let mcpOutcome: IntegrationOutcome = { target: options.target, component: 'mcp', status: 'not-requested', registrations: [] };
+      if (mcpRequested) {
+        if (options.noVerify === true) {
+          mcpOutcome = refusedOutcome(options.target, 'mcp', 'NO_QUALIFYING_LIVE_RECEIPT', '--no-verify cannot authorize integration emission; rerun with live verification enabled');
+        } else if (aggregate.digest === undefined || options.allowIntegrations !== aggregate.digest) {
+          mcpOutcome = refusedOutcome(options.target, 'mcp', 'INTEGRATION_AUTHORIZATION_REQUIRED', `rerun with --allow-integrations ${aggregate.digest ?? '<missing-digest>'}`);
+        } else {
+          const plan = TARGET_INTEGRATIONS['claude-code'].plan(aggregate.manifest, { target: 'claude-code' });
+          const refusal = plan.refusals.find((row) => row.component === 'mcp');
+          if (refusal !== undefined) {
+            mcpOutcome = refusedOutcome(options.target, 'mcp', refusal.reasonCode, refusal.remediation);
+          } else {
+            const preflight = verifyTargetIntegration({
+              target: 'claude-code',
+              component: 'mcp',
+              projectRoot: options.projectRoot,
+              phase: 'preflight',
+              ...(options.integrationProcessPort !== undefined ? { processPort: options.integrationProcessPort } : {}),
+            });
+            if (!preflight.ok) {
+              mcpOutcome = refusedOutcome(options.target, 'mcp', preflight.reasonCode ?? 'LIVE_PROBE_FAILED', preflight.remediation ?? 'live preflight did not qualify');
+            } else {
+              eligibleClaudePlan = plan;
+              mcpOutcome = {
+                target: options.target,
+                component: 'mcp',
+                status: 'emitted',
+                registrations: [],
+                carrier: { scope: 'project', path: '.mcp.json' },
+                ...(preflight.runtimeVersion !== undefined ? { runtimeVersion: preflight.runtimeVersion } : {}),
+                ...(preflight.evidenceVersion !== undefined ? { evidenceVersion: preflight.evidenceVersion } : {}),
+              };
+            }
+          }
+        }
+      }
+      const hookOutcome: IntegrationOutcome = hooksRequested
+        ? refusedOutcome(options.target, 'hooks', 'NO_ACTIVATION_RECEIPT', 'record a nonce canary and negative-control activation receipt')
+        : { target: options.target, component: 'hooks', status: 'not-requested', registrations: [] };
+      integrations = [mcpOutcome, hookOutcome];
+    }
+  }
   // Skip-and-collect (D1): one unparseable SKILL.md must not discard the whole install.
   // Same shape as `runVerify`'s long-standing per-id try/catch below.
   //
@@ -602,7 +747,59 @@ export async function runInit(options: InitOptions): Promise<InitReport> {
       applyFailures.push({ id, reason: error instanceof Error ? error.message : String(error) });
     }
   }
-  return { target: options.target, skillsDir: options.skillsDir, projectRoot: options.projectRoot, skills, missing, failures, applyFailures };
+  if (eligibleClaudePlan !== undefined && integrations[0].status === 'emitted') {
+    try {
+      applyIntegrationFragments({
+        projectRoot: options.projectRoot,
+        fragments: eligibleClaudePlan.fragments,
+        ...(options.integrationApplyFault !== undefined ? { injectFault: options.integrationApplyFault } : {}),
+      });
+      const registrations = Object.keys(aggregate.manifest?.mcpServers ?? {});
+      const observed = [];
+      let failedObservation: ReturnType<typeof verifyTargetIntegration> | undefined;
+      for (const registrationId of registrations) {
+        const result = verifyTargetIntegration({
+          target: 'claude-code',
+          component: 'mcp',
+          projectRoot: options.projectRoot,
+          registrationId,
+          phase: 'post-write',
+          ...(options.integrationProcessPort !== undefined ? { processPort: options.integrationProcessPort } : {}),
+        });
+        if (!result.ok) { failedObservation = result; break; }
+        observed.push(...result.registrations);
+      }
+      if (failedObservation !== undefined) {
+        integrations = [
+          {
+            ...refusedOutcome(options.target, 'mcp', failedObservation.reasonCode ?? 'POST_WRITE_REGISTRATION_NOT_OBSERVED', failedObservation.remediation ?? 'registration was written but not observed'),
+            carrier: { scope: 'project', path: '.mcp.json' },
+            applied: true,
+          },
+          integrations[1],
+        ];
+      } else {
+        integrations = [{ ...integrations[0], registrations: observed }, integrations[1]];
+      }
+    } catch (error) {
+      const reasonCode = error instanceof IntegrationApplyError ? error.reasonCode : 'APPLY_FAILED';
+      integrations = [{
+        ...refusedOutcome(options.target, 'mcp', reasonCode, error instanceof Error ? error.message : String(error)),
+        ...(error instanceof IntegrationApplyError && error.applied ? { applied: true } : {}),
+      }, integrations[1]];
+    }
+  }
+  return {
+    target: options.target,
+    skillsDir: options.skillsDir,
+    projectRoot: options.projectRoot,
+    skills,
+    missing,
+    failures,
+    applyFailures,
+    integrations,
+    ...(aggregate.digest !== undefined ? { integrationDigest: aggregate.digest } : {}),
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -1186,9 +1383,12 @@ export async function runDoctor(options: { projectRoot: string }): Promise<Docto
   // Silent when a log is absent or has never been chained: an unchained file is legal (FR-5), not a
   // fault, and reporting it would train the reader to ignore this line.
   try {
-    const { verifyEventChainText, classifyChainDefects, EVENT_CHAIN_SCOPE } = await import('./event-chain.js');
-    for (const rel of ['recall-usage.jsonl', 'guard-audit.jsonl']) {
-      const p = join(root, '.dz', rel);
+    const { verifyEventChainText, classifyChainDefects, EVENT_CHAIN_SCOPE, CHAINED_JOURNALS } = await import('./event-chain.js');
+    // W0-chain (bc4ee35c): enumerated from THE registry, never from a list kept here. The inline
+    // array this replaces is why a journal could be given a chain and still be checked by nobody —
+    // the mechanism present, the coverage absent, and no red anywhere to say so.
+    for (const journal of CHAINED_JOURNALS) {
+      const p = join(root, journal.rel);
       if (!existsSync(p)) continue;
       const text = readFileSync(p, 'utf-8');
       const v = verifyEventChainText(text);
@@ -1203,7 +1403,7 @@ export async function runDoctor(options: { projectRoot: string }): Promise<Docto
       // file and false of the present, and a red nobody can act on is a red nobody reads.
       if (age.inRun.length === 0 && age.runRecords > 0) {
         checks.push({
-          name: `evidence chain (.dz/${rel})`,
+          name: `evidence chain (${journal.rel})`,
           ok: true,
           // The COUNT carries the meaning, and is printed first for that reason: "1 record forms an
           // unbroken run" is true and says almost nothing, while 998 says a great deal. Naming the
@@ -1216,7 +1416,7 @@ export async function runDoctor(options: { projectRoot: string }): Promise<Docto
         continue;
       }
       checks.push({
-        name: `evidence chain (.dz/${rel})`,
+        name: `evidence chain (${journal.rel})`,
         ok: false,
         detail: `${named} — with NO sound records after them: learning verdicts computed from this log are unsafe. Scope: ${EVENT_CHAIN_SCOPE}`,
       });