@dalzoubi/dev-agents-sync 2.0.20 → 2.0.22

package/README.md

@@ -109,11 +109,12 @@ The CLI seeds a blank steering scaffold under `.claude/steering/` — `decisions
 
 ### Hook scripts (managed)
 
-`init` and `update` install three hook scripts into `.claude/hooks/` as marker-managed, lockfile-tracked, executable files:
+`init` and `update` install four hook scripts into `.claude/hooks/` as marker-managed, lockfile-tracked, executable files:
 
 | Script | Claude Code event | Purpose |
 |---|---|---|
 | `steering-injector.sh` | `SessionStart` | Surfaces steering context at the start of a session. |
+| `rules-injector.sh` | `SessionStart` | Injects the always-on shared rule bodies (`structured-choices`, `tone`) from `.claude/rules/` into every session; fail-safe (skips absent rules, exits 0). |
 | `managed-file-guard.sh` | `PostToolUse` | Guards managed files against unexpected edits. |
 | `uncommitted-check.sh` | `Stop` | Flags uncommitted work when a session ends. |
 
@@ -121,7 +122,7 @@ Hook scripts use the shell-comment marker form `# managed-by: dev-agents-sync vX
 
 ### settings.json auto-wiring
 
-By default, `init` and `update` also register the three hooks in `.claude/settings.json` so Claude Code runs them. The merge is:
+By default, `init` and `update` also register the four hooks in `.claude/settings.json` so Claude Code runs them. The merge is:
 
 - **Additive** — every existing setting and every consumer-authored hook is preserved untouched.
 - **Idempotent** — running `update` twice produces no duplicate entries.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dalzoubi/dev-agents-sync",
-  "version": "2.0.20",
+  "version": "2.0.22",
   "type": "module",
   "description": "CLI that syncs managed dev-agent prompts into consumer repos (.claude/ and/or .cursor/).",
   "license": "UNLICENSED",

package/src/settings.mjs

@@ -263,6 +263,7 @@ export function removeHookSettings(consumerCwd, opts = {}) {
  */
 export const DEFAULT_HOOK_SCRIPTS = [
   { event: 'SessionStart', matcher: '.*', command: '.claude/hooks/steering-injector.sh' },
+  { event: 'SessionStart', matcher: '.*', command: '.claude/hooks/rules-injector.sh' },
   { event: 'PostToolUse', matcher: '.*', command: '.claude/hooks/managed-file-guard.sh' },
   { event: 'Stop', matcher: '.*', command: '.claude/hooks/uncommitted-check.sh' },
 ];

package/tests/rules-injector-registration.test.mjs

@@ -0,0 +1,352 @@
+/**
+ * tests/rules-injector-registration.test.mjs
+ *
+ * Slice S2 — SessionStart rules-injector.sh hook (registration half).
+ * Spec: docs/specs/260708-claude-rules-enforcement/
+ *
+ * These tests FAIL before the implement agent registers rules-injector.sh as a
+ * managed SessionStart hook and PASS after. They are behavior-anchored (§7):
+ * each criterion maps to a named test that would fail if the behavior broke.
+ *
+ * Behavior anchors:
+ *
+ *  R1. DEFAULT_HOOK_SCRIPTS (packages/dev-agents-sync/src/settings.mjs) includes
+ *      a SessionStart entry whose command targets
+ *      `.claude/hooks/rules-injector.sh`.
+ *  R2. When the fetched FileMap ships `claude/hooks/rules-injector.sh` (as S3's
+ *      build.mjs will once the canonical `.agents/hooks/rules-injector.sh`
+ *      exists), `runInit` wires a HOOK_TAG-tagged SessionStart registration for
+ *      it into the consumer's `.claude/settings.json`, additively alongside the
+ *      three pre-existing managed hooks (steering-injector.sh,
+ *      managed-file-guard.sh, uncommitted-check.sh).
+ *  R3. `runUpdate` does the same on a pre-initialized consumer repo.
+ *  R4. Running update twice produces no duplicate rules-injector.sh
+ *      registration (idempotent, §9).
+ *
+ * Test runner: `node --test packages/dev-agents-sync/tests/rules-injector-registration.test.mjs`
+ * No third-party dependencies. All tests use isolated tmp dirs.
+ */
+
+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 { runInit } from '../src/commands/init.mjs';
+import { runUpdate } from '../src/commands/update.mjs';
+import { writeLockfile } from '../src/lockfile.mjs';
+import { DEFAULT_HOOK_SCRIPTS, HOOK_TAG } from '../src/settings.mjs';
+
+// ---------------------------------------------------------------------------
+// Paths / fixture helpers (mirrors tests/hooks-cli-install.test.mjs)
+// ---------------------------------------------------------------------------
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FIXTURE_DIR = path.join(__dirname, 'fixtures', 'release-v1.0.0');
+
+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');
+    }
+  }
+}
+
+/**
+ * Builds a fixture FileMap that includes the four managed hook scripts —
+ * the three pre-existing ones plus rules-injector.sh (as S3's build.mjs will
+ * emit once the canonical `.agents/hooks/rules-injector.sh` source exists).
+ */
+function buildFixtureFileMap() {
+  const map = {};
+  const targetDir = path.join(FIXTURE_DIR, 'claude');
+  if (existsSync(targetDir)) {
+    collectFiles(targetDir, targetDir, map, 'claude');
+  }
+  map['claude/hooks/steering-injector.sh'] =
+    '#!/bin/sh\n# managed-by: dev-agents-sync v2.0.16\n# SessionStart hook.\nexit 0\n';
+  map['claude/hooks/managed-file-guard.sh'] =
+    '#!/bin/sh\n# managed-by: dev-agents-sync v2.0.16\n# PostToolUse hook.\nexit 0\n';
+  map['claude/hooks/uncommitted-check.sh'] =
+    '#!/bin/sh\n# managed-by: dev-agents-sync v2.0.16\n# Stop hook.\nexit 0\n';
+  map['claude/hooks/rules-injector.sh'] =
+    '#!/bin/sh\n# managed-by: dev-agents-sync v2.0.16\n# SessionStart hook.\nexit 0\n';
+  return map;
+}
+
+function makeFixtureFetcher() {
+  return async (_repo, _tag, _token) => buildFixtureFileMap();
+}
+
+const AVAILABLE_TAGS = ['v1.0.0', 'v1.1.0', 'v1.2.0', 'v2.0.0'];
+
+function makeTmpDir() {
+  return mkdtempSync(path.join(tmpdir(), 'das-rules-injector-reg-test-'));
+}
+
+function setupInitializedRepo(consumerDir, opts = {}) {
+  const { targets = ['claude'], resolvedVersion = '1.0.0', range = '^1' } = opts;
+
+  writeLockfile(consumerDir, {
+    source: 'github:dalzoubi/dev-agents',
+    range,
+    resolvedVersion,
+    targets,
+    lastUpdated: '2026-06-01T00:00:00Z',
+  });
+
+  const agentsDir = path.join(consumerDir, '.claude', 'agents');
+  mkdirSync(agentsDir, { recursive: true });
+  const fixtureContent = readFileSync(
+    path.join(FIXTURE_DIR, 'claude', 'agents', 'define.md'),
+    'utf8',
+  );
+  writeFileSync(path.join(agentsDir, 'define.md'), fixtureContent, 'utf8');
+}
+
+/** Collects every hook `command` string registered anywhere in settings.hooks. */
+function allHookCommands(settings) {
+  const hooks = settings.hooks ?? {};
+  const commands = [];
+  for (const entries of Object.values(hooks)) {
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      const hookList = Array.isArray(entry.hooks) ? entry.hooks : [];
+      for (const h of hookList) {
+        if (h.command) commands.push({ command: h.command, tagged: entry[HOOK_TAG] === true });
+      }
+    }
+  }
+  return commands;
+}
+
+// ---------------------------------------------------------------------------
+// R1 — DEFAULT_HOOK_SCRIPTS registers rules-injector.sh on SessionStart
+// ---------------------------------------------------------------------------
+
+describe('S2 R1 — DEFAULT_HOOK_SCRIPTS includes rules-injector.sh', () => {
+  it('R1a: DEFAULT_HOOK_SCRIPTS has an entry whose command is .claude/hooks/rules-injector.sh', () => {
+    const entry = DEFAULT_HOOK_SCRIPTS.find(
+      (h) => h.command === '.claude/hooks/rules-injector.sh',
+    );
+    assert.ok(
+      entry,
+      `DEFAULT_HOOK_SCRIPTS must register .claude/hooks/rules-injector.sh; ` +
+        `got commands: ${DEFAULT_HOOK_SCRIPTS.map((h) => h.command).join(', ')}`,
+    );
+  });
+
+  it('R1b: the rules-injector.sh registration fires on SessionStart', () => {
+    const entry = DEFAULT_HOOK_SCRIPTS.find(
+      (h) => h.command === '.claude/hooks/rules-injector.sh',
+    );
+    assert.ok(entry, 'rules-injector.sh must be registered in DEFAULT_HOOK_SCRIPTS');
+    assert.equal(
+      entry.event,
+      'SessionStart',
+      `rules-injector.sh must be registered on the SessionStart event; got: ${entry?.event}`,
+    );
+  });
+
+  it('R1c: the three pre-existing managed hooks are still registered (additive, not replaced)', () => {
+    const commands = DEFAULT_HOOK_SCRIPTS.map((h) => h.command);
+    for (const expected of [
+      '.claude/hooks/steering-injector.sh',
+      '.claude/hooks/managed-file-guard.sh',
+      '.claude/hooks/uncommitted-check.sh',
+    ]) {
+      assert.ok(
+        commands.includes(expected),
+        `registering rules-injector.sh must not drop the existing ${expected} registration`,
+      );
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// R2 — init wires a tagged SessionStart registration for rules-injector.sh
+// ---------------------------------------------------------------------------
+
+describe('S2 R2 — init wires rules-injector.sh into settings.json', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('R2a: init registers a SessionStart entry for rules-injector.sh', async () => {
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const settingsPath = path.join(consumerDir, '.claude', 'settings.json');
+    assert.ok(existsSync(settingsPath), '.claude/settings.json must exist after init');
+
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const sessionStart = settings.hooks?.SessionStart ?? [];
+    const found = sessionStart.some(
+      (e) =>
+        Array.isArray(e.hooks) &&
+        e.hooks.some((h) => typeof h.command === 'string' && h.command.includes('rules-injector.sh')),
+    );
+    assert.ok(
+      found,
+      'settings.json must contain a SessionStart hook entry for rules-injector.sh after init',
+    );
+  });
+
+  it('R2b: the injected rules-injector.sh entry carries the HOOK_TAG', async () => {
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const settingsPath = path.join(consumerDir, '.claude', 'settings.json');
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const sessionStart = settings.hooks?.SessionStart ?? [];
+    const taggedEntry = sessionStart.find(
+      (e) =>
+        e[HOOK_TAG] === true &&
+        Array.isArray(e.hooks) &&
+        e.hooks.some((h) => typeof h.command === 'string' && h.command.includes('rules-injector.sh')),
+    );
+    assert.ok(
+      taggedEntry,
+      `rules-injector.sh SessionStart entry must carry HOOK_TAG ("${HOOK_TAG}") so it is identifiable as CLI-managed`,
+    );
+  });
+
+  it('R2c: rules-injector.sh registration coexists with the three pre-existing managed hooks', async () => {
+    await runInit(consumerDir, {
+      targets: ['claude'],
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const settingsPath = path.join(consumerDir, '.claude', 'settings.json');
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const commands = allHookCommands(settings).map((c) => c.command);
+
+    for (const expected of [
+      'steering-injector.sh',
+      'managed-file-guard.sh',
+      'uncommitted-check.sh',
+      'rules-injector.sh',
+    ]) {
+      assert.ok(
+        commands.some((cmd) => cmd.includes(expected)),
+        `settings.json must register ${expected} alongside the other managed hooks after init`,
+      );
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// R3 — update wires rules-injector.sh on a pre-initialized consumer repo
+// ---------------------------------------------------------------------------
+
+describe('S2 R3 — update wires rules-injector.sh into settings.json', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('R3a: update registers a SessionStart entry for rules-injector.sh', async () => {
+    setupInitializedRepo(consumerDir, { resolvedVersion: '1.0.0' });
+
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    const settingsPath = path.join(consumerDir, '.claude', 'settings.json');
+    assert.ok(existsSync(settingsPath), '.claude/settings.json must exist after update');
+
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const sessionStart = settings.hooks?.SessionStart ?? [];
+    const found = sessionStart.some(
+      (e) =>
+        Array.isArray(e.hooks) &&
+        e.hooks.some((h) => typeof h.command === 'string' && h.command.includes('rules-injector.sh')),
+    );
+    assert.ok(
+      found,
+      'settings.json must contain a SessionStart hook entry for rules-injector.sh after update',
+    );
+  });
+
+  it('R3b: rules-injector.sh script itself is installed by update', async () => {
+    setupInitializedRepo(consumerDir, { resolvedVersion: '1.0.0' });
+
+    await runUpdate(consumerDir, {
+      fetcher: makeFixtureFetcher(),
+      availableTags: AVAILABLE_TAGS,
+    });
+
+    assert.ok(
+      existsSync(path.join(consumerDir, '.claude', 'hooks', 'rules-injector.sh')),
+      'update must write .claude/hooks/rules-injector.sh',
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// R4 — idempotent: running update twice adds no duplicate registration
+// ---------------------------------------------------------------------------
+
+describe('S2 R4 — repeated update produces no duplicate rules-injector.sh registration', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('R4: rules-injector.sh command appears at most once after two updates', async () => {
+    setupInitializedRepo(consumerDir, { resolvedVersion: '1.0.0' });
+
+    const opts = { fetcher: makeFixtureFetcher(), availableTags: AVAILABLE_TAGS };
+    await runUpdate(consumerDir, opts);
+    await runUpdate(consumerDir, opts);
+
+    const settingsPath = path.join(consumerDir, '.claude', 'settings.json');
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const commands = allHookCommands(settings).map((c) => c.command);
+    const occurrences = commands.filter((cmd) => cmd.includes('rules-injector.sh')).length;
+
+    assert.ok(
+      occurrences <= 1,
+      `rules-injector.sh hook command must appear at most once after two updates (found: ${occurrences})`,
+    );
+  });
+});

package/tests/rules-injector-runtime.test.mjs

@@ -0,0 +1,313 @@
+/**
+ * tests/rules-injector-runtime.test.mjs
+ *
+ * Slice S2 — SessionStart rules-injector.sh hook (runtime behavior half).
+ * Spec: docs/specs/260708-claude-rules-enforcement/
+ *
+ * Pins the runtime behavior of the shipped `.claude/hooks/rules-injector.sh`
+ * script (mirrored from the canonical `.agents/hooks/rules-injector.sh`, which
+ * does not exist yet — these tests are the RED anchor for that build step).
+ * Follows the steering-injector.sh convention: the hook is invoked with the
+ * consumer repo root as its cwd and looks for its inputs relative to that cwd,
+ * so we exercise it against an isolated tmp fixture dir rather than depending
+ * on this repo's real `.claude/rules/` contents (which may change).
+ *
+ * Behavior anchors:
+ *
+ *  T1. Executing the script against a fixture dir containing
+ *      `.claude/rules/structured-choices.md` and `.claude/rules/tone.md`
+ *      emits both rule BODIES to stdout, with the YAML frontmatter and the
+ *      `<!-- managed-by: ... -->` marker line stripped.
+ *  T2. The script exits 0 on that happy path.
+ *  T3. When one rule file is absent, the script still exits 0 (fail-safe),
+ *      emits at most a stderr note, and still surfaces the present rule's body.
+ *  T4. When both rule files are absent (no .claude/rules/ dir at all), the
+ *      script still exits 0.
+ *
+ * Test runner: `node --test packages/dev-agents-sync/tests/rules-injector-runtime.test.mjs`
+ * No third-party dependencies. All tests use isolated tmp dirs; none of them
+ * depend on this repo's actual `.claude/rules/*.md` content.
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// packages/dev-agents-sync/tests -> packages/dev-agents-sync -> packages -> repo root
+const REPO_ROOT = path.resolve(__dirname, '..', '..', '..');
+const SCRIPT_PATH = path.join(REPO_ROOT, '.claude', 'hooks', 'rules-injector.sh');
+
+// ---------------------------------------------------------------------------
+// Fixture content — self-contained, does NOT depend on this repo's actual
+// .claude/rules/*.md bodies so the test stays stable if those rules are edited.
+// ---------------------------------------------------------------------------
+
+const STRUCTURED_CHOICES_BODY_MARKER = 'FIXTURE_STRUCTURED_CHOICES_BODY_9f3a1';
+const TONE_BODY_MARKER = 'FIXTURE_TONE_BODY_7c22e';
+const FRONTMATTER_NAME_MARKER = 'name: "structured-choices"';
+const MARKDOWN_MANAGED_MARKER = '<!-- managed-by: dev-agents-sync v0.1.0 -->';
+
+function structuredChoicesFixture() {
+  return [
+    '---',
+    'name: "structured-choices"',
+    'description: "fixture rule for rules-injector runtime tests"',
+    '---',
+    MARKDOWN_MANAGED_MARKER,
+    '# Structured choices',
+    '',
+    STRUCTURED_CHOICES_BODY_MARKER,
+    '',
+  ].join('\n');
+}
+
+function toneFixture() {
+  return [
+    '---',
+    'name: "tone"',
+    'description: "fixture rule for rules-injector runtime tests"',
+    '---',
+    MARKDOWN_MANAGED_MARKER,
+    '# Tone',
+    '',
+    TONE_BODY_MARKER,
+    '',
+  ].join('\n');
+}
+
+function makeTmpDir() {
+  return mkdtempSync(path.join(tmpdir(), 'das-rules-injector-runtime-test-'));
+}
+
+/** Runs the shipped rules-injector.sh with `cwd` as its working directory. */
+function runScript(cwd) {
+  return spawnSync('sh', [SCRIPT_PATH], { cwd, encoding: 'utf8' });
+}
+
+let fixtureDir;
+
+// ---------------------------------------------------------------------------
+// T1/T2 — happy path: both rules present
+// ---------------------------------------------------------------------------
+
+describe('S2 T1/T2 — rules-injector.sh emits both rule bodies, exits 0', () => {
+  beforeEach(() => {
+    fixtureDir = makeTmpDir();
+    const rulesDir = path.join(fixtureDir, '.claude', 'rules');
+    mkdirSync(rulesDir, { recursive: true });
+    writeFileSync(path.join(rulesDir, 'structured-choices.md'), structuredChoicesFixture(), 'utf8');
+    writeFileSync(path.join(rulesDir, 'tone.md'), toneFixture(), 'utf8');
+  });
+
+  afterEach(() => {
+    rmSync(fixtureDir, { recursive: true, force: true });
+  });
+
+  it('T2: exits 0 when both rule files are present', () => {
+    const result = runScript(fixtureDir);
+    assert.equal(
+      result.status,
+      0,
+      `rules-injector.sh must exit 0 on the happy path; got status=${result.status}, stderr=${result.stderr}, error=${result.error}`,
+    );
+  });
+
+  it('T1a: stdout includes the structured-choices.md body', () => {
+    const result = runScript(fixtureDir);
+    assert.ok(
+      (result.stdout ?? '').includes(STRUCTURED_CHOICES_BODY_MARKER),
+      `stdout must include the structured-choices.md body; got stdout=${JSON.stringify(result.stdout)}`,
+    );
+  });
+
+  it('T1b: stdout includes the tone.md body', () => {
+    const result = runScript(fixtureDir);
+    assert.ok(
+      (result.stdout ?? '').includes(TONE_BODY_MARKER),
+      `stdout must include the tone.md body; got stdout=${JSON.stringify(result.stdout)}`,
+    );
+  });
+
+  it('T1c: stdout strips the YAML frontmatter (no "name:" front-matter key leaks through)', () => {
+    const result = runScript(fixtureDir);
+    const stdout = result.stdout ?? '';
+    // Anchored to the body actually being emitted — otherwise "frontmatter is
+    // absent" would pass vacuously against empty stdout (e.g. the script not
+    // existing yet) without proving anything about stripping behavior.
+    assert.ok(
+      stdout.includes(STRUCTURED_CHOICES_BODY_MARKER),
+      `precondition failed: stdout must carry the rule body before frontmatter-stripping can be checked; got stdout=${JSON.stringify(stdout)}`,
+    );
+    assert.ok(
+      !stdout.includes(FRONTMATTER_NAME_MARKER),
+      `stdout must not include raw frontmatter (${FRONTMATTER_NAME_MARKER}); got stdout=${JSON.stringify(stdout)}`,
+    );
+  });
+
+  it('T1d: stdout strips the managed-by marker line', () => {
+    const result = runScript(fixtureDir);
+    const stdout = result.stdout ?? '';
+    // Same anchoring as T1c: require the body to be present so this cannot
+    // pass vacuously against empty output.
+    assert.ok(
+      stdout.includes(TONE_BODY_MARKER),
+      `precondition failed: stdout must carry the rule body before marker-stripping can be checked; got stdout=${JSON.stringify(stdout)}`,
+    );
+    assert.ok(
+      !stdout.includes(MARKDOWN_MANAGED_MARKER),
+      `stdout must not include the raw managed-by marker line; got stdout=${JSON.stringify(stdout)}`,
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// T3 — fail-safe: one rule file absent
+// ---------------------------------------------------------------------------
+
+describe('S2 T3 — rules-injector.sh is fail-safe when one rule file is absent', () => {
+  beforeEach(() => {
+    fixtureDir = makeTmpDir();
+    const rulesDir = path.join(fixtureDir, '.claude', 'rules');
+    mkdirSync(rulesDir, { recursive: true });
+    // Only tone.md exists; structured-choices.md is missing.
+    writeFileSync(path.join(rulesDir, 'tone.md'), toneFixture(), 'utf8');
+  });
+
+  afterEach(() => {
+    rmSync(fixtureDir, { recursive: true, force: true });
+  });
+
+  it('T3a: still exits 0 when structured-choices.md is absent', () => {
+    const result = runScript(fixtureDir);
+    assert.equal(
+      result.status,
+      0,
+      `rules-injector.sh must exit 0 even when a rule file is absent (fail-safe); got status=${result.status}, stderr=${result.stderr}, error=${result.error}`,
+    );
+  });
+
+  it('T3b: still surfaces the present rule (tone.md) body on stdout', () => {
+    const result = runScript(fixtureDir);
+    assert.ok(
+      (result.stdout ?? '').includes(TONE_BODY_MARKER),
+      `stdout must still include the present tone.md body; got stdout=${JSON.stringify(result.stdout)}`,
+    );
+  });
+
+  it('T3c: emits at most a stderr note about the missing rule (does not crash silently on stdout)', () => {
+    const result = runScript(fixtureDir);
+    const stdout = result.stdout ?? '';
+    // Anchored to exit 0 + the present rule's body actually being emitted —
+    // otherwise "no fabricated content" would pass vacuously (e.g. against
+    // empty stdout from a script that doesn't exist yet or crashed outright)
+    // without proving the fail-safe skip behavior.
+    assert.equal(
+      result.status,
+      0,
+      `precondition failed: script must exit 0 before the fail-safe skip behavior can be checked; got status=${result.status}`,
+    );
+    assert.ok(
+      stdout.includes(TONE_BODY_MARKER),
+      `precondition failed: stdout must carry the present rule's body before checking the missing rule was skipped cleanly; got stdout=${JSON.stringify(stdout)}`,
+    );
+    // "at most a stderr note" — we don't require stderr, but if the script
+    // emits anything about the skip, it must go to stderr, not stdout, and
+    // must not fabricate content for the missing rule on stdout.
+    assert.ok(
+      !stdout.includes('structured-choices'),
+      `stdout must not fabricate content for the missing structured-choices.md; got stdout=${JSON.stringify(stdout)}`,
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// T5 — CRLF robustness: frontmatter fences with a trailing CR are still stripped
+// (regression anchor for M1 — the awk fence match must tolerate `---\r`, else
+// on a CRLF checkout the whole YAML frontmatter leaks into injected context).
+// ---------------------------------------------------------------------------
+
+describe('S2 T5 — rules-injector.sh strips frontmatter on a CRLF checkout', () => {
+  beforeEach(() => {
+    fixtureDir = makeTmpDir();
+    const rulesDir = path.join(fixtureDir, '.claude', 'rules');
+    mkdirSync(rulesDir, { recursive: true });
+    // Re-encode both fixtures with CRLF line endings, as a CRLF checkout would.
+    const toCRLF = (s) => s.replace(/\n/g, '\r\n');
+    writeFileSync(path.join(rulesDir, 'structured-choices.md'), toCRLF(structuredChoicesFixture()), 'utf8');
+    writeFileSync(path.join(rulesDir, 'tone.md'), toCRLF(toneFixture()), 'utf8');
+  });
+
+  afterEach(() => {
+    rmSync(fixtureDir, { recursive: true, force: true });
+  });
+
+  it('T5a: exits 0 and still emits the rule bodies on a CRLF checkout', () => {
+    const result = runScript(fixtureDir);
+    assert.equal(
+      result.status,
+      0,
+      `rules-injector.sh must exit 0 on a CRLF checkout; got status=${result.status}, stderr=${result.stderr}, error=${result.error}`,
+    );
+    assert.ok(
+      (result.stdout ?? '').includes(STRUCTURED_CHOICES_BODY_MARKER),
+      `stdout must still include the structured-choices.md body on a CRLF checkout; got stdout=${JSON.stringify(result.stdout)}`,
+    );
+  });
+
+  it('T5b: strips the CRLF frontmatter (no "name:" key and no bare "---" fence leaks)', () => {
+    const result = runScript(fixtureDir);
+    const stdout = result.stdout ?? '';
+    // Anchor to the body actually being emitted, so this cannot pass vacuously.
+    assert.ok(
+      stdout.includes(STRUCTURED_CHOICES_BODY_MARKER),
+      `precondition failed: stdout must carry the rule body before frontmatter-stripping can be checked; got stdout=${JSON.stringify(stdout)}`,
+    );
+    assert.ok(
+      !stdout.includes(FRONTMATTER_NAME_MARKER),
+      `stdout must not leak raw frontmatter (${FRONTMATTER_NAME_MARKER}) on a CRLF checkout; got stdout=${JSON.stringify(stdout)}`,
+    );
+    // No line should be a bare YAML fence (with or without a trailing CR).
+    assert.ok(
+      !/^---\r?$/m.test(stdout),
+      `stdout must not leak a bare "---" frontmatter fence on a CRLF checkout; got stdout=${JSON.stringify(stdout)}`,
+    );
+    // The managed-by marker must also be gone even with the trailing CR.
+    assert.ok(
+      !stdout.includes(MARKDOWN_MANAGED_MARKER),
+      `stdout must not leak the managed-by marker line on a CRLF checkout; got stdout=${JSON.stringify(stdout)}`,
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// T4 — fail-safe: no .claude/rules/ directory at all
+// ---------------------------------------------------------------------------
+
+describe('S2 T4 — rules-injector.sh is fail-safe when no rule files exist', () => {
+  beforeEach(() => {
+    fixtureDir = makeTmpDir();
+    // Deliberately do NOT create .claude/rules/ at all.
+  });
+
+  afterEach(() => {
+    rmSync(fixtureDir, { recursive: true, force: true });
+  });
+
+  it('T4: exits 0 when .claude/rules/ does not exist', () => {
+    const result = runScript(fixtureDir);
+    assert.equal(
+      result.status,
+      0,
+      `rules-injector.sh must exit 0 when .claude/rules/ is entirely absent; got status=${result.status}, stderr=${result.stderr}, error=${result.error}`,
+    );
+  });
+});