@event4u/agent-config 9.7.0 → 9.9.0

package/src/install/agentSwitchProfile.ts

@@ -0,0 +1,131 @@
+/**
+ * Detect whether AC is currently running under an agent-switch (AS)
+ * profile (`road-to-reciprocal-ecosystem.md` Phase 2 — correctness
+ * work, not the Phase 1 promotion card).
+ *
+ * Pure and injectable: reads only the supplied environment map, no
+ * filesystem I/O. Detection is deliberately topology-free — it never
+ * needs to understand AS's on-disk share model (that lives in
+ * `sharedWriteCheck.ts`, which DOES touch disk via `lstat`).
+ *
+ * AS root resolution mirrors `agent-switch/src/profiles.ts:11`:
+ * `AGENT_SWITCH_HOME` env override, else `~/.agent-switch`. Profile
+ * config dirs live at `<ROOT>/<provider>/<name>/config` (profiles.ts
+ * :143-145). Provider env vars mirror `agent-switch/src/providers.ts`:
+ * claude → `CLAUDE_CONFIG_DIR`, codex → `CODEX_HOME`. `HOME`
+ * (antigravity's provider var) is deliberately NOT checked here — it
+ * is set on every process, so treating it as an AS signal would
+ * false-positive constantly; antigravity profile detection is left to
+ * a future, more specific probe.
+ */
+import { homedir } from 'node:os';
+import * as path from 'node:path';
+
+export interface AgentSwitchProfile {
+    active: boolean;
+    provider: string | null;
+    profile: string | null;
+}
+
+const INACTIVE: AgentSwitchProfile = { active: false, provider: null, profile: null };
+
+/** Provider env vars checked, in priority order (claude wins on a tie). */
+const PROVIDER_ENV_VARS: readonly string[] = ['CLAUDE_CONFIG_DIR', 'CODEX_HOME'];
+
+interface AgentSwitchMatch {
+    /** The resolved AS root implied by the matching env var. */
+    root: string;
+    /** Path segments below `root` (e.g. `[provider, profile, 'config']`). */
+    afterRoot: string[];
+}
+
+/** Expand a leading `~` the way a shell would, for env values set programmatically. */
+function expandTilde(p: string): string {
+    if (p === '~') return homedir();
+    if (p.startsWith('~/') || (process.platform === 'win32' && p.startsWith('~\\'))) {
+        return path.join(homedir(), p.slice(2));
+    }
+    return p;
+}
+
+function normalize(p: string): string {
+    return path.resolve(expandTilde(p));
+}
+
+function nonEmpty(v: string | undefined): v is string {
+    return typeof v === 'string' && v.trim() !== '';
+}
+
+/**
+ * Find the first provider env var whose (normalized) value lies
+ * inside the AS root, and return the root + the path segments below
+ * it. Shared by `detectAgentSwitchProfile` and `resolveAgentSwitchRoot`
+ * so both stay in lockstep with a single matching rule.
+ */
+function resolveMatch(env: NodeJS.ProcessEnv): AgentSwitchMatch | null {
+    const overrideRaw = env['AGENT_SWITCH_HOME'];
+    const overrideRoot = nonEmpty(overrideRaw) ? normalize(overrideRaw) : null;
+
+    for (const varName of PROVIDER_ENV_VARS) {
+        const raw = env[varName];
+        if (!nonEmpty(raw)) continue;
+        const candidate = normalize(raw);
+
+        let root: string | null = null;
+        if (overrideRoot !== null) {
+            if (candidate === overrideRoot || candidate.startsWith(overrideRoot + path.sep)) {
+                root = overrideRoot;
+            }
+        } else {
+            const bareMarker = `${path.sep}.agent-switch`;
+            const nestedMarker = `${bareMarker}${path.sep}`;
+            if (candidate.endsWith(bareMarker)) {
+                root = candidate;
+            } else {
+                const idx = candidate.indexOf(nestedMarker);
+                if (idx !== -1) root = candidate.slice(0, idx + bareMarker.length);
+            }
+        }
+        if (root === null) continue;
+
+        const rest = candidate === root ? '' : candidate.slice(root.length + 1);
+        const afterRoot = rest === '' ? [] : rest.split(path.sep).filter((s) => s.length > 0);
+        return { root, afterRoot };
+    }
+    return null;
+}
+
+/**
+ * Detect the active AS profile (if any) from the current environment.
+ *
+ * - Not inside `.agent-switch` at all → `{ active: false, ... }`.
+ * - Inside the AS root, but the env var points AT the root itself
+ *   (no `<provider>/<profile>` segments below it) → treated as
+ *   inactive; an env var pointing at the bare root is not a profile
+ *   directory.
+ * - Inside the AS root with only one segment below it (a provider dir
+ *   with no profile name) → active, but unparseable (`provider`/
+ *   `profile` both `null`).
+ * - Inside the AS root with `<provider>/<profile>/...` below it →
+ *   active, with `provider`/`profile` parsed from the first two
+ *   segments.
+ */
+export function detectAgentSwitchProfile(env: NodeJS.ProcessEnv = process.env): AgentSwitchProfile {
+    const match = resolveMatch(env);
+    if (match === null) return INACTIVE;
+    if (match.afterRoot.length === 0) return INACTIVE;
+    if (match.afterRoot.length < 2) return { active: true, provider: null, profile: null };
+    // `length >= 2` guaranteed above — `??` only satisfies noUncheckedIndexedAccess.
+    return { active: true, provider: match.afterRoot[0] ?? null, profile: match.afterRoot[1] ?? null };
+}
+
+/**
+ * Resolve the AS root directory implied by the environment (the same
+ * matching rule `detectAgentSwitchProfile` uses), for callers that
+ * need a boundary to stop an upward filesystem walk at — see
+ * `sharedWriteCheck.ts`. Returns `null` when no provider env var
+ * resolves inside an AS tree.
+ */
+export function resolveAgentSwitchRoot(env: NodeJS.ProcessEnv = process.env): string | null {
+    return resolveMatch(env)?.root ?? null;
+}

package/src/install/atomic.ts

@@ -2,7 +2,7 @@
  * Atomic file writer — Phase A4 primitive.
  *
  * 1:1 port of the `tempfile.mkstemp` + `os.replace` pattern used across
- * `scripts/install.py` (see `_write_consumer_bridge_marker` ~line 3036).
+ * the retired Python installer's `_write_consumer_bridge_marker` (ADR-200).
  *
  * Contract:
  *   1. Open a sibling `.tmp.<rand>` file in the destination directory

package/src/install/detect.ts

@@ -26,7 +26,7 @@ import type { InstallTarget } from './types.js';
 /**
  * Settings-file name used as the strongest project-scope signal.
  *
- * Matches `SETTINGS_FILE` in `scripts/install.py`. Presence in `cwd`
+ * Matches `SETTINGS_FILE` in the retired Python installer (ADR-200). Presence in `cwd`
  * short-circuits scope detection to `'project'` without consulting
  * the manifest / AI-tool lists.
  */

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.
  * 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,7 @@ 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 * as sync_gitattributes from '../sync_gitattributes.js';
 import {
     PROJECT_ROOT_ENV,
     ROOT_OVERRIDE_ENV,
@@ -759,6 +761,7 @@ const CHECK_IDS = [
     'unsupported-combos',
     'wizard-state',
     'settings-review-pending',
+    'memory-merge-union',
 ] as const;
 
 /** Checks that need only the project root and run regardless of a lockfile. */
@@ -782,6 +785,7 @@ const GLOBAL_CHECK_IDS: ReadonlySet<string> = new Set([
     'team',
     'wizard-state',
     'settings-review-pending',
+    'memory-merge-union',
 ]);
 
 /** Checks that genuinely cannot run without the project manifest. */
@@ -2557,6 +2561,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 +2750,7 @@ 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),
     };
     const out: Dict[] = [];
     for (const cid of CHECK_IDS) {
@@ -2765,6 +2825,7 @@ 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),
     };
     const out: Dict[] = [];
     for (const cid of CHECK_IDS) {