@event4u/agent-config 9.8.0 → 9.10.0

package/src/install/rtkDetection.ts

@@ -0,0 +1,274 @@
+/**
+ * rtk (Rust Token Killer) detection — two-stage identity probe.
+ *
+ * rtk is a THIRD-PARTY Apache-2.0 tool (upstream: https://github.com/rtk-ai/rtk,
+ * not an event4u project). Its binary name collides with an unrelated crate —
+ * `reachingforthejack/rtk` (Rust Type Kit), which is also what the bare
+ * crates.io `rtk` crate resolves to. Upstream's INSTALL.md documents the
+ * collision and the discriminator: `rtk gain` renders the token-savings
+ * dashboard only on Rust Token Killer.
+ *
+ * Stage 1 — presence: an executable named `rtk` resolvable on PATH.
+ * Stage 2 — identity: run `rtk gain` (short timeout) and judge the OUTPUT
+ * SIGNATURE, not the exit code (upstream documents no exit-code contract for
+ * `rtk gain`, and `rtk --version` does not distinguish the two tools — both
+ * print `rtk <ver>`). The signature is the dashboard header "RTK Token
+ * Savings" (captured live from rtk 0.43.0, 2026-07-28).
+ *
+ * Four states, never a boolean — a broken RIGHT tool is not the WRONG tool:
+ *   { present: false }
+ *   { present: true, identity: 'token-killer', version }  — signature matched
+ *   { present: true, identity: 'unknown-rtk' }            — probe ran, output
+ *       clearly not Token Killer (e.g. unknown-subcommand / usage error)
+ *   { present: true, identity: 'unverified' }             — timeout, spawn
+ *       failure, crash, or ambiguous (empty) output
+ *
+ * Consumers: the wizard `detect-rtk` endpoint, the `rtk:detect` CLI readout,
+ * and the `rtk_wrap` PreToolUse hook (which gates on
+ * `identity === 'token-killer'` — never on bare presence). Contract:
+ * docs/contracts/rtk-detection.md.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, statSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join, dirname } from 'node:path';
+
+export const RTK_UPSTREAM_REPO = 'https://github.com/rtk-ai/rtk';
+
+export type RtkIdentity = 'token-killer' | 'unknown-rtk' | 'unverified';
+
+export interface RtkDetection {
+    /** An executable named `rtk` is resolvable on PATH. */
+    present: boolean;
+    /** Only set when present. */
+    identity?: RtkIdentity;
+    /** Only set when identity === 'token-killer' (from `rtk --version`). */
+    version?: string;
+    /** Resolved binary path (diagnostic; only set when present). */
+    binPath?: string;
+}
+
+/**
+ * Output signature of Rust Token Killer's `rtk gain` savings dashboard.
+ * Rust Type Kit has no `gain` subcommand and errors with a usage message
+ * that never contains this header.
+ */
+const TOKEN_KILLER_GAIN_SIGNATURE = /RTK Token Savings/;
+
+/** Probe timeout — `rtk gain` renders from a local DB (sub-second upstream). */
+const PROBE_TIMEOUT_MS = 3000;
+
+/** Resolve the first executable named `name` on the given PATH string. */
+export function resolveBinaryOnPath(name: string, pathEnv?: string): string | null {
+    const pathVar = pathEnv ?? process.env['PATH'] ?? '';
+    if (pathVar.length === 0) return null;
+    const suffixes = process.platform === 'win32' ? ['', '.exe', '.cmd', '.bat'] : [''];
+    for (const dir of pathVar.split(delimiter)) {
+        if (dir.length === 0) continue;
+        for (const suffix of suffixes) {
+            const candidate = join(dir, `${name}${suffix}`);
+            if (existsSync(candidate)) return candidate;
+        }
+    }
+    return null;
+}
+
+export interface ProbeResult {
+    /** Process completed (spawned and exited, regardless of exit code). */
+    completed: boolean;
+    stdout: string;
+    stderr: string;
+}
+
+type ProbeFn = (binPath: string) => ProbeResult;
+
+function runGainProbe(binPath: string): ProbeResult {
+    try {
+        const res = spawnSync(binPath, ['gain'], {
+            timeout: PROBE_TIMEOUT_MS,
+            encoding: 'utf-8',
+            windowsHide: true,
+        });
+        // spawn error or timeout/signal kill → not a completed probe.
+        if (res.error !== undefined || res.signal !== null) {
+            return { completed: false, stdout: res.stdout ?? '', stderr: res.stderr ?? '' };
+        }
+        return { completed: true, stdout: res.stdout ?? '', stderr: res.stderr ?? '' };
+    } catch {
+        return { completed: false, stdout: '', stderr: '' };
+    }
+}
+
+function readVersion(binPath: string): string | undefined {
+    try {
+        const res = spawnSync(binPath, ['--version'], {
+            timeout: PROBE_TIMEOUT_MS,
+            encoding: 'utf-8',
+            windowsHide: true,
+        });
+        const m = /^rtk\s+(\S+)/m.exec(res.stdout ?? '');
+        return m?.[1];
+    } catch {
+        return undefined;
+    }
+}
+
+/** Judge identity from a finished probe — output signature, never exit code. */
+export function classifyGainOutput(probe: ProbeResult): RtkIdentity {
+    if (!probe.completed) return 'unverified';
+    const combined = `${probe.stdout}\n${probe.stderr}`;
+    if (TOKEN_KILLER_GAIN_SIGNATURE.test(probe.stdout)) return 'token-killer';
+    // Probe ran and produced output that is clearly not the savings dashboard
+    // (Rust Type Kit answers `gain` with a usage/unknown-subcommand error).
+    if (combined.trim().length > 0) return 'unknown-rtk';
+    // Completed silently with no output — ambiguous, don't accuse the tool.
+    return 'unverified';
+}
+
+export interface DetectRtkOptions {
+    /** Override PATH (tests / isolated probes). */
+    pathEnv?: string;
+    /** Override the gain probe (tests). */
+    probe?: ProbeFn;
+    /** Override the version read (tests). */
+    versionReader?: (binPath: string) => string | undefined;
+}
+
+/**
+ * Two-stage rtk detection. Never throws; failure modes collapse into
+ * `unverified` (fail-open for diagnostics, fail-CLOSED for consumers that
+ * gate behavior — `rtk_wrap` activates only on `token-killer`).
+ */
+export function detectRtk(options: DetectRtkOptions = {}): RtkDetection {
+    const binPath = resolveBinaryOnPath('rtk', options.pathEnv);
+    if (binPath === null) return { present: false };
+    const probe = options.probe ?? runGainProbe;
+    const identity = classifyGainOutput(probe(binPath));
+    if (identity !== 'token-killer') return { present: true, identity, binPath };
+    const version = (options.versionReader ?? readVersion)(binPath);
+    return version === undefined
+        ? { present: true, identity, binPath }
+        : { present: true, identity, version, binPath };
+}
+
+/* ------------------------------------------------------------------ */
+/* Cached variant — for high-frequency callers (PreToolUse hook).      */
+/* ------------------------------------------------------------------ */
+
+interface IdentityCacheEntry {
+    binPath: string;
+    mtimeMs: number;
+    size: number;
+    identity: RtkIdentity;
+    version?: string;
+    checkedAt: string;
+}
+
+function cacheFile(): string {
+    return join(homedir(), '.event4u', 'agent-config', 'state', 'rtk-identity.json');
+}
+
+/**
+ * `detectRtk` with a user-global identity cache keyed on the resolved binary's
+ * path + mtime + size — the probe re-runs only when the binary changes. An
+ * `unverified` verdict is never cached (transient by definition). Any cache
+ * I/O error falls through to a live probe (fail-open).
+ */
+export function detectRtkCached(options: DetectRtkOptions = {}): RtkDetection {
+    const binPath = resolveBinaryOnPath('rtk', options.pathEnv);
+    if (binPath === null) return { present: false };
+
+    let stat: { mtimeMs: number; size: number } | null = null;
+    try {
+        const st = statSync(binPath);
+        stat = { mtimeMs: st.mtimeMs, size: st.size };
+    } catch {
+        stat = null;
+    }
+
+    const file = cacheFile();
+    if (stat !== null) {
+        try {
+            const cached = JSON.parse(readFileSync(file, 'utf-8')) as IdentityCacheEntry;
+            if (
+                cached.binPath === binPath &&
+                cached.mtimeMs === stat.mtimeMs &&
+                cached.size === stat.size
+            ) {
+                return cached.version === undefined
+                    ? { present: true, identity: cached.identity, binPath }
+                    : { present: true, identity: cached.identity, version: cached.version, binPath };
+            }
+        } catch {
+            /* no / stale / unreadable cache — fall through to a live probe */
+        }
+    }
+
+    const detection = detectRtk(options);
+    if (stat !== null && detection.identity !== undefined && detection.identity !== 'unverified') {
+        const entry: IdentityCacheEntry = {
+            binPath,
+            mtimeMs: stat.mtimeMs,
+            size: stat.size,
+            identity: detection.identity,
+            checkedAt: new Date().toISOString(),
+        };
+        if (detection.version !== undefined) entry.version = detection.version;
+        try {
+            mkdirSync(dirname(file), { recursive: true });
+            writeFileSync(file, `${JSON.stringify(entry, null, 2)}\n`, 'utf-8');
+        } catch {
+            /* cache write is best-effort */
+        }
+    }
+    return detection;
+}
+
+/* ------------------------------------------------------------------ */
+/* Per-OS install commands — verified upstream paths only.             */
+/* ------------------------------------------------------------------ */
+
+export interface RtkInstallCommands {
+    /** The primary copy-and-run command for this platform. */
+    recommended: string;
+    /** Human-readable label for the recommended path. */
+    recommendedLabel: string;
+    /** Secondary/manual path (only where a packaged one may be unavailable). */
+    manual?: string;
+    manualLabel?: string;
+    /** Caveat the UI must surface next to the command. */
+    note?: string;
+}
+
+/**
+ * Per-OS install commands from verified upstream paths. NEVER emit a bare
+ * `cargo install rtk` — the crates.io `rtk` crate is the colliding Rust Type
+ * Kit, not Rust Token Killer.
+ */
+export function rtkInstallCommands(platform: NodeJS.Platform = process.platform): RtkInstallCommands {
+    switch (platform) {
+        case 'darwin':
+            return {
+                recommended: 'brew install rtk',
+                recommendedLabel: 'Homebrew (official homebrew-core formula)',
+            };
+        case 'win32':
+            return {
+                recommended: 'winget install rtk-ai.rtk',
+                recommendedLabel: 'Recommended (automated, winget)',
+                manual: `Download rtk-x86_64-pc-windows-msvc.zip from ${RTK_UPSTREAM_REPO}/releases and place rtk.exe on PATH`,
+                manualLabel: 'Manual (all Windows versions, incl. winget-less images)',
+                note:
+                    'ripgrep is a documented Windows runtime dependency: `winget install BurntSushi.ripgrep.MSVC`. ' +
+                    'The winget path is documented upstream (microsoft/winget-pkgs manifests) but has not been live-verified by agent-config — verify with `rtk gain` after install.',
+            };
+        default:
+            // linux + everything POSIX-ish: upstream's install.sh (errors out
+            // on unsupported platforms itself; installs to ~/.local/bin).
+            return {
+                recommended: `curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/master/install.sh | sh`,
+                recommendedLabel: "Upstream install.sh (installs to ~/.local/bin)",
+                note: 'Ensure ~/.local/bin is on PATH.',
+            };
+    }
+}

package/src/install/rule_scope.ts

@@ -36,10 +36,16 @@ import { rule_in_scope } from '../scripts/condense.js';
  */
 export const COMPAT_ALWAYS_EXCLUDED: readonly string[] = ['source-of-truth.md'];
 
-/** Workspace/pack scope read from consumer settings. `null` axis = unset. */
+/**
+ * Workspace/pack/role scope read from consumer settings. `null` axis =
+ * unset. `roles` is optional (additive — road-to-lean-agent-init Phase 4,
+ * the subagent role-scoping axis) so pre-existing `RuleScope` literals
+ * without the field keep compiling unchanged.
+ */
 export interface RuleScope {
     readonly workspaces: readonly string[] | null;
     readonly packs: readonly string[] | null;
+    readonly roles?: readonly string[] | null;
 }
 
 export const LEGACY_ALL: RuleScope = { workspaces: null, packs: null };
@@ -66,6 +72,7 @@ export function ruleScopeFromSettings(settings: Record<string, unknown>): RuleSc
     return {
         workspaces: _list(p['rule_workspaces']),
         packs: _list(p['rule_packs']),
+        roles: _list(p['rule_roles']),
     };
 }
 
@@ -85,7 +92,7 @@ export function ruleFileArrives(sourcePath: string, scope: RuleScope): boolean {
     if (COMPAT_ALWAYS_EXCLUDED.includes(basename)) {
         return false;
     }
-    return rule_in_scope(sourcePath, scope.workspaces, scope.packs);
+    return rule_in_scope(sourcePath, scope.workspaces, scope.packs, scope.roles ?? null);
 }
 
 /**

package/src/install/types.ts

@@ -2,7 +2,7 @@
  * Core types for the unified TypeScript install engine (v4.0.0).
  *
  * Mirrors the on-disk schema used by the legacy Python installer
- * (`scripts/install.py`) so the v4 engine reads/writes the same
+ * (the retired Python installer, ADR-200) so the v4 engine reads/writes the same
  * `~/.event4u/agent-config/` tree and v2 manifest entries without a
  * migration step.
  *
@@ -10,7 +10,7 @@
  * apply, and conflict-resolution modules. Pure types, no runtime
  * dependencies.
  *
- * Reference: `scripts/install.py`
+ * Reference: the retired Python installer (ADR-200)
  *   - `_file_entry()` → {@link FileEntry}
  *   - `class ConflictPolicy` → {@link ConflictPolicy}
  *   - v2 manifest `files_by_tool` → {@link InstallPlan.filesByTool}

package/src/install/wizard-plan.ts

@@ -63,7 +63,7 @@ export const USER_SCOPE_PATHS: Readonly<Record<string, string>> = {
 
 /**
  * Universal Anthropic-shaped skill bundle deployed to markdown-skills
- * tools. Mirrors `_CLAUDE_SKILL_BUNDLE` in `scripts/install.py`.
+ * tools. Mirrors `_CLAUDE_SKILL_BUNDLE` in the retired Python installer (ADR-200).
  */
 const CLAUDE_SKILL_BUNDLE: ReadonlyArray<readonly [string, string]> = [
     ['dist/agent-src/rules',    'rules'],

package/src/install/wizardDismissals.ts

@@ -0,0 +1,60 @@
+/**
+ * Permanent wizard-recommendation dismissals, persisted at
+ * `~/.event4u/agent-config/wizard-dismissals.json`.
+ *
+ * A dismissed recommendation (e.g. `"agent-switch"`) never returns — there
+ * is deliberately NO un-dismiss function (S0.1 council verdict, 2026-07-28:
+ * a passive row the user closed once stays closed). The file lives in the
+ * user-global config root, not inside the installed package, so a
+ * dismissal survives package updates.
+ *
+ * `AGENT_CONFIG_WIZARD_DISMISSALS` overrides the path (tests only).
+ */
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve, dirname } from 'node:path';
+
+function wizardDismissalsPath(): string {
+    const override = process.env['AGENT_CONFIG_WIZARD_DISMISSALS'];
+    if (override !== undefined && override.length > 0) return override;
+    return resolve(homedir(), '.event4u', 'agent-config', 'wizard-dismissals.json');
+}
+
+interface DismissalsFile {
+    dismissed?: unknown;
+}
+
+/**
+ * Return the recorded dismissal ids, or `[]` when absent / unreadable.
+ * Best-effort: a missing or corrupted file behaves as "nothing dismissed
+ * yet" rather than throwing.
+ */
+export function readDismissedRecommendations(): readonly string[] {
+    try {
+        const raw = readFileSync(wizardDismissalsPath(), 'utf8');
+        const parsed = JSON.parse(raw) as DismissalsFile;
+        return Array.isArray(parsed.dismissed)
+            ? parsed.dismissed.filter((d): d is string => typeof d === 'string')
+            : [];
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Record `id` as permanently dismissed. Idempotent — a repeat call for an
+ * already-dismissed id is a no-op.
+ */
+export function dismissRecommendation(id: string): void {
+    try {
+        const existing = readDismissedRecommendations();
+        if (existing.includes(id)) return;
+        const path = wizardDismissalsPath();
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        const record = { dismissed: [...existing, id] };
+        writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    } catch {
+        // Best-effort: a failed write just means the recommendation may
+        // resurface on the next load — never throw out of a dismiss action.
+    }
+}

package/src/scripts/_cli/cmd_doctor.ts

@@ -30,7 +30,8 @@
  * lockfile-freshness · bridge-drift · mcp-mode · mcp-beta-readiness ·
  * offline-readiness · python-runtime · humanizer-runtime · tier-usage-readiness ·
  * council-cli · team ·
- * unsupported-combos · wizard-state.
+ * unsupported-combos · wizard-state · settings-review-pending ·
+ * memory-merge-union · duplicate-scope-rules.
  * Each emits a structured `{id, status, message, remedy}` record with
  * `status` ∈ `ok` / `warn` / `fail` / `skipped` (rendered
  * `✅` / `⚠️` / `❌` / `⏭️`). `--check <id>` runs a single check.
@@ -88,6 +89,8 @@ import * as installed_lock from '../_lib/installed_lock.js';
 import * as installed_tools from '../_lib/installed_tools.js';
 import * as user_global_paths from '../_lib/user_global_paths.js';
 import * as global_deploy_inventory from '../_lib/global_deploy_inventory.js';
+import { censusDuplicateScope } from '../_lib/duplicate_scope_census.js';
+import * as sync_gitattributes from '../sync_gitattributes.js';
 import {
     PROJECT_ROOT_ENV,
     ROOT_OVERRIDE_ENV,
@@ -509,7 +512,7 @@ function splitlines(text: string): string[] {
 
 /** Python `str.rstrip()` (default whitespace, ASCII+Unicode). */
 function rstrip(s: string): string {
-    return s.replace(/[\s… ]+$/u, '');
+    return s.replace(/[\s\u0085 ]+$/u, '');
 }
 
 /** Python `value.strip().strip("'\"")` tail (after `.strip()` already done). */
@@ -759,6 +762,8 @@ const CHECK_IDS = [
     'unsupported-combos',
     'wizard-state',
     'settings-review-pending',
+    'memory-merge-union',
+    'duplicate-scope-rules',
 ] as const;
 
 /** Checks that need only the project root and run regardless of a lockfile. */
@@ -782,6 +787,8 @@ const GLOBAL_CHECK_IDS: ReadonlySet<string> = new Set([
     'team',
     'wizard-state',
     'settings-review-pending',
+    'memory-merge-union',
+    'duplicate-scope-rules',
 ]);
 
 /** Checks that genuinely cannot run without the project manifest. */
@@ -1735,6 +1742,76 @@ function _check_rule_scope_drift(project_root: string): Dict {
     };
 }
 
+/**
+ * Duplicate-scope rule detection (road-to-cache-economy Phase 3, C-2 —
+ * confirmed at 38.5% of subagent write volume on this maintainer's own
+ * checkout). When the same `.md` rule filenames are installed at BOTH the
+ * user-scope Claude Code config (`~/.claude/rules`) and the project scope,
+ * every session AND every subagent spawn injects two near-identical copies
+ * of the same rule set. This check is DETECTION ONLY: it reports the
+ * measured redundant-token estimate and names which copy is authoritative —
+ * it never deletes, rewrites, or otherwise touches a user's files (per
+ * `non-destructive-by-default`).
+ *
+ * Project scope resolves the same way the census in
+ * `cache_realization_report.ts` does: `dist/agent-src/rules` in this
+ * source repo itself (the only place the ~37% finding was measured), or the
+ * first populated {@link _RULE_PROJECTION_DIRS} entry in a consumer install.
+ * `userRulesDirOverride` exists solely so tests never touch the real
+ * `~/.claude/rules` on the machine running the suite.
+ */
+function _check_duplicate_scope_rules(project_root: string, userRulesDirOverride?: string): Dict {
+    const user_rules_dir = userRulesDirOverride ?? path.join(os.homedir(), '.claude', 'rules');
+
+    let project_rules_dir: string | null = null;
+    if (_is_source_repo(project_root)) {
+        const cand = path.join(project_root, 'dist', 'agent-src', 'rules');
+        if (isDir(cand)) project_rules_dir = cand;
+    } else {
+        for (const rel of _RULE_PROJECTION_DIRS) {
+            const cand = path.join(project_root, rel);
+            if (isDir(cand)) {
+                project_rules_dir = cand;
+                break;
+            }
+        }
+    }
+
+    if (project_rules_dir === null) {
+        return {
+            id: 'duplicate-scope-rules',
+            status: 'skipped',
+            message: 'no project-scope rule tree found (dist/agent-src/rules, .augment/rules, …) — nothing to compare against the user-scope copy',
+            remedy: '',
+        };
+    }
+
+    const census = censusDuplicateScope(user_rules_dir, project_rules_dir);
+    if (!census.evaluable) {
+        return {
+            id: 'duplicate-scope-rules',
+            status: 'ok',
+            message: census.reason ?? 'no duplicate-scope rule install detected',
+            remedy: '',
+        };
+    }
+
+    const tokens = Math.round(census.duplicate_chars / 4);
+    const rel_project = relativeTo(project_rules_dir, project_root) ?? project_rules_dir;
+    return {
+        id: 'duplicate-scope-rules',
+        status: 'warn',
+        message:
+            `${census.shared_filenames.length} rule(s) installed at BOTH user scope (${user_rules_dir}) and ` +
+            `project scope (${rel_project}) — an estimated ${tokens} redundant tokens are injected on every ` +
+            'session AND every subagent spawn (both copies are always-loaded). Project scope is authoritative ' +
+            'for this checkout.',
+        remedy:
+            'detection only — no file is modified. If the duplication is unwanted, refresh the user-scope copy ' +
+            '(e.g. `agent-config global`) to re-sync it with the project-scope version.',
+    };
+}
+
 function _check_python_runtime(): Dict {
     // Post-teardown: the package runtime is TypeScript-on-`tsx`. python3 is no
     // longer a runtime dependency, so this check no longer probes for an
@@ -2557,6 +2634,61 @@ function _check_settings_review_pending(): Dict {
     };
 }
 
+/**
+ * `memory-merge-union` — read-only warn check (road-to-reachable-code-memory
+ * Phase 5). The `merge=union` .gitattributes block lets two branches each
+ * appending a NEW memory entry (intake JSONL, or the flat curated
+ * `agents/memory/<type>.yml` files) merge cleanly instead of conflicting.
+ * Without it, ordinary parallel memory writes on separate branches produce a
+ * merge conflict the human has to resolve by hand. Never fails the run —
+ * this is advisory, same posture as `offline-readiness`.
+ */
+function _check_memory_merge_union(project_root: string): Dict {
+    const remedy =
+        'run: npx tsx src/scripts/sync_gitattributes.ts (or `agent-config refresh --project`)';
+    const target = path.join(project_root, sync_gitattributes.DEFAULT_GITATTRIBUTES);
+    if (!pathExists(target)) {
+        return {
+            id: 'memory-merge-union',
+            status: 'warn',
+            message:
+                'no .gitattributes at project root — memory merge-safety attributes not applied',
+            remedy,
+        };
+    }
+    let text: string;
+    try {
+        text = readText(target);
+    } catch (exc) {
+        return {
+            id: 'memory-merge-union',
+            status: 'warn',
+            message: `unreadable .gitattributes at ${target}: ${osErrorStr(exc)}`,
+            remedy,
+        };
+    }
+    const has_block = text.includes(sync_gitattributes.SECTION_HEADER);
+    const has_intake_union = /agents\/memory\/intake\/\*\.jsonl\s+merge=union/.test(text);
+    if (has_block && has_intake_union) {
+        return {
+            id: 'memory-merge-union',
+            status: 'ok',
+            message:
+                '.gitattributes carries the memory merge-safety block (intake JSONL union-merge present)',
+            remedy: '',
+        };
+    }
+    return {
+        id: 'memory-merge-union',
+        status: 'warn',
+        message: has_block
+            ? '.gitattributes has the managed block but is missing the intake merge=union line'
+            : '.gitattributes is missing the memory merge-safety block — parallel-branch ' +
+              'memory writes can conflict instead of merging',
+        remedy,
+    };
+}
+
 interface JsonDecodeError {
     msg: string;
     lineno: number;
@@ -2691,6 +2823,8 @@ function _run_checks(
         'unsupported-combos': () => _check_unsupported_combos(manifest),
         'wizard-state': _check_wizard_state,
         'settings-review-pending': _check_settings_review_pending,
+        'memory-merge-union': () => _check_memory_merge_union(project_root),
+        'duplicate-scope-rules': () => _check_duplicate_scope_rules(project_root),
     };
     const out: Dict[] = [];
     for (const cid of CHECK_IDS) {
@@ -2765,6 +2899,8 @@ function _run_checks_no_manifest(
         'unsupported-combos': () => _skipped_manifest_check('unsupported-combos'),
         'wizard-state': _check_wizard_state,
         'settings-review-pending': _check_settings_review_pending,
+        'memory-merge-union': () => _check_memory_merge_union(project_root),
+        'duplicate-scope-rules': () => _check_duplicate_scope_rules(project_root),
     };
     const out: Dict[] = [];
     for (const cid of CHECK_IDS) {
@@ -3247,6 +3383,7 @@ export {
     _check_offline_readiness,
     _check_stale_orphans,
     _check_rule_scope_drift,
+    _check_duplicate_scope_rules,
     _check_python_runtime,
     _check_humanizer_runtime,
     _check_mcp_beta_readiness,