@dalzoubi/dev-agents-sync 1.0.25 → 2.0.0

package/tests/e2e/claudeMd-injection.test.mjs

@@ -0,0 +1,846 @@
+/**
+ * tests/e2e/claudeMd-injection.test.mjs
+ *
+ * E2E tests for CLAUDE.md fenced-routing-block injection.
+ *
+ * These tests exercise the CLI programmatically via the runInit / runUpdate /
+ * runCheck command modules — the same interface the unit tests use — but with
+ * fixture fetchers that return a realistic file map including
+ * `claude/skills/auto-route.md`. This lets the tests cover the full
+ * init → update → check lifecycle without real GitHub calls.
+ *
+ * Success criteria (all RED until production wiring is in place):
+ *
+ *   init:
+ *     1. Running init against a clean consumer repo creates CLAUDE.md with the
+ *        fenced routing block.
+ *     2. The fenced block contains the start and end markers.
+ *     3. An existing CLAUDE.md with prose is preserved; the block is appended.
+ *     4. --dry-run does NOT create CLAUDE.md.
+ *
+ *   update:
+ *     5. Running update against a consumer whose CLAUDE.md has a stale block
+ *        replaces the block in-place.
+ *     6. Prose above/below the stale block is preserved after update.
+ *
+ *   check:
+ *     7. check exits 1 and names CLAUDE.md when the fenced block is stale.
+ *     8. check exits 1 and names CLAUDE.md when the file is absent.
+ *     9. check exits 0 when the fenced block is current.
+ *
+ * These tests are RED because:
+ *   - init.mjs / update.mjs do not yet call injectClaudeMd when the fetcher
+ *     returns a claude/skills/auto-route.md entry.
+ *   - check.mjs does not yet evaluate the CLAUDE.md fenced block.
+ *
+ * Implement agent must wire those calls before these tests go green.
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  rmSync,
+  readdirSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+import { runInit } from '../../src/commands/init.mjs';
+import { runUpdate } from '../../src/commands/update.mjs';
+import { runCheck } from '../../src/commands/check.mjs';
+import { writeLockfile } from '../../src/lockfile.mjs';
+import {
+  buildFencedBlock,
+  START_MARKER_PREFIX,
+  END_MARKER,
+} from '../../src/claudeMd.mjs';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const _require = createRequire(import.meta.url);
+const CLI_VERSION = _require('../../package.json').version;
+
+const FIXTURE_DIR = path.join(__dirname, '..', 'fixtures', 'release-v1.0.0');
+
+// Deterministic routing content injected by the fixture fetcher.
+// Tests that assert on the block content anchor to this exact string.
+const FIXTURE_ROUTING_CONTENT = [
+  '## Routing table',
+  '',
+  '| User intent | Route to |',
+  '|---|---|',
+  '| New feature | `define` |',
+  '| Small fix | `implement` |',
+  '',
+  '## Signal words',
+  '',
+  '`build`, `fix`, `test`',
+].join('\n');
+
+const FIXTURE_ROUTING_CONTENT_V2 = FIXTURE_ROUTING_CONTENT +
+  '\n\n## Updated section\n\nThis content was added in v2.';
+
+// Available tags used across tests.
+const AVAILABLE_TAGS = ['v1.0.0', 'v1.1.0', 'v1.2.0'];
+const AVAILABLE_TAGS_V2 = ['v1.0.0', 'v1.1.0', 'v1.2.0', 'v2.0.0'];
+
+// ---------------------------------------------------------------------------
+// Fixture helpers
+// ---------------------------------------------------------------------------
+
+function collectFiles(baseDir, currentDir, map, prefix) {
+  const entries = readdirSync(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(baseDir, full, map, prefix);
+    } else {
+      const rel = path.relative(baseDir, full).replace(/\\/g, '/');
+      map[`${prefix}/${rel}`] = readFileSync(full, 'utf8');
+    }
+  }
+}
+
+function buildBaseFileMap(targets = ['claude']) {
+  const map = {};
+  for (const t of targets) {
+    const targetDir = path.join(FIXTURE_DIR, t);
+    if (!existsSync(targetDir)) continue;
+    collectFiles(targetDir, targetDir, map, t);
+  }
+  return map;
+}
+
+/**
+ * Builds a fixture fetcher that includes `claude/skills/auto-route.md` with
+ * the given routing content. This is the critical ingredient: init/update must
+ * detect this key and call injectClaudeMd with its content.
+ */
+function makeFixtureFetcher(routingContent = FIXTURE_ROUTING_CONTENT) {
+  return async (_repo, _tag, _token) => {
+    const base = buildBaseFileMap(['claude']);
+    base['claude/skills/auto-route.md'] = routingContent;
+    return base;
+  };
+}
+
+function makeTmpDir() {
+  return mkdtempSync(path.join(tmpdir(), 'das-e2e-claudemd-'));
+}
+
+/**
+ * Convenience: build the fenced block that init/update should write.
+ */
+function currentBlock(routingContent = FIXTURE_ROUTING_CONTENT) {
+  return buildFencedBlock(CLI_VERSION, routingContent);
+}
+
+// ---------------------------------------------------------------------------
+// init — creates CLAUDE.md with fenced block in clean consumer repo
+// ---------------------------------------------------------------------------
+
+describe('e2e: init — CLAUDE.md injection into clean consumer repo', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('creates CLAUDE.md at the consumer root', async () => {
+    const claudeMdPath = path.join(consumerDir, 'CLAUDE.md');
+    assert.ok(!existsSync(claudeMdPath), 'precondition: CLAUDE.md must not exist before init');
+
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    assert.ok(
+      existsSync(claudeMdPath),
+      'CLAUDE.md must be created at the consumer root after init when ' +
+      'claude/skills/auto-route.md is present in the fetched file map',
+    );
+  });
+
+  it('CLAUDE.md contains the fenced start marker', async () => {
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const content = readFileSync(path.join(consumerDir, 'CLAUDE.md'), 'utf8');
+    assert.ok(
+      content.includes(START_MARKER_PREFIX),
+      `CLAUDE.md must contain the fenced start marker prefix "${START_MARKER_PREFIX}".\n` +
+      `Got:\n${content}`,
+    );
+  });
+
+  it('CLAUDE.md contains the fenced end marker', async () => {
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const content = readFileSync(path.join(consumerDir, 'CLAUDE.md'), 'utf8');
+    assert.ok(
+      content.includes(END_MARKER),
+      `CLAUDE.md must contain the fenced end marker "${END_MARKER}".\n` +
+      `Got:\n${content}`,
+    );
+  });
+
+  it('CLAUDE.md contains the routing content from claude/skills/auto-route.md', async () => {
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const content = readFileSync(path.join(consumerDir, 'CLAUDE.md'), 'utf8');
+    assert.ok(
+      content.includes('## Routing table'),
+      `CLAUDE.md must include the routing table from the injected auto-route.md content.\n` +
+      `Got:\n${content}`,
+    );
+  });
+
+  it('CLAUDE.md fenced block includes the CLI version in the start marker', async () => {
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const content = readFileSync(path.join(consumerDir, 'CLAUDE.md'), 'utf8');
+    const expectedMarker = `${START_MARKER_PREFIX}${CLI_VERSION} -->`;
+    assert.ok(
+      content.includes(expectedMarker),
+      `CLAUDE.md start marker must include the CLI version v${CLI_VERSION}.\n` +
+      `Expected marker: ${expectedMarker}\n` +
+      `Got:\n${content}`,
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// init — preserves existing CLAUDE.md prose
+// ---------------------------------------------------------------------------
+
+describe('e2e: init — existing CLAUDE.md prose is preserved', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('prose already in CLAUDE.md is present after init', async () => {
+    const claudeMdPath = path.join(consumerDir, 'CLAUDE.md');
+    writeFileSync(claudeMdPath, '# My Project\n\nThis is my CLAUDE.md.', 'utf8');
+
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const content = readFileSync(claudeMdPath, 'utf8');
+    assert.ok(
+      content.includes('# My Project'),
+      `Heading "# My Project" must be preserved after init.\n` +
+      `Got:\n${content}`,
+    );
+    assert.ok(
+      content.includes('This is my CLAUDE.md.'),
+      `Prose "This is my CLAUDE.md." must be preserved after init.\n` +
+      `Got:\n${content}`,
+    );
+  });
+
+  it('existing prose appears before the fenced block after init', async () => {
+    const claudeMdPath = path.join(consumerDir, 'CLAUDE.md');
+    writeFileSync(claudeMdPath, '# My Project\n\nExisting prose.', 'utf8');
+
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const content = readFileSync(claudeMdPath, 'utf8');
+    const proseIndex = content.indexOf('Existing prose.');
+    const blockIndex = content.indexOf(START_MARKER_PREFIX);
+
+    assert.ok(proseIndex !== -1, 'Prose must be present in CLAUDE.md after init');
+    assert.ok(blockIndex !== -1, 'Fenced block must be present in CLAUDE.md after init');
+    assert.ok(
+      proseIndex < blockIndex,
+      'Existing prose must appear before the injected fenced block',
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// init — --dry-run does not create CLAUDE.md
+// ---------------------------------------------------------------------------
+
+describe('e2e: init — --dry-run suppresses CLAUDE.md creation', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('CLAUDE.md is not created in dry-run mode', async () => {
+    const claudeMdPath = path.join(consumerDir, 'CLAUDE.md');
+
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      dryRun: true,
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    assert.ok(
+      !existsSync(claudeMdPath),
+      'CLAUDE.md must NOT be created when init is run with --dry-run',
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// update — replaces stale fenced block
+// ---------------------------------------------------------------------------
+
+describe('e2e: update — replaces stale CLAUDE.md fenced block', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  /**
+   * Sets up a consumer repo that has already run init at v1.0.0 with a CLAUDE.md
+   * containing a stale block written by an older CLI version.
+   */
+  function setupConsumerWithStaleBlock(opts = {}) {
+    const { staleVersion = '0.1.0', proseAbove = '' } = opts;
+
+    writeLockfile(consumerDir, {
+      source: 'github:dalzoubi/dev-agents',
+      range: '^1',
+      resolvedVersion: '1.0.0',
+      targets: ['claude'],
+      lastUpdated: '2026-04-01T00:00:00Z',
+    });
+
+    // Write managed claude agent file so update has something to check.
+    const agentsDir = path.join(consumerDir, '.claude', 'agents');
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(
+      path.join(agentsDir, 'define.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'agents', 'define.md'), 'utf8'),
+      'utf8',
+    );
+
+    // Write CLAUDE.md with a stale block.
+    const staleBlock = buildFencedBlock(staleVersion, 'Old routing content.');
+    const claudeContent = proseAbove
+      ? `${proseAbove}\n\n${staleBlock}`
+      : staleBlock;
+    writeFileSync(path.join(consumerDir, 'CLAUDE.md'), claudeContent, 'utf8');
+  }
+
+  it('replaces the stale fenced block with a current one', async () => {
+    setupConsumerWithStaleBlock({ staleVersion: '0.1.0' });
+
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const content = readFileSync(path.join(consumerDir, 'CLAUDE.md'), 'utf8');
+    assert.ok(
+      !content.includes('v0.1.0'),
+      `Stale version "v0.1.0" must be replaced in CLAUDE.md after update.\n` +
+      `Got:\n${content}`,
+    );
+    assert.ok(
+      content.includes(START_MARKER_PREFIX),
+      `Updated CLAUDE.md must contain the fenced start marker prefix.\n` +
+      `Got:\n${content}`,
+    );
+  });
+
+  it('stale block is replaced with current version marker', async () => {
+    setupConsumerWithStaleBlock({ staleVersion: '0.1.0' });
+
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const content = readFileSync(path.join(consumerDir, 'CLAUDE.md'), 'utf8');
+    const expectedMarker = `${START_MARKER_PREFIX}${CLI_VERSION} -->`;
+    assert.ok(
+      content.includes(expectedMarker),
+      `Updated CLAUDE.md must use the current CLI version in the start marker.\n` +
+      `Expected: ${expectedMarker}\n` +
+      `Got:\n${content}`,
+    );
+  });
+
+  it('preserves prose above the stale block after update', async () => {
+    setupConsumerWithStaleBlock({
+      staleVersion: '0.1.0',
+      proseAbove: '# My Project\n\nThis is preserved prose.',
+    });
+
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const content = readFileSync(path.join(consumerDir, 'CLAUDE.md'), 'utf8');
+    assert.ok(
+      content.includes('# My Project'),
+      `Prose heading above the block must be preserved after update.\n` +
+      `Got:\n${content}`,
+    );
+    assert.ok(
+      content.includes('This is preserved prose.'),
+      `Prose above the block must be preserved after update.\n` +
+      `Got:\n${content}`,
+    );
+  });
+
+  it('old routing content is replaced with new content after update', async () => {
+    setupConsumerWithStaleBlock({ staleVersion: '0.1.0' });
+
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const content = readFileSync(path.join(consumerDir, 'CLAUDE.md'), 'utf8');
+    assert.ok(
+      !content.includes('Old routing content.'),
+      `Old routing content must be replaced by the new content after update.\n` +
+      `Got:\n${content}`,
+    );
+    assert.ok(
+      content.includes('## Routing table'),
+      `New routing content from the fixture fetcher must appear after update.\n` +
+      `Got:\n${content}`,
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// check — detects stale block (exit 1) and names CLAUDE.md
+// ---------------------------------------------------------------------------
+
+describe('e2e: check — stale fenced block is detected (exit 1, CLAUDE.md named)', () => {
+  let consumerDir;
+
+  afterEach(() => {
+    if (consumerDir) rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  /**
+   * Sets up a consumer repo with all managed files in sync EXCEPT for the
+   * CLAUDE.md fenced block, which is written with a stale version.
+   */
+  function setupConsumerWithStaleClaude(staleVersion = '0.1.0') {
+    consumerDir = makeTmpDir();
+
+    writeLockfile(consumerDir, {
+      source: 'github:dalzoubi/dev-agents',
+      range: '^1',
+      resolvedVersion: '1.2.0',
+      targets: ['claude'],
+      lastUpdated: '2026-04-01T00:00:00Z',
+    });
+
+    // Write managed claude files exactly matching the fetcher output.
+    const agentsDir = path.join(consumerDir, '.claude', 'agents');
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(
+      path.join(agentsDir, 'define.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'agents', 'define.md'), 'utf8'),
+      'utf8',
+    );
+    writeFileSync(
+      path.join(agentsDir, 'test.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'agents', 'test.md'), 'utf8'),
+      'utf8',
+    );
+
+    const commandsDir = path.join(consumerDir, '.claude', 'commands');
+    mkdirSync(commandsDir, { recursive: true });
+    writeFileSync(
+      path.join(commandsDir, 'preflight.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'commands', 'preflight.md'), 'utf8'),
+      'utf8',
+    );
+
+    // Write .claude/skills/auto-route.md matching the fetcher output so that
+    // file itself is not the source of drift — only CLAUDE.md is under test.
+    const skillsDir = path.join(consumerDir, '.claude', 'skills');
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      path.join(skillsDir, 'auto-route.md'),
+      FIXTURE_ROUTING_CONTENT,
+      'utf8',
+    );
+
+    // Write CLAUDE.md with a stale block (wrong version).
+    const staleBlock = buildFencedBlock(staleVersion, FIXTURE_ROUTING_CONTENT);
+    writeFileSync(
+      path.join(consumerDir, 'CLAUDE.md'),
+      `# My Project\n\n${staleBlock}\n`,
+      'utf8',
+    );
+  }
+
+  it('exits 1 when the fenced block version is older than the current CLI version', async () => {
+    setupConsumerWithStaleClaude('0.1.0');
+
+    let exitCode;
+    try {
+      await runCheck(consumerDir, {
+        fetcher: makeFixtureFetcher(),
+        availableTags: ['v1.2.0'],
+      });
+      exitCode = 0;
+    } catch (err) {
+      exitCode = err.exitCode;
+    }
+
+    assert.equal(
+      exitCode,
+      1,
+      'check must exit 1 when the CLAUDE.md fenced block version is stale ' +
+      '(older than the current CLI version)',
+    );
+  });
+
+  it('drift error message names CLAUDE.md for a stale block', async () => {
+    setupConsumerWithStaleClaude('0.1.0');
+
+    let errorMessage = '';
+    try {
+      await runCheck(consumerDir, {
+        fetcher: makeFixtureFetcher(),
+        availableTags: ['v1.2.0'],
+      });
+    } catch (err) {
+      errorMessage = err.message ?? '';
+    }
+
+    assert.ok(
+      errorMessage.includes('CLAUDE.md'),
+      `check drift error must name CLAUDE.md when the fenced block is stale.\n` +
+      `Got: ${errorMessage}`,
+    );
+  });
+
+  it('err.drifted array includes CLAUDE.md for a stale block', async () => {
+    setupConsumerWithStaleClaude('0.1.0');
+
+    let drifted;
+    try {
+      await runCheck(consumerDir, {
+        fetcher: makeFixtureFetcher(),
+        availableTags: ['v1.2.0'],
+      });
+    } catch (err) {
+      drifted = err.drifted;
+    }
+
+    assert.ok(
+      Array.isArray(drifted),
+      'expected err.drifted to be an array when drift is detected',
+    );
+    assert.ok(
+      drifted.some((d) => d.includes('CLAUDE.md')),
+      `err.drifted must include an entry mentioning CLAUDE.md for a stale block.\n` +
+      `Got: ${JSON.stringify(drifted)}`,
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// check — detects absent CLAUDE.md (exit 1, CLAUDE.md named)
+// ---------------------------------------------------------------------------
+
+describe('e2e: check — absent CLAUDE.md is detected as drift (exit 1)', () => {
+  let consumerDir;
+
+  afterEach(() => {
+    if (consumerDir) rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  function setupConsumerWithoutClaude() {
+    consumerDir = makeTmpDir();
+
+    writeLockfile(consumerDir, {
+      source: 'github:dalzoubi/dev-agents',
+      range: '^1',
+      resolvedVersion: '1.2.0',
+      targets: ['claude'],
+      lastUpdated: '2026-04-01T00:00:00Z',
+    });
+
+    const agentsDir = path.join(consumerDir, '.claude', 'agents');
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(
+      path.join(agentsDir, 'define.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'agents', 'define.md'), 'utf8'),
+      'utf8',
+    );
+    writeFileSync(
+      path.join(agentsDir, 'test.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'agents', 'test.md'), 'utf8'),
+      'utf8',
+    );
+
+    const commandsDir = path.join(consumerDir, '.claude', 'commands');
+    mkdirSync(commandsDir, { recursive: true });
+    writeFileSync(
+      path.join(commandsDir, 'preflight.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'commands', 'preflight.md'), 'utf8'),
+      'utf8',
+    );
+
+    const skillsDir = path.join(consumerDir, '.claude', 'skills');
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      path.join(skillsDir, 'auto-route.md'),
+      FIXTURE_ROUTING_CONTENT,
+      'utf8',
+    );
+
+    // Deliberately do NOT create CLAUDE.md — absence is the drift condition.
+  }
+
+  it('exits 1 when CLAUDE.md does not exist', async () => {
+    setupConsumerWithoutClaude();
+
+    const claudeMdPath = path.join(consumerDir, 'CLAUDE.md');
+    assert.ok(!existsSync(claudeMdPath), 'precondition: CLAUDE.md must not exist');
+
+    let exitCode;
+    try {
+      await runCheck(consumerDir, {
+        fetcher: makeFixtureFetcher(),
+        availableTags: ['v1.2.0'],
+      });
+      exitCode = 0;
+    } catch (err) {
+      exitCode = err.exitCode;
+    }
+
+    assert.equal(
+      exitCode,
+      1,
+      'check must exit 1 when CLAUDE.md does not exist (absence = drift)',
+    );
+  });
+
+  it('drift error message names CLAUDE.md when file is absent', async () => {
+    setupConsumerWithoutClaude();
+
+    let errorMessage = '';
+    try {
+      await runCheck(consumerDir, {
+        fetcher: makeFixtureFetcher(),
+        availableTags: ['v1.2.0'],
+      });
+    } catch (err) {
+      errorMessage = err.message ?? '';
+    }
+
+    assert.ok(
+      errorMessage.includes('CLAUDE.md'),
+      `check drift error must name CLAUDE.md when the file is absent.\n` +
+      `Got: ${errorMessage}`,
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// check — current block exits 0
+// ---------------------------------------------------------------------------
+
+describe('e2e: check — current CLAUDE.md fenced block exits 0', () => {
+  let consumerDir;
+
+  afterEach(() => {
+    if (consumerDir) rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  function setupConsumerWithCurrentBlock() {
+    consumerDir = makeTmpDir();
+
+    writeLockfile(consumerDir, {
+      source: 'github:dalzoubi/dev-agents',
+      range: '^1',
+      resolvedVersion: '1.2.0',
+      targets: ['claude'],
+      lastUpdated: '2026-04-01T00:00:00Z',
+    });
+
+    const agentsDir = path.join(consumerDir, '.claude', 'agents');
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(
+      path.join(agentsDir, 'define.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'agents', 'define.md'), 'utf8'),
+      'utf8',
+    );
+    writeFileSync(
+      path.join(agentsDir, 'test.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'agents', 'test.md'), 'utf8'),
+      'utf8',
+    );
+
+    const commandsDir = path.join(consumerDir, '.claude', 'commands');
+    mkdirSync(commandsDir, { recursive: true });
+    writeFileSync(
+      path.join(commandsDir, 'preflight.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'commands', 'preflight.md'), 'utf8'),
+      'utf8',
+    );
+
+    const skillsDir = path.join(consumerDir, '.claude', 'skills');
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      path.join(skillsDir, 'auto-route.md'),
+      FIXTURE_ROUTING_CONTENT,
+      'utf8',
+    );
+
+    // Write CLAUDE.md with the current (expected) fenced block.
+    const block = currentBlock(FIXTURE_ROUTING_CONTENT);
+    writeFileSync(
+      path.join(consumerDir, 'CLAUDE.md'),
+      `# My Project\n\n${block}\n`,
+      'utf8',
+    );
+  }
+
+  it('exits 0 when CLAUDE.md has the current fenced block', async () => {
+    setupConsumerWithCurrentBlock();
+
+    let exitCode = 0;
+    try {
+      await runCheck(consumerDir, {
+        fetcher: makeFixtureFetcher(),
+        availableTags: ['v1.2.0'],
+      });
+    } catch (err) {
+      exitCode = err.exitCode ?? 2;
+    }
+
+    assert.equal(
+      exitCode,
+      0,
+      'check must exit 0 when CLAUDE.md has the current fenced block with current version and content',
+    );
+  });
+
+  it('exits 0 even when CLAUDE.md has prose surrounding the current block', async () => {
+    consumerDir = makeTmpDir();
+
+    writeLockfile(consumerDir, {
+      source: 'github:dalzoubi/dev-agents',
+      range: '^1',
+      resolvedVersion: '1.2.0',
+      targets: ['claude'],
+      lastUpdated: '2026-04-01T00:00:00Z',
+    });
+
+    const agentsDir = path.join(consumerDir, '.claude', 'agents');
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(
+      path.join(agentsDir, 'define.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'agents', 'define.md'), 'utf8'),
+      'utf8',
+    );
+    writeFileSync(
+      path.join(agentsDir, 'test.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'agents', 'test.md'), 'utf8'),
+      'utf8',
+    );
+
+    const commandsDir = path.join(consumerDir, '.claude', 'commands');
+    mkdirSync(commandsDir, { recursive: true });
+    writeFileSync(
+      path.join(commandsDir, 'preflight.md'),
+      readFileSync(path.join(FIXTURE_DIR, 'claude', 'commands', 'preflight.md'), 'utf8'),
+      'utf8',
+    );
+
+    const skillsDir = path.join(consumerDir, '.claude', 'skills');
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      path.join(skillsDir, 'auto-route.md'),
+      FIXTURE_ROUTING_CONTENT,
+      'utf8',
+    );
+
+    // Write CLAUDE.md with prose before AND after the block.
+    const block = currentBlock(FIXTURE_ROUTING_CONTENT);
+    writeFileSync(
+      path.join(consumerDir, 'CLAUDE.md'),
+      `# My Full Project\n\nProse before.\n\n${block}\n\nTrailing notes.`,
+      'utf8',
+    );
+
+    let exitCode = 0;
+    try {
+      await runCheck(consumerDir, {
+        fetcher: makeFixtureFetcher(),
+        availableTags: ['v1.2.0'],
+      });
+    } catch (err) {
+      exitCode = err.exitCode ?? 2;
+    }
+
+    assert.equal(
+      exitCode,
+      0,
+      'check must exit 0 when block is current — surrounding prose must not affect the result',
+    );
+  });
+});