@event4u/agent-config 8.6.0 → 8.7.0

package/dist/scripts/condense.js

@@ -0,0 +1,2181 @@
+#!/usr/bin/env tsx
+/**
+ * Agent-config sync — condense .agent-src.uncondensed/ → dist/agent-src/
+ * and project dist/agent-src/ → .augment/ (copies for rules by default,
+ * symlinks for the rest; opt into rule symlinks via
+ * augment.rules_use_symlinks in .agent-settings.yml).
+ *
+ * Ported from the retired Python `src/scripts/condense.py` (ADR-200 — Python→TS
+ * migration, Phase 5). Mirrors the Python CLI surface EXACTLY — every
+ * subcommand (`--sync`, `--list`, `--changed`, `--check`, `--check-hashes`,
+ * `--clean-hashes`, `--mark-done <path>`, `--mark-all-done`,
+ * `--generate-tools`, `--clean-tools`, `--project-augment`) — same flags,
+ * exit codes, stdout/stderr split, byte-identical messages. No behaviour
+ * changes; historical quirks preserved and flagged.
+ *
+ * Path handling note: the retired Python implementation uses `pathlib.Path` objects.
+ * This twin uses absolute path strings (the host filesystem on the
+ * supported platforms is POSIX). Logical relative paths are always POSIX
+ * (forward-slash) strings, matching the Python `.as_posix()` keys.
+ *
+ * Module-level constants (PROJECT_ROOT, SOURCE_DIR, TARGET_DIR, …) and the
+ * multi-root helper functions (iter_all_sources, resolve_logical,
+ * artefact_roots) are exposed through a mutable module-state object so the
+ * pytest suite's monkeypatch pattern — reassigning `condense.PROJECT_ROOT`,
+ * `condense.HASH_FILE`, `condense.iter_all_sources`, … — has a faithful TS
+ * equivalent. Tests mutate `MODULE_STATE` via the exported setters.
+ */
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import * as YAML from 'yaml';
+import { artefact_roots as _agent_src_artefact_roots, iter_all_sources as _agent_src_iter_all_sources, resolve_logical as _agent_src_resolve_logical, strip_source_prefix, } from './_lib/agent_src.js';
+import { build_claude_hook_matrix } from './_lib/claude_settings_hooks.js';
+import { project_settings_path, load_agent_settings } from './_lib/agent_settings.js';
+import { info, success, flush_summary, resolve_level } from './_lib/script_output.js';
+import { TIER_TO_CLAUDE_MODEL as _TIER_TO_CLAUDE_MODEL, MODEL_TIER_RE as _MODEL_TIER_RE, } from './_lib/model_tier.js';
+// The Python module imports `_SLUG_PREFIX_RE` from `_lib.agent_src`. The TS
+// twin does not re-export that private regex, so reproduce it locally — it is
+// only used by `_domains_slug_prefix` below (PROJECT_ROOT-aware mirror).
+const _SLUG_PREFIX_RE = /^slug_prefix:\s*"?([a-z][a-z0-9-]*)"?\s*$/m;
+/**
+ * Best-effort YAML parse mirroring Python's `yaml.safe_load` tolerance.
+ * Returns `null` on any parse failure (callers treat that as "no data").
+ * version '1.1' matches PyYAML's bool/int quirks so frontmatter parses
+ * identically. A STATIC import (not a lazy `require`) — `require` is not
+ * reliably available under ESM/tsx, which silently degraded dependency
+ * folding to a plain file hash when condense.ts ran as the main module.
+ */
+function _yamlParse(text) {
+    try {
+        const data = YAML.parse(text, { version: '1.1' });
+        return data === undefined ? null : data;
+    }
+    catch {
+        return null;
+    }
+}
+// --- Filesystem helpers reproducing pathlib semantics ------------------------
+function _exists(p) {
+    try {
+        fs.lstatSync(p);
+        fs.statSync(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Path.exists() OR Path.is_symlink() — true even for a broken symlink. */
+function _existsOrSymlink(p) {
+    try {
+        fs.lstatSync(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function _isDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function _isFile(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function _isSymlink(p) {
+    try {
+        return fs.lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/** `Path.is_dir()` that does NOT follow a symlink (lstat-based). */
+function _isDirNoFollow(p) {
+    try {
+        return fs.lstatSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function _readText(p) {
+    return fs.readFileSync(p, 'utf-8');
+}
+function _writeText(p, text) {
+    fs.writeFileSync(p, text, 'utf-8');
+}
+function _mkdirp(p) {
+    fs.mkdirSync(p, { recursive: true });
+}
+/** Sorted immediate children as absolute paths (mirrors sorted(p.iterdir())). */
+function _iterdirSorted(p) {
+    let names;
+    try {
+        names = fs.readdirSync(p);
+    }
+    catch {
+        return [];
+    }
+    names.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    return names.map((n) => path.join(p, n));
+}
+/**
+ * Mirror `root.rglob(pattern)` → SORTED absolute path strings. Yields every
+ * descendant (files AND dirs) whose name matches; callers sort, so sort here
+ * by the POSIX-string key Python uses. `pattern` is `"*"` or a `"*<suffix>"`
+ * suffix glob.
+ */
+function _rglobSorted(root, pattern) {
+    const out = [];
+    const suffix = pattern === '*' ? null : pattern.slice(1);
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            const full = path.join(dir, ent.name);
+            const matches = suffix === null ? true : ent.name.endsWith(suffix);
+            if (matches) {
+                out.push(full);
+            }
+            if (ent.isDirectory() || (ent.isSymbolicLink() && _isDir(full))) {
+                walk(full);
+            }
+        }
+    };
+    walk(root);
+    out.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    return out;
+}
+function _relativeToPosix(child, root) {
+    const rel = path.relative(root, child);
+    return rel.split(path.sep).join('/');
+}
+function _isUnder(child, root) {
+    const rel = path.relative(root, child);
+    return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+/** POSIX `parts` of a path string, dropping empty segments (mirrors Path.parts). */
+function _posixParts(p) {
+    return p.split('/').filter((s) => s.length > 0);
+}
+/** Python str.lstrip() with no args — strip leading Unicode whitespace. */
+function _lstrip(s) {
+    return s.replace(/^\s+/u, '');
+}
+/** Python str.strip() with no args — strip leading/trailing Unicode whitespace. */
+function _strip(s) {
+    return s.replace(/^\s+/u, '').replace(/\s+$/u, '');
+}
+/** Python str.lstrip("\n") — strip only leading newlines. */
+function _lstripNewlines(s) {
+    return s.replace(/^\n+/, '');
+}
+/** Python `.strip('"').strip("'")` — strip the given chars from both ends. */
+function _stripChars(s, chars) {
+    let start = 0;
+    let end = s.length;
+    while (start < end && chars.includes(s[start]))
+        start += 1;
+    while (end > start && chars.includes(s[end - 1]))
+        end -= 1;
+    return s.slice(start, end);
+}
+// =============================================================================
+// Module state — mutable mirror of the Python module-level constants & hooks.
+//
+// The pytest suite reassigns `condense.PROJECT_ROOT`, `condense.HASH_FILE`,
+// `condense.TARGET_DIR`, `condense.SOURCE_DIR`, `condense.RULES_SOURCE`,
+// `condense.SKILLS_SOURCE`, `condense.COMMANDS_SOURCE`,
+// `condense.CLAUDE_SKILLS_DIR`, `condense.AUGMENT_DIR`, `condense.SETTINGS_FILE`,
+// and the helper functions `condense.iter_all_sources`,
+// `condense.resolve_logical`, `condense.artefact_roots`. All such state lives
+// here so TS tests can inject the same way via the exported setters.
+//
+// PROJECT_ROOT default: Path(__file__).resolve().parent.parent.parent — the
+// .py file lives at <repo>/src/scripts/condense.py, so three parents up is
+// the repo root.
+// =============================================================================
+const _HERE = path.dirname(fileURLToPath(import.meta.url)); // <repo>/src/scripts
+const _DEFAULT_PROJECT_ROOT = path.resolve(_HERE, '..', '..');
+function _deriveState(root) {
+    return {
+        PROJECT_ROOT: root,
+        SOURCE_DIR: path.join(root, '.agent-src.uncondensed'),
+        TARGET_DIR: path.join(root, 'dist/agent-src'),
+        AUGMENT_DIR: path.join(root, '.augment'),
+        HASH_FILE: path.join(root, 'internal', '.condensation-hashes.json'),
+        SETTINGS_FILE: project_settings_path(root),
+        RULES_SOURCE: path.join(root, 'dist/agent-src', 'rules'),
+        SKILLS_SOURCE: path.join(root, 'dist/agent-src', 'skills'),
+        COMMANDS_SOURCE: path.join(root, 'dist/agent-src', 'commands'),
+        PERSONAS_SOURCE: path.join(root, 'dist/agent-src', 'personas'),
+        USER_TYPES_SOURCE: path.join(root, 'dist/agent-src', 'user-types'),
+        CLAUDE_SKILLS_DIR: path.join(root, '.claude', 'skills'),
+        // ADR-109: subagents project from src/ directly (NOT dist/) — a subagent
+        // is an executable system prompt Claude Code runs verbatim; telegraph
+        // condensation would alter its behaviour, and it is not routed through the
+        // pack/discovery condensation flow.
+        CLAUDE_AGENTS_DIR: path.join(root, '.claude', 'agents'),
+        SUBAGENTS_SOURCE: path.join(root, 'src', 'subagents'),
+        PLUGIN_SKILLS_DIR: path.join(root, '.claude-plugin', 'skills'),
+        iter_all_sources: _agent_src_iter_all_sources,
+        resolve_logical: _agent_src_resolve_logical,
+        artefact_roots: _agent_src_artefact_roots,
+    };
+}
+export const MODULE_STATE = _deriveState(_DEFAULT_PROJECT_ROOT);
+/**
+ * Test seam — reassign one or more module-state fields, mirroring the pytest
+ * monkeypatch of `condense.<NAME> = ...`. When `PROJECT_ROOT` is overridden,
+ * SETTINGS_FILE is NOT recomputed (Python tests set it explicitly when they
+ * need it) — only the literally-supplied keys change. Not part of the Python
+ * surface; a TS-only injection point.
+ */
+export function _setStateForTest(overrides) {
+    Object.assign(MODULE_STATE, overrides);
+}
+/** Snapshot module state for save/restore in tests. */
+export function _getStateForTest() {
+    return { ...MODULE_STATE };
+}
+/**
+ * Re-derive ALL module-state fields from a fresh PROJECT_ROOT (mirrors the
+ * Python convention where every constant is recomputed from PROJECT_ROOT).
+ * Convenience for tests that want a clean tmp-root layout.
+ */
+export function _resetStateForTest(root = _DEFAULT_PROJECT_ROOT) {
+    Object.assign(MODULE_STATE, _deriveState(root));
+}
+// Convenience accessors used internally — read through MODULE_STATE so a test
+// override is always honoured.
+function _iter_sources() {
+    // Wraps the injectable iter_all_sources hook (mirrors condense._iter_sources).
+    return MODULE_STATE.iter_all_sources();
+}
+function _resolve_source(relative) {
+    return MODULE_STATE.resolve_logical(relative);
+}
+function _any_source_root_exists() {
+    return [...MODULE_STATE.artefact_roots()].length > 0;
+}
+// --- Self-projection tool toggle ---------------------------------------------
+const _ALL_TOOLS = new Set([
+    'claude-code',
+    'claude-desktop',
+    'augment',
+    'copilot',
+    'cursor',
+    'windsurf',
+    'cline',
+    'gemini',
+]);
+void _ALL_TOOLS;
+function _active_tools() {
+    const tools_file = path.join(MODULE_STATE.PROJECT_ROOT, 'agents', '.agent-tools.yml');
+    if (!_exists(tools_file)) {
+        return null;
+    }
+    // Mirrors Python's `yaml.safe_load`; a malformed file → YAMLError → null
+    // (treated as "all tools").
+    let data = _yamlParse(_readText(tools_file));
+    if (data === null || data === undefined) {
+        data = {};
+    }
+    const tools = typeof data === 'object' && data !== null && !Array.isArray(data)
+        ? data['tools']
+        : null;
+    if (!Array.isArray(tools)) {
+        return null;
+    }
+    return new Set(tools.filter((t) => typeof t === 'string'));
+}
+function _tool_active(tool_id) {
+    const active = _active_tools();
+    return active === null ? true : active.has(tool_id);
+}
+// Files to copy as-is even if .md (not condensed by agent).
+const COPY_AS_IS = new Set(['README.md']);
+// Directories whose .md content is data, not prose — copied verbatim.
+const COPY_AS_IS_DIRS = new Set(['ghostwriter']);
+// --- settings readers --------------------------------------------------------
+function _read_augment_rules_use_symlinks() {
+    const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+    const augment = data['augment'];
+    if (typeof augment !== 'object' || augment === null || Array.isArray(augment)) {
+        return false;
+    }
+    const value = augment['rules_use_symlinks'];
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return ['true', 'yes', 'on', '1'].includes(value.trim().toLowerCase());
+    }
+    if (typeof value === 'number') {
+        return value === 1;
+    }
+    return false;
+}
+function _lean_projection_mode() {
+    const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+    const lean = data['lean_projection'];
+    if (typeof lean === 'object' &&
+        lean !== null &&
+        !Array.isArray(lean) &&
+        String(lean['mode'] ?? '')
+            .trim()
+            .toLowerCase() === 'thin') {
+        return 'thin';
+    }
+    return 'eager-all';
+}
+// --- hashing -----------------------------------------------------------------
+export function file_hash(filepath) {
+    const h = crypto.createHash('sha256');
+    h.update(fs.readFileSync(filepath));
+    return h.digest('hex');
+}
+const _DEP_FRONTMATTER_KEYS = ['skills', 'rules'];
+function _slug_to_logical(slug) {
+    for (const cand of [`skills/${slug}/SKILL.md`, `rules/${slug}.md`]) {
+        if (_resolve_source(cand) !== null) {
+            return cand;
+        }
+    }
+    return null;
+}
+function _direct_includes(relative) {
+    const source = _resolve_source(relative);
+    if (source === null) {
+        return [];
+    }
+    let meta;
+    try {
+        [meta] = _parse_frontmatter(_readText(source));
+    }
+    catch {
+        return [];
+    }
+    const deps = [];
+    for (const key of _DEP_FRONTMATTER_KEYS) {
+        const value = meta[key];
+        if (!Array.isArray(value)) {
+            continue;
+        }
+        for (const item of value) {
+            if (typeof item !== 'string') {
+                continue;
+            }
+            const logical = _slug_to_logical(item.trim());
+            if (logical !== null && logical !== relative) {
+                deps.push(logical);
+            }
+        }
+    }
+    return deps;
+}
+export function effective_hash(relative, _seen = null) {
+    const source = _resolve_source(relative);
+    if (source === null) {
+        return '';
+    }
+    const own = file_hash(source);
+    if (_seen !== null && _seen.has(relative)) {
+        return own; // cycle — fold own content only
+    }
+    const deps = [...new Set(_direct_includes(relative))].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    if (deps.length === 0) {
+        return own; // leaf — identical to plain file_hash
+    }
+    const seenNext = new Set(_seen ?? []);
+    seenNext.add(relative);
+    const parts = [own, ...deps.map((dep) => effective_hash(dep, seenNext))];
+    return crypto.createHash('sha256').update(parts.join('\n'), 'utf-8').digest('hex');
+}
+export function load_hashes() {
+    if (_exists(MODULE_STATE.HASH_FILE)) {
+        try {
+            return JSON.parse(_readText(MODULE_STATE.HASH_FILE));
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+export function save_hashes(hashes) {
+    _mkdirp(path.dirname(MODULE_STATE.HASH_FILE));
+    _writeText(MODULE_STATE.HASH_FILE, _jsonDumpsSorted(hashes) + '\n');
+}
+/** Mirror json.dumps(obj, indent=2, sort_keys=True) for a flat string map. */
+function _jsonDumpsSorted(obj) {
+    const keys = Object.keys(obj).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    if (keys.length === 0) {
+        return '{}';
+    }
+    const lines = keys.map((k) => `  ${JSON.stringify(k)}: ${JSON.stringify(obj[k])}`);
+    return `{\n${lines.join(',\n')}\n}`;
+}
+export function mark_done(relative_path) {
+    const source_file = _resolve_source(relative_path);
+    if (source_file === null || !_exists(source_file)) {
+        _print(`❌  Source file not found: ${relative_path}`);
+        process.exit(1);
+    }
+    apply_path_rewriter(relative_path);
+    const hashes = load_hashes();
+    hashes[relative_path] = effective_hash(relative_path);
+    save_hashes(hashes);
+    _print(`✅  Marked as condensed: ${relative_path}`);
+}
+export function apply_path_rewriter(relative_path) {
+    const target = path.join(MODULE_STATE.TARGET_DIR, relative_path);
+    if (!_exists(target) || !relative_path.endsWith('.md')) {
+        return false;
+    }
+    const original = _readText(target);
+    const rewritten = _rewrite_paths(original, relative_path);
+    if (rewritten === original) {
+        return false;
+    }
+    _writeText(target, rewritten);
+    return true;
+}
+export function mark_all_done() {
+    const hashes = load_hashes();
+    let count = 0;
+    for (const [source_file, relative] of _iter_sources()) {
+        if (!should_condense(source_file)) {
+            continue;
+        }
+        hashes[relative] = effective_hash(relative);
+        count += 1;
+    }
+    save_hashes(hashes);
+    _print(`✅  Marked ${count} files as condensed`);
+}
+export function list_changed_md(_source_dir) {
+    // _source_dir retained for signature compatibility but ignored (multi-root).
+    const hashes = load_hashes();
+    const changed = [];
+    for (const [source_file, relative] of _iter_sources()) {
+        if (!should_condense(source_file)) {
+            continue;
+        }
+        const current_hash = effective_hash(relative);
+        const stored_hash = hashes[relative];
+        if (stored_hash !== current_hash) {
+            changed.push(relative);
+        }
+    }
+    return changed;
+}
+export function find_stale_hashes(_source_dir) {
+    const hashes = load_hashes();
+    const stale = [];
+    for (const relative of Object.keys(hashes).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))) {
+        if (_resolve_source(relative) === null) {
+            stale.push(relative);
+        }
+    }
+    return stale;
+}
+export function clean_stale_hashes(_source_dir) {
+    const stale = find_stale_hashes(_source_dir);
+    if (stale.length === 0) {
+        return 0;
+    }
+    const hashes = load_hashes();
+    for (const relative of stale) {
+        delete hashes[relative];
+    }
+    save_hashes(hashes);
+    return stale.length;
+}
+export function should_condense(filepath) {
+    if (path.extname(filepath) !== '.md') {
+        return false;
+    }
+    if (COPY_AS_IS.has(path.basename(filepath))) {
+        return false;
+    }
+    // Determine logical relative parts so COPY_AS_IS_DIRS works for legacy +
+    // post-move source roots. Default to the full path parts (Python: Path.parts).
+    let rel_parts = filepath.split(path.sep).filter((s) => s.length > 0);
+    for (const root of MODULE_STATE.artefact_roots()) {
+        if (filepath !== root && !_isUnder(filepath, root)) {
+            continue;
+        }
+        rel_parts = _relativeToPosix(filepath, root).split('/');
+        break;
+    }
+    if (rel_parts.length > 0 && COPY_AS_IS_DIRS.has(rel_parts[0])) {
+        return false;
+    }
+    return true;
+}
+export function copy_file(source, target) {
+    _mkdirp(path.dirname(target));
+    fs.copyFileSync(source, target);
+    // shutil.copy2 also preserves metadata (mtime/mode); fidelity for content
+    // is what matters for the sync/hash contract.
+    try {
+        const st = fs.statSync(source);
+        fs.utimesSync(target, st.atime, st.mtime);
+        fs.chmodSync(target, st.mode);
+    }
+    catch {
+        /* best-effort metadata copy */
+    }
+}
+export function cleanup_stale(_source_dir, target_dir) {
+    let deleted = 0;
+    if (!_exists(target_dir)) {
+        return 0;
+    }
+    for (const target_file of _rglobSorted(target_dir, '*')) {
+        if (_isDir(target_file)) {
+            continue;
+        }
+        const relative = _relativeToPosix(target_file, target_dir);
+        if (_resolve_source(relative) === null) {
+            _print(`  Deleting stale: ${relative}`);
+            fs.unlinkSync(target_file);
+            deleted += 1;
+        }
+    }
+    // Remove empty directories (reverse-sorted, deepest first).
+    const dirs = _rglobSorted(target_dir, '*')
+        .filter((p) => _isDir(p))
+        .sort((a, b) => (a < b ? 1 : a > b ? -1 : 0));
+    for (const dirpath of dirs) {
+        try {
+            if (fs.readdirSync(dirpath).length === 0) {
+                fs.rmdirSync(dirpath);
+                _print(`  Removing empty dir: ${_relativeToPosix(dirpath, target_dir)}`);
+            }
+        }
+        catch {
+            /* races/permission — ignore, mirrors Python best-effort */
+        }
+    }
+    return deleted;
+}
+export function sync_non_md(_source_dir, target_dir) {
+    let copied = 0;
+    const seen = new Set();
+    for (const [source_file, relative] of _iter_sources()) {
+        if (should_condense(source_file)) {
+            continue; // .md files are condensed by the agent, not copied here
+        }
+        if (seen.has(relative)) {
+            continue;
+        }
+        seen.add(relative);
+        const target_file = path.join(target_dir, relative);
+        copy_file(source_file, target_file);
+        _print(`  Copied: ${relative}`);
+        copied += 1;
+    }
+    return copied;
+}
+export function list_md_files(_source_dir) {
+    const files = [];
+    const seen = new Set();
+    for (const [source_file, relative] of _iter_sources()) {
+        if (!should_condense(source_file)) {
+            continue;
+        }
+        if (seen.has(relative)) {
+            continue;
+        }
+        seen.add(relative);
+        files.push(relative);
+    }
+    return files.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+export function check_sync(_source_dir, target_dir) {
+    const missing = [];
+    const stale = [];
+    const seen = new Set();
+    for (const [, relative] of _iter_sources()) {
+        if (seen.has(relative)) {
+            continue;
+        }
+        seen.add(relative);
+        if (!_exists(path.join(target_dir, relative))) {
+            missing.push(relative);
+        }
+    }
+    if (_exists(target_dir)) {
+        for (const target_file of _rglobSorted(target_dir, '*')) {
+            if (_isDir(target_file)) {
+                continue;
+            }
+            const relative = _relativeToPosix(target_file, target_dir);
+            if (_resolve_source(relative) === null) {
+                stale.push(relative);
+            }
+        }
+    }
+    return [missing, stale];
+}
+// ── Multi-agent tool generation ──────────────────────────────────────
+const TOOL_DIRS = {
+    '.claude/rules': '../../dist/agent-src/rules',
+    '.cursor/rules': '../../dist/agent-src/rules',
+    '.clinerules': '../dist/agent-src/rules',
+};
+const PERSONA_TOOL_DIRS = {
+    '.claude/personas': '../../dist/agent-src/personas',
+    '.cursor/personas': '../../dist/agent-src/personas',
+};
+const USER_TYPE_TOOL_DIRS = {
+    '.claude/user-types': '../../dist/agent-src/user-types',
+    '.cursor/user-types': '../../dist/agent-src/user-types',
+};
+const _DIR_TOOL_ID = {
+    '.claude/rules': 'claude-code',
+    '.cursor/rules': 'cursor',
+    '.clinerules': 'cline',
+    '.claude/personas': 'claude-code',
+    '.cursor/personas': 'cursor',
+    '.claude/user-types': 'claude-code',
+    '.cursor/user-types': 'cursor',
+};
+function _filter_tool_dirs(mapping) {
+    const out = {};
+    for (const [d, p] of Object.entries(mapping)) {
+        if (_tool_active(_DIR_TOOL_ID[d] ?? 'claude-code')) {
+            out[d] = p;
+        }
+    }
+    return out;
+}
+export function strip_frontmatter(content) {
+    if (content.startsWith('---')) {
+        const end = content.indexOf('---', 3);
+        if (end !== -1) {
+            content = _lstripNewlines(content.slice(end + 3));
+        }
+    }
+    return content;
+}
+// ── Path rewriter (P1 of road-to-path-fixes.md) ───────────────────────────
+// Kept byte-identical to check_condensation.ts::_rewritePaths (the two MUST
+// agree — see ADR-200 note). Mirrors condense.py::_rewrite_paths.
+const _LEGACY_SRC_PREFIX = '.agent-src.uncondensed/';
+const _PROJECTED_SRC_PREFIX = 'dist/agent-src/';
+const _LEGACY_PROJECTED_SRC_PREFIX = '.agent-src/';
+const _FM_LIST_ITEM_RE = /^(\s*-\s*)(["']?)([^"'\n]+?\.md)(["']?)\s*$/;
+const _FM_PATH_PREFIX_RE = /^(\s*(?:-\s+)?path_prefix:\s*)(["']?)([^"'\n]+?)(["']?)\s*$/;
+const _BODY_DOCS_RE = /\.\.\/\.\.\/(docs\/(?:guidelines|contracts)\/[^)\s]+\.md)/g;
+const _FM_PLAIN_LIST_RE = /^\s*-\s*(["']?)([^"'\n]+?)\1\s*$/;
+const _HRR_BANNER_MARKER = '<!-- agent-config:human-review-banner -->';
+function _depth_prefix(source_relative_path) {
+    const parts = _posixParts(source_relative_path);
+    const depth = Math.max(parts.length - 1, 1);
+    return '../'.repeat(depth);
+}
+function _split_frontmatter(content) {
+    if (!content.startsWith('---\n')) {
+        return [null, content];
+    }
+    const end = content.indexOf('\n---\n', 4);
+    if (end === -1) {
+        return [null, content];
+    }
+    const fm_text = content.slice(4, end);
+    const body = content.slice(end + '\n---\n'.length);
+    return [fm_text.split('\n'), body];
+}
+function _rewrite_load_context_value(value, prefix) {
+    if (value.startsWith('../') || value.startsWith('./') || value.startsWith('/')) {
+        return value;
+    }
+    if (value.startsWith(_LEGACY_SRC_PREFIX)) {
+        return prefix + value.slice(_LEGACY_SRC_PREFIX.length);
+    }
+    if (value.startsWith(_PROJECTED_SRC_PREFIX)) {
+        return prefix + value.slice(_PROJECTED_SRC_PREFIX.length);
+    }
+    if (value.startsWith(_LEGACY_PROJECTED_SRC_PREFIX)) {
+        return prefix + value.slice(_LEGACY_PROJECTED_SRC_PREFIX.length);
+    }
+    return prefix + value;
+}
+function _rewrite_path_prefix_value(value) {
+    return value; // no-op — literal match pattern, not a file reference
+}
+function _rewrite_frontmatter_lines(lines, prefix) {
+    let in_load_context = false;
+    const out = [];
+    for (const line of lines) {
+        const bare = _lstrip(line);
+        if (bare.startsWith('load_context:') || bare.startsWith('load_context_eager:')) {
+            in_load_context = true;
+            out.push(line);
+            continue;
+        }
+        if (in_load_context) {
+            const m = _FM_LIST_ITEM_RE.exec(line);
+            if (m) {
+                const indent = m[1] ?? '';
+                const q1 = m[2] ?? '';
+                const value = m[3] ?? '';
+                const q2 = m[4] ?? '';
+                out.push(`${indent}${q1}${_rewrite_load_context_value(value, prefix)}${q2}`);
+                continue;
+            }
+            in_load_context = false;
+        }
+        const pm = _FM_PATH_PREFIX_RE.exec(line);
+        if (pm) {
+            const head = pm[1] ?? '';
+            const q1 = pm[2] ?? '';
+            const value = pm[3] ?? '';
+            const q2 = pm[4] ?? '';
+            out.push(`${head}${q1}${_rewrite_path_prefix_value(value)}${q2}`);
+            continue;
+        }
+        out.push(line);
+    }
+    return out;
+}
+function _rewrite_body_links(body, prefix) {
+    return body.replace(_BODY_DOCS_RE, (_m, tail) => prefix + tail);
+}
+function _parse_trust_and_owner(fm_lines) {
+    let level = 'core';
+    let hrr = false;
+    const packs = [];
+    const workspaces = [];
+    let in_trust = false;
+    let in_packs = false;
+    let in_workspaces = false;
+    for (const line of fm_lines) {
+        const stripped = _lstrip(line);
+        const indent = line.length - stripped.length;
+        if (indent === 0 && stripped.endsWith(':')) {
+            const key = stripped.slice(0, -1);
+            in_trust = key === 'trust';
+            in_packs = key === 'packs';
+            in_workspaces = key === 'workspaces';
+            continue;
+        }
+        if (in_trust && stripped.startsWith('level:')) {
+            const after = stripped.slice(stripped.indexOf(':') + 1);
+            level = _stripChars(_stripChars(_strip(after), '"'), "'");
+        }
+        else if (in_trust && stripped.startsWith('human_review_required:')) {
+            const after = stripped.slice(stripped.indexOf(':') + 1);
+            hrr = _strip(after).toLowerCase() === 'true';
+        }
+        else if (in_packs || in_workspaces) {
+            const m = _FM_PLAIN_LIST_RE.exec(line);
+            if (m) {
+                const value = _strip(m[2] ?? '');
+                (in_packs ? packs : workspaces).push(value);
+            }
+        }
+    }
+    let owner = 'unknown';
+    if (packs.length > 0) {
+        owner = packs[0].split('-')[0];
+    }
+    else if (workspaces.length > 0) {
+        owner = workspaces[0];
+    }
+    return [level, hrr, owner];
+}
+function _inject_hrr_banner(body, level, owner) {
+    if (body.includes(_HRR_BANNER_MARKER)) {
+        return body;
+    }
+    const banner = `${_HRR_BANNER_MARKER}\n` + `> HUMAN REVIEW REQUIRED · trust: ${level} · owner: ${owner}\n\n`;
+    return banner + _lstripNewlines(body);
+}
+export function _rewrite_paths(content, source_relative_path) {
+    const prefix = _depth_prefix(source_relative_path);
+    const [fm_lines, bodyInitial] = _split_frontmatter(content);
+    let body = _rewrite_body_links(bodyInitial, prefix);
+    if (fm_lines === null) {
+        return body;
+    }
+    const new_fm = _rewrite_frontmatter_lines(fm_lines, prefix);
+    const [level, hrr, owner] = _parse_trust_and_owner(fm_lines);
+    if (hrr && level) {
+        body = _inject_hrr_banner(body, level, owner);
+    }
+    return '---\n' + new_fm.join('\n') + '\n---\n' + body;
+}
+// Expose the HRR marker for tests (mirrors condense._HRR_BANNER_MARKER access).
+export { _HRR_BANNER_MARKER };
+// ── Consumer-scoped rule projection (road-to-request-scoped-rule-load P1) ──
+//
+// Opt-in via `projection.rule_workspaces: [<workspace-id>, …]` in
+// `.agent-settings.yml`. Absent / empty = legacy-all (every rule projects —
+// today's behaviour, non-breaking). When set, a non-kernel rule projects
+// only if its `workspaces:` frontmatter intersects the configured set.
+// Kernel rules (`type: always` / `alwaysApply: true`) ALWAYS project —
+// the kernel is unconditional and workspace-independent by definition
+// (rule-router contract § Schema v2). Untagged rules fail safe: they ship.
+// ADR-040: projection-time filtering only, no runtime resolver.
+function _read_projection_list(key) {
+    const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+    const proj = data['projection'];
+    const value = typeof proj === 'object' && proj !== null && !Array.isArray(proj)
+        ? proj[key]
+        : null;
+    if (Array.isArray(value) && value.length > 0) {
+        return value.map((v) => String(v));
+    }
+    return null;
+}
+function _read_rule_workspaces() {
+    return _read_projection_list('rule_workspaces');
+}
+function _read_rule_packs() {
+    return _read_projection_list('rule_packs');
+}
+/**
+ * Whether a rule source file projects under the given workspace + pack
+ * scopes. Both scopes are independent constraints: when configured, the
+ * rule's frontmatter list must intersect (installed workspaces AND
+ * installed packs). Kernel always projects; untagged axes fail safe.
+ */
+export function rule_in_scope(source_path, scope, pack_scope = null) {
+    if (scope === null && pack_scope === null) {
+        return true;
+    }
+    const [meta] = _parse_frontmatter(_readText(source_path));
+    if (meta['type'] === 'always' || meta['alwaysApply'] === true) {
+        return true; // kernel always projects
+    }
+    const axis = (key, configured) => {
+        if (configured === null) {
+            return true;
+        }
+        const values = Array.isArray(meta[key])
+            ? meta[key].map((w) => String(w))
+            : [];
+        if (values.length === 0) {
+            return true; // untagged → fail safe: ship it
+        }
+        return values.some((v) => configured.includes(v));
+    };
+    return axis('workspaces', scope) && axis('packs', pack_scope);
+}
+/** List rule basenames under RULES_SOURCE, workspace/pack scope applied. */
+function _scoped_rule_basenames() {
+    const scope = _read_rule_workspaces();
+    const pack_scope = _read_rule_packs();
+    return _iterdirSorted(MODULE_STATE.RULES_SOURCE)
+        .filter((p) => p.endsWith('.md') && _isFile(p))
+        .filter((p) => rule_in_scope(p, scope, pack_scope))
+        .map((p) => path.basename(p))
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+export function generate_rule_symlinks() {
+    const rules = _scoped_rule_basenames();
+    const tool_dirs = _filter_tool_dirs(TOOL_DIRS);
+    let thin_files = null;
+    if (_lean_projection_mode() === 'thin') {
+        // The `project_thin_rules` twin is not ported (out of scope — thin mode
+        // is opt-in and not exercised by golden parity). Throw a clear error if
+        // a consumer actually enables it, mirroring an unmet import.
+        throw new Error('lean_projection.mode=thin requires project_thin_rules (not ported in condense.ts)');
+    }
+    let total = 0;
+    for (const [tool_dir, rel_prefix] of Object.entries(tool_dirs)) {
+        const target_dir = path.join(MODULE_STATE.PROJECT_ROOT, tool_dir);
+        _mkdirp(target_dir);
+        // Clean stale symlinks
+        for (const item of _iterdirSorted(target_dir)) {
+            const name = path.basename(item);
+            if (_isSymlink(item) && !rules.includes(name) && name !== 'README.md') {
+                fs.unlinkSync(item);
+            }
+        }
+        for (const rule of rules) {
+            const link = path.join(target_dir, rule);
+            if (_existsOrSymlink(link)) {
+                fs.unlinkSync(link);
+            }
+            if (thin_files !== null) {
+                _writeText(link, thin_files[rule]);
+            }
+            else {
+                fs.symlinkSync(path.join(rel_prefix, rule), link);
+            }
+            total += 1;
+        }
+    }
+    const source_count = rules.length;
+    for (const tool_dir of Object.keys(tool_dirs)) {
+        const target_dir = path.join(MODULE_STATE.PROJECT_ROOT, tool_dir);
+        const tool_count = _iterdirSorted(target_dir).filter((f) => f.endsWith('.md')).length;
+        if (tool_count !== source_count) {
+            _print(`  ⚠️  ${tool_dir}: ${tool_count} rules (expected ${source_count})`);
+        }
+    }
+    info(`  ✅  Created ${total} rule symlinks across ${Object.keys(tool_dirs).length} tool directories (${source_count} rules each)`);
+    return total;
+}
+export function generate_windsurfrules() {
+    const rules = _scoped_rule_basenames();
+    const parts = ['# Auto-generated from dist/agent-src/rules/ — do not edit directly\n'];
+    for (const rule of rules) {
+        const p = path.join(MODULE_STATE.RULES_SOURCE, rule);
+        const content = strip_frontmatter(_readText(p));
+        parts.push(`---\n\n${_strip(content)}\n`);
+    }
+    const output = path.join(MODULE_STATE.PROJECT_ROOT, '.windsurfrules');
+    _writeText(output, parts.join('\n') + '\n');
+    info(`  ✅  Generated .windsurfrules (${rules.length} rules)`);
+    return rules.length;
+}
+// ── Modern editor formats ────────────────────────────────────────────
+function _CURSOR_RULES_MDC_DIR() {
+    return path.join(MODULE_STATE.PROJECT_ROOT, '.cursor', 'rules');
+}
+function _WINDSURF_RULES_DIR() {
+    return path.join(MODULE_STATE.PROJECT_ROOT, '.windsurf', 'rules');
+}
+function _WINDSURF_WORKFLOWS_DIR() {
+    return path.join(MODULE_STATE.PROJECT_ROOT, '.windsurf', 'workflows');
+}
+function _CURSOR_COMMANDS_DIR() {
+    return path.join(MODULE_STATE.PROJECT_ROOT, '.cursor', 'commands');
+}
+function _parse_frontmatter(content) {
+    if (!content.startsWith('---')) {
+        return [{}, content];
+    }
+    const end = content.indexOf('\n---', 3);
+    if (end === -1) {
+        return [{}, content];
+    }
+    const raw = _strip(content.slice(3, end));
+    const body = _lstripNewlines(content.slice(end + 4));
+    // Python: `meta = yaml.safe_load(raw) or {}` inside try/except YAMLError.
+    let meta = _yamlParse(raw);
+    if (meta === null || meta === undefined) {
+        meta = {};
+    }
+    if (typeof meta === 'object' && meta !== null && !Array.isArray(meta)) {
+        return [meta, body];
+    }
+    return [{}, body];
+}
+function _yaml_scalar(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Derive host-native activation globs from a rule's `triggers:` frontmatter
+ * (road-to-request-scoped-rule-load Phase 2). `file_pattern` triggers map
+ * verbatim; `path_prefix` triggers map to `<prefix>**`. Keyword / phrase /
+ * intent / command triggers produce no glob — those rules stay
+ * description-activated (Cursor Agent-Requested / Windsurf model_decision).
+ */
+export function derive_trigger_globs(meta) {
+    const triggers = meta['triggers'];
+    if (!Array.isArray(triggers)) {
+        return [];
+    }
+    const globs = [];
+    for (const t of triggers) {
+        if (t === null || typeof t !== 'object' || Array.isArray(t))
+            continue;
+        const obj = t;
+        if (typeof obj['file_pattern'] === 'string' && obj['file_pattern']) {
+            globs.push(obj['file_pattern']);
+        }
+        else if (typeof obj['path_prefix'] === 'string' && obj['path_prefix']) {
+            const prefix = obj['path_prefix'];
+            globs.push(prefix.endsWith('/') ? `${prefix}**` : `${prefix}**`);
+        }
+    }
+    // De-dup, keep declaration order (deterministic output).
+    return [...new Set(globs)];
+}
+export function _emit_cursor_mdc(source, target) {
+    const [meta, body] = _parse_frontmatter(_readText(source));
+    const description = _strip(String(meta['description'] ?? '').replace(/\n/g, ' '));
+    const always_apply = Boolean(meta['alwaysApply'] || meta['type'] === 'always');
+    // Path-shaped triggers become Cursor auto-attach globs; rules without
+    // them keep `globs: ` empty and stay Agent-Requested via description.
+    const globs = always_apply ? [] : derive_trigger_globs(meta);
+    const lines = [
+        '---',
+        `description: ${_yaml_scalar(description)}`,
+        `globs: ${globs.join(',')}`,
+        `alwaysApply: ${always_apply ? 'true' : 'false'}`,
+        '---',
+        '',
+        _pyRstrip(body) + '\n',
+    ];
+    _mkdirp(path.dirname(target));
+    _writeText(target, lines.join('\n'));
+}
+export function _emit_windsurf_rule(source, target) {
+    const [meta, body] = _parse_frontmatter(_readText(source));
+    const description = _strip(String(meta['description'] ?? '').replace(/\n/g, ' '));
+    const always_apply = Boolean(meta['alwaysApply'] || meta['type'] === 'always');
+    // Path-shaped triggers activate host-natively via Windsurf's `glob`
+    // trigger; keyword/intent-only rules keep `model_decision`.
+    const globs = always_apply ? [] : derive_trigger_globs(meta);
+    const trigger = always_apply ? 'always_on' : globs.length > 0 ? 'glob' : 'model_decision';
+    const lines = [
+        '---',
+        `trigger: ${trigger}`,
+        `description: ${_yaml_scalar(description)}`,
+        `globs: ${globs.join(',')}`,
+        '---',
+        '',
+        _pyRstrip(body) + '\n',
+    ];
+    _mkdirp(path.dirname(target));
+    _writeText(target, lines.join('\n'));
+}
+/** Python str.rstrip() with no args. */
+function _pyRstrip(s) {
+    return s.replace(/\s+$/u, '');
+}
+function _clean_modern_dir(target_dir, valid_names) {
+    if (!_exists(target_dir)) {
+        return;
+    }
+    for (const item of _iterdirSorted(target_dir)) {
+        const name = path.basename(item);
+        if (name === 'README.md') {
+            continue;
+        }
+        if (!valid_names.has(name)) {
+            if (_isDir(item) && !_isSymlink(item)) {
+                fs.rmSync(item, { recursive: true, force: true });
+            }
+            else {
+                fs.unlinkSync(item);
+            }
+        }
+    }
+}
+export function generate_cursor_mdc_rules() {
+    const scope = _read_rule_workspaces();
+    const pack_scope = _read_rule_packs();
+    const rules = _rglobSorted(MODULE_STATE.RULES_SOURCE, '*.md')
+        .filter((p) => _isFile(p))
+        .filter((p) => rule_in_scope(p, scope, pack_scope));
+    const stems = rules.map((r) => path.basename(r, '.md'));
+    const valid = new Set([
+        ...stems.map((s) => `${s}.mdc`),
+        ...rules.map((r) => path.basename(r)),
+    ]);
+    _clean_modern_dir(_CURSOR_RULES_MDC_DIR(), valid);
+    for (const rule of rules) {
+        _emit_cursor_mdc(rule, path.join(_CURSOR_RULES_MDC_DIR(), `${path.basename(rule, '.md')}.mdc`));
+    }
+    info(`  ✅  Wrote ${rules.length} \`.cursor/rules/*.mdc\` files`);
+    return rules.length;
+}
+export function generate_windsurf_modern_rules() {
+    const scope = _read_rule_workspaces();
+    const pack_scope = _read_rule_packs();
+    const rules = _rglobSorted(MODULE_STATE.RULES_SOURCE, '*.md')
+        .filter((p) => _isFile(p))
+        .filter((p) => rule_in_scope(p, scope, pack_scope));
+    const valid = new Set(rules.map((r) => path.basename(r)));
+    _clean_modern_dir(_WINDSURF_RULES_DIR(), valid);
+    for (const rule of rules) {
+        _emit_windsurf_rule(rule, path.join(_WINDSURF_RULES_DIR(), path.basename(rule)));
+    }
+    info(`  ✅  Wrote ${rules.length} \`.windsurf/rules/*.md\` files`);
+    return rules.length;
+}
+export function generate_cursor_commands(active_command_slugs = null) {
+    if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains'))) {
+        return 0;
+    }
+    const cmds = [...iterCommands()].filter(([, slug]) => active_command_slugs === null || active_command_slugs.has(slug));
+    const valid = new Set(cmds.map(([, slug]) => `${slug}.md`));
+    _clean_modern_dir(_CURSOR_COMMANDS_DIR(), valid);
+    _mkdirp(_CURSOR_COMMANDS_DIR());
+    let count = 0;
+    for (const [source_file, slug] of cmds) {
+        const link = path.join(_CURSOR_COMMANDS_DIR(), `${slug}.md`);
+        if (_existsOrSymlink(link)) {
+            fs.unlinkSync(link);
+        }
+        const rel = path.join('../..', _relativeToPosix(source_file, MODULE_STATE.PROJECT_ROOT));
+        fs.symlinkSync(rel, link);
+        count += 1;
+    }
+    info(`  ✅  Linked ${count} \`.cursor/commands/*.md\` files`);
+    return count;
+}
+export function generate_windsurf_workflows(active_command_slugs = null) {
+    if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains'))) {
+        return 0;
+    }
+    const cmds = [...iterCommands()].filter(([, slug]) => active_command_slugs === null || active_command_slugs.has(slug));
+    const valid = new Set(cmds.map(([, slug]) => `${slug}.md`));
+    _clean_modern_dir(_WINDSURF_WORKFLOWS_DIR(), valid);
+    _mkdirp(_WINDSURF_WORKFLOWS_DIR());
+    let count = 0;
+    for (const [source_file, slug] of cmds) {
+        const link = path.join(_WINDSURF_WORKFLOWS_DIR(), `${slug}.md`);
+        if (_existsOrSymlink(link)) {
+            fs.unlinkSync(link);
+        }
+        const rel = path.join('../..', _relativeToPosix(source_file, MODULE_STATE.PROJECT_ROOT));
+        fs.symlinkSync(rel, link);
+        count += 1;
+    }
+    info(`  ✅  Linked ${count} \`.windsurf/workflows/*.md\` files`);
+    return count;
+}
+export function generate_gemini_md() {
+    const link = path.join(MODULE_STATE.PROJECT_ROOT, 'GEMINI.md');
+    if (_existsOrSymlink(link)) {
+        fs.unlinkSync(link);
+    }
+    fs.symlinkSync('AGENTS.md', link);
+    info('  ✅  Created GEMINI.md → AGENTS.md symlink');
+}
+function _command_slug(source_file) {
+    const rel = _relativeToPosix(source_file, MODULE_STATE.COMMANDS_SOURCE);
+    return _posixParts(rel.replace(/\.md$/, '')).join('-');
+}
+void _command_slug; // mirrors the Python helper; not on the hot path here
+/**
+ * Yield [source_file, slug] for every command, sourced from src/domains/.
+ * Mirrors condense._iter_commands (ADR-044 amendment).
+ */
+function* iterCommands() {
+    const src_domains = path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains');
+    if (!_isDir(src_domains)) {
+        return;
+    }
+    for (const source_file of _rglobSorted(src_domains, 'command.md')) {
+        if (!_isFile(source_file)) {
+            continue;
+        }
+        const rel = _relativeToPosix(source_file, MODULE_STATE.PROJECT_ROOT);
+        let slug = _command_path_to_slug(rel);
+        if (!slug) {
+            continue;
+        }
+        const pack_id = _relativeToPosix(source_file, src_domains).split('/')[0];
+        const prefix = _domains_slug_prefix(pack_id);
+        if (prefix && slug !== prefix && !slug.startsWith(prefix + '-')) {
+            slug = `${prefix}-${slug}`;
+        }
+        yield [source_file, slug];
+    }
+}
+function _read_model_auto_switch() {
+    const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+    const model = data['model'];
+    const value = typeof model === 'object' && model !== null && !Array.isArray(model)
+        ? model['auto_switch']
+        : null;
+    if (typeof value === 'string' && ['auto', 'suggest', 'off'].includes(value.trim().toLowerCase())) {
+        return value.trim().toLowerCase();
+    }
+    return 'suggest';
+}
+function _read_projection_mode() {
+    const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+    const proj = data['projection'];
+    const value = typeof proj === 'object' && proj !== null && !Array.isArray(proj)
+        ? proj['mode']
+        : null;
+    if (typeof value === 'string' && ['legacy-all', 'scoped'].includes(value.trim().toLowerCase())) {
+        return value.trim().toLowerCase();
+    }
+    return 'legacy-all';
+}
+function _domains_slug_prefix(pack_id) {
+    const manifest = path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains', pack_id, 'pack.yaml');
+    if (!_isFile(manifest)) {
+        return '';
+    }
+    const m = _SLUG_PREFIX_RE.exec(_readText(manifest));
+    return m ? m[1] : '';
+}
+function _command_path_to_slug(manifest_path) {
+    const logical = strip_source_prefix(manifest_path);
+    if (logical && logical.startsWith('commands/')) {
+        return _posixParts(logical.slice('commands/'.length).replace(/\.md$/, '')).join('-');
+    }
+    const parts = manifest_path.split(path.sep).filter((s) => s.length > 0);
+    const i = parts.indexOf('commands');
+    return parts
+        .slice(i + 1)
+        .join('/')
+        .replace(/\.md$/, '')
+        .split('/')
+        .join('-');
+}
+function _skill_path_to_name(manifest_path) {
+    const parts = manifest_path.split(path.sep).filter((s) => s.length > 0);
+    const i = parts.indexOf('skills');
+    return parts[i + 1];
+}
+void _skill_path_to_name;
+function _resolve_active_predicates() {
+    if (_read_projection_mode() !== 'scoped') {
+        return [null, null];
+    }
+    // The `config` package twins (packs / session_profiles / profiles) are not
+    // ported (out of scope — scoped mode is opt-in and not exercised by golden
+    // parity). Throw a clear error if a consumer enables it, mirroring an
+    // unmet import.
+    throw new Error('projection.mode=scoped requires the config package (not ported in condense.ts)');
+}
+function _model_tier(skill_md) {
+    if (!_exists(skill_md)) {
+        return null;
+    }
+    const text = fs.readFileSync(skill_md).toString('utf-8');
+    if (!text.startsWith('---\n')) {
+        return null;
+    }
+    const end = text.indexOf('\n---\n', 4);
+    if (end === -1) {
+        return null;
+    }
+    const m = _MODEL_TIER_RE.exec(text.slice(4, end));
+    return m ? m[1] : null;
+}
+function _render_native_model_md(src_md, tier) {
+    const text = _readText(src_md);
+    const model = _TIER_TO_CLAUDE_MODEL[tier];
+    return text.replace(_MODEL_TIER_RE, `model: ${model}`);
+}
+export function generate_claude_skills(active_skill_names = null) {
+    if (!_exists(MODULE_STATE.SKILLS_SOURCE)) {
+        process.stderr.write('  ⚠️  dist/agent-src/skills/ not found — skipping skills\n');
+        return 0;
+    }
+    let skills = _iterdirSorted(MODULE_STATE.SKILLS_SOURCE)
+        .filter((p) => _isDir(p))
+        .map((p) => path.basename(p))
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    if (active_skill_names !== null) {
+        skills = skills.filter((s) => active_skill_names.has(s));
+    }
+    const skill_set = new Set(skills);
+    const command_slugs = new Set([...iterCommands()].map(([, slug]) => slug));
+    _mkdirp(MODULE_STATE.CLAUDE_SKILLS_DIR);
+    const auto = _read_model_auto_switch() === 'auto';
+    for (const item of _iterdirSorted(MODULE_STATE.CLAUDE_SKILLS_DIR)) {
+        const name = path.basename(item);
+        if (skill_set.has(name) || command_slugs.has(name) || name === 'README.md') {
+            continue;
+        }
+        if (_isSymlink(item)) {
+            fs.unlinkSync(item);
+        }
+        else if (_isDirNoFollow(item)) {
+            const skill_md = path.join(item, 'SKILL.md');
+            if (_isFile(skill_md) && !_isSymlink(skill_md)) {
+                fs.rmSync(item, { recursive: true, force: true });
+            }
+        }
+    }
+    let count = 0;
+    let rendered = 0;
+    for (const skill of skills) {
+        const link = path.join(MODULE_STATE.CLAUDE_SKILLS_DIR, skill);
+        const src_dir = path.join(MODULE_STATE.SKILLS_SOURCE, skill);
+        const value = auto ? _model_tier(path.join(src_dir, 'SKILL.md')) : null;
+        if (_isSymlink(link)) {
+            fs.unlinkSync(link);
+        }
+        else if (_isDirNoFollow(link)) {
+            fs.rmSync(link, { recursive: true, force: true });
+        }
+        else if (_existsOrSymlink(link)) {
+            fs.unlinkSync(link);
+        }
+        if (value !== null && value in _TIER_TO_CLAUDE_MODEL) {
+            _mkdirp(link);
+            for (const entry of _iterdirSorted(src_dir)) {
+                const entryName = path.basename(entry);
+                if (entryName === 'SKILL.md') {
+                    _writeText(path.join(link, 'SKILL.md'), _render_native_model_md(entry, value));
+                }
+                else {
+                    fs.symlinkSync(path.join('../../../dist/agent-src/skills', skill, entryName), path.join(link, entryName));
+                }
+            }
+            rendered += 1;
+        }
+        else {
+            fs.symlinkSync(path.join('../../dist/agent-src/skills', skill), link);
+        }
+        count += 1;
+    }
+    const suffix = rendered ? ` (${rendered} rendered with native model:)` : '';
+    info(`  ✅  Created ${count} skill entries in .claude/skills/${suffix}`);
+    return count;
+}
+export function extract_description_from_md(content) {
+    for (const raw of _strip(content).split('\n')) {
+        const line = _strip(raw);
+        if (line.startsWith('# ')) {
+            return _strip(line.slice(2));
+        }
+        if (line && !line.startsWith('#')) {
+            return line.slice(0, 120);
+        }
+    }
+    return '';
+}
+export function generate_claude_commands(active_command_slugs = null) {
+    if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains'))) {
+        process.stderr.write('  ⚠️  src/domains/ not found — skipping commands\n');
+        return 0;
+    }
+    _mkdirp(MODULE_STATE.CLAUDE_SKILLS_DIR);
+    let skill_names = new Set();
+    if (_exists(MODULE_STATE.SKILLS_SOURCE)) {
+        skill_names = new Set(_iterdirSorted(MODULE_STATE.SKILLS_SOURCE)
+            .filter((p) => _isDir(p))
+            .map((p) => path.basename(p)));
+    }
+    const current_slugs = new Set();
+    let count = 0;
+    let skipped = 0;
+    let rendered = 0;
+    const auto = _read_model_auto_switch() === 'auto';
+    for (const [source_file, slug] of iterCommands()) {
+        if (active_command_slugs !== null && !active_command_slugs.has(slug)) {
+            continue;
+        }
+        if (skill_names.has(slug)) {
+            skipped += 1;
+            continue;
+        }
+        current_slugs.add(slug);
+        const skill_dir = path.join(MODULE_STATE.CLAUDE_SKILLS_DIR, slug);
+        _mkdirp(skill_dir);
+        const skill_file = path.join(skill_dir, 'SKILL.md');
+        if (_existsOrSymlink(skill_file)) {
+            fs.unlinkSync(skill_file);
+        }
+        const rel_path = _relativeToPosix(source_file, MODULE_STATE.PROJECT_ROOT);
+        const value = auto ? _model_tier(source_file) : null;
+        if (value !== null && value in _TIER_TO_CLAUDE_MODEL) {
+            _writeText(skill_file, _render_native_model_md(source_file, value));
+            rendered += 1;
+        }
+        else {
+            const rel_target = path.join('../../..', rel_path);
+            fs.symlinkSync(rel_target, skill_file);
+        }
+        count += 1;
+    }
+    let removed_dirs = 0;
+    for (const item of _iterdirSorted(MODULE_STATE.CLAUDE_SKILLS_DIR)) {
+        if (!_isDirNoFollow(item) || _isSymlink(item)) {
+            continue;
+        }
+        const name = path.basename(item);
+        if (skill_names.has(name) || current_slugs.has(name)) {
+            continue;
+        }
+        const skill_md = path.join(item, 'SKILL.md');
+        if (_isSymlink(skill_md) || _isFile(skill_md)) {
+            const entries = _iterdirSorted(item);
+            if (entries.length === 1 && path.basename(entries[0]) === 'SKILL.md') {
+                fs.unlinkSync(skill_md);
+                fs.rmdirSync(item);
+                removed_dirs += 1;
+            }
+        }
+    }
+    let msg = `  ✅  Created ${count} command entries in .claude/skills/`;
+    if (rendered) {
+        msg += ` (${rendered} rendered with native model:)`;
+    }
+    if (skipped) {
+        msg += ` (${skipped} skipped — same-name skill exists)`;
+    }
+    if (removed_dirs) {
+        msg += ` (${removed_dirs} stale dirs removed)`;
+    }
+    info(msg);
+    return count;
+}
+/**
+ * Project `src/subagents/*.md` (subagent-v1, ADR-109) → `.claude/agents/*.md`
+ * in Claude Code's native subagent format.
+ *
+ * The source frontmatter carries governance metadata (schema_version, trust,
+ * lifecycle, discovery, source) that Claude Code does not understand; the native
+ * `.claude/agents/` format wants only `{name, description, tools, model}` + the
+ * system-prompt body. This is a **frontmatter transform**, not a symlink:
+ *
+ *  - `model_tier` → native `model:` via `_TIER_TO_CLAUDE_MODEL` (ADR-034/035);
+ *    the `inherit` sentinel passes through to `model: inherit`.
+ *  - `tools` (a YAML list) → the comma-joined form Claude Code accepts.
+ *  - the body (everything after the closing `---`) is copied verbatim.
+ *
+ * Static projection only — Claude Code (or the user via `@<name>`) decides
+ * dispatch; nothing here runs an agent. Reads from `src/` directly (subagent
+ * prompts are not telegraph-condensed). Reaps stale generated `.claude/agents/`
+ * files whose source no longer exists.
+ */
+export function generate_claude_subagents() {
+    if (!_isDir(MODULE_STATE.SUBAGENTS_SOURCE)) {
+        return 0;
+    }
+    _mkdirp(MODULE_STATE.CLAUDE_AGENTS_DIR);
+    const sources = _rglobSorted(MODULE_STATE.SUBAGENTS_SOURCE, '*.md').filter((p) => _isFile(p));
+    const current = new Set();
+    let count = 0;
+    for (const src of sources) {
+        const stem = path.basename(src, '.md');
+        const text = _readText(src);
+        if (!text.startsWith('---\n')) {
+            continue;
+        }
+        const end = text.indexOf('\n---\n', 4);
+        if (end === -1) {
+            continue;
+        }
+        const fmBlock = text.slice(4, end);
+        const body = text.slice(end + 5);
+        const fm = _yamlParse(fmBlock);
+        if (fm === null) {
+            continue;
+        }
+        const name = typeof fm['name'] === 'string' ? fm['name'] : stem;
+        const description = typeof fm['description'] === 'string' ? fm['description'] : '';
+        const toolsRaw = fm['tools'];
+        const tools = Array.isArray(toolsRaw) ? toolsRaw.map((t) => String(t)).join(', ') : String(toolsRaw ?? '');
+        const tier = typeof fm['model_tier'] === 'string' ? fm['model_tier'] : 'inherit';
+        const model = tier === 'inherit' ? 'inherit' : (_TIER_TO_CLAUDE_MODEL[tier] ?? 'inherit');
+        const out = '---\n' +
+            `name: ${name}\n` +
+            `description: ${description}\n` +
+            `tools: ${tools}\n` +
+            `model: ${model}\n` +
+            '---\n' +
+            body;
+        const target = path.join(MODULE_STATE.CLAUDE_AGENTS_DIR, `${name}.md`);
+        _writeText(target, out);
+        current.add(`${name}.md`);
+        count += 1;
+    }
+    // Reap stale generated agent files (source removed). Only touch plain .md
+    // files we would have generated; never follow into unrelated content.
+    for (const item of _iterdirSorted(MODULE_STATE.CLAUDE_AGENTS_DIR)) {
+        const base = path.basename(item);
+        if (base === 'README.md' || current.has(base)) {
+            continue;
+        }
+        if (_isFile(item) && base.endsWith('.md') && !_isSymlink(item)) {
+            fs.unlinkSync(item);
+        }
+    }
+    info(`  ✅  Created ${count} subagent entries in .claude/agents/`);
+    return count;
+}
+/**
+ * Cross-host degradation for subagent-v1 (ADR-109 §4).
+ *
+ * Only Claude Code has native subagents (`generate_claude_subagents`). On the
+ * other rules-surface hosts a subagent projects to a **loadable context file** —
+ * a *passive reference*, honestly labelled: there is NO host-native `@`-dispatch
+ * (faking it would need a runtime the package refuses to add). Council
+ * (claude-sonnet-4-5 + gpt-4o, 2026-07-05) converged here over honest-null: the
+ * body is 95% reusable review discipline, 5% dispatch syntax, so an advanced user
+ * on Cursor / Windsurf / Cline loads it on intent and applies the discipline
+ * manually. This is **governance parity, not feature parity** — trust / lifecycle
+ * / model_tier stay legible; automation does not.
+ *
+ * Placement is reaper-safe by construction:
+ *  - Cursor / Windsurf → a dedicated `subagents/` subdir with its own reaper,
+ *    so it never collides with the aggressive `_clean_modern_dir` rule reapers.
+ *  - Cline → a flat real `<name>.subagent.md` in `.clinerules/` (whose reaper
+ *    only unlinks *symlinks*, so a real file survives).
+ *
+ * Copilot / Gemini are skipped (no per-file context surface), per ADR-109 §4.
+ * Reads from `src/` directly (subagent prompts are not telegraph-condensed).
+ */
+export function generate_subagent_host_contexts() {
+    if (!_isDir(MODULE_STATE.SUBAGENTS_SOURCE)) {
+        return 0;
+    }
+    const sources = _rglobSorted(MODULE_STATE.SUBAGENTS_SOURCE, '*.md').filter((p) => _isFile(p));
+    // Build the passive-reference body once per subagent, keyed by projected name.
+    const rendered = [];
+    for (const src of sources) {
+        const stem = path.basename(src, '.md');
+        const text = _readText(src);
+        if (!text.startsWith('---\n')) {
+            continue;
+        }
+        const end = text.indexOf('\n---\n', 4);
+        if (end === -1) {
+            continue;
+        }
+        const fm = _yamlParse(text.slice(4, end));
+        if (fm === null) {
+            continue;
+        }
+        const body = text.slice(end + 5);
+        const name = typeof fm['name'] === 'string' ? fm['name'] : stem;
+        const description = typeof fm['description'] === 'string' ? fm['description'] : '';
+        // `trust` is either a flat string or the subagent-v1 nested object
+        // {level, confidence, human_review_required}; surface the level either way.
+        const trustRaw = fm['trust'];
+        const trust = typeof trustRaw === 'string'
+            ? trustRaw
+            : typeof trustRaw === 'object' && trustRaw !== null && typeof trustRaw['level'] === 'string'
+                ? trustRaw['level']
+                : 'unknown';
+        const lifecycle = typeof fm['lifecycle'] === 'string' ? fm['lifecycle'] : 'unknown';
+        const tier = typeof fm['model_tier'] === 'string' ? fm['model_tier'] : 'inherit';
+        const toolsRaw = fm['tools'];
+        const tools = Array.isArray(toolsRaw)
+            ? toolsRaw.map((t) => String(t)).join(', ')
+            : String(toolsRaw ?? '');
+        const out = '---\n' +
+            `description: ${description}\n` +
+            '---\n\n' +
+            `# Subagent (passive reference): ${name}\n\n` +
+            '> Passive subagent reference. This host has **no native subagent dispatch** —\n' +
+            `> there is no \`@${name}\` here. Load this discipline manually and apply it.\n` +
+            '> Governance parity (trust / lifecycle / model tier) is preserved below;\n' +
+            '> feature parity is not (ADR-109 §4).\n\n' +
+            `- trust: ${trust}\n` +
+            `- lifecycle: ${lifecycle}\n` +
+            `- model tier: ${tier}\n` +
+            (tools ? `- tools: ${tools}\n` : '') +
+            '\n' +
+            _pyRstrip(body) +
+            '\n';
+        rendered.push({ name, text: out });
+    }
+    // Host targets: [dir, filename(name)->basename, reaper-predicate].
+    const targets = [
+        {
+            active: _tool_active('cursor'),
+            dir: path.join(MODULE_STATE.PROJECT_ROOT, '.cursor', 'subagents'),
+            file: (n) => `${n}.md`,
+            owns: (b) => b.endsWith('.md'),
+        },
+        {
+            active: _tool_active('windsurf'),
+            dir: path.join(MODULE_STATE.PROJECT_ROOT, '.windsurf', 'subagents'),
+            file: (n) => `${n}.md`,
+            owns: (b) => b.endsWith('.md'),
+        },
+        {
+            active: _tool_active('cline'),
+            dir: path.join(MODULE_STATE.PROJECT_ROOT, '.clinerules'),
+            file: (n) => `${n}.subagent.md`,
+            owns: (b) => b.endsWith('.subagent.md'),
+        },
+    ];
+    let count = 0;
+    for (const t of targets) {
+        if (!t.active) {
+            continue;
+        }
+        const current = new Set(rendered.map((r) => t.file(r.name)));
+        _mkdirp(t.dir);
+        for (const r of rendered) {
+            _writeText(path.join(t.dir, t.file(r.name)), r.text);
+            count += 1;
+        }
+        // Reap stale generated files we own whose source is gone. Never touch
+        // symlinks (cline's rule symlinks) or a README.
+        if (_exists(t.dir)) {
+            for (const item of _iterdirSorted(t.dir)) {
+                const base = path.basename(item);
+                if (base === 'README.md' || current.has(base)) {
+                    continue;
+                }
+                if (_isFile(item) && !_isSymlink(item) && t.owns(base)) {
+                    fs.unlinkSync(item);
+                }
+            }
+        }
+    }
+    info(`  ✅  Projected ${count} passive subagent context file(s) to non-Claude-Code hosts`);
+    return count;
+}
+// Bootstrap shim (road-to-install-path-convergence): the Claude Code plugin
+// ships ZERO content skills. It carries only hooks/hooks.json (byte-identical
+// to the managed settings block, so Claude Code dedupes) plus this single
+// pointer skill whose description names the canonical install command.
+export const PLUGIN_POINTER_SLUG = 'install-agent-config';
+export const PLUGIN_POINTER_SKILL_BODY = `---
+name: install-agent-config
+description: >-
+  Install or upgrade the event4u agent-config suite. This marketplace plugin
+  is a bootstrap shim — it ships hooks plus this pointer only; ALL skills,
+  rules, and commands are installed via \`npx -y @event4u/agent-config init\`.
+  Use when the user asks to install, set up, or upgrade agent-config, or
+  wonders why this plugin contains no other skills.
+---
+
+# Install agent-config
+
+This plugin is a **bootstrap shim**. It exists so the marketplace listing
+stays discoverable and existing plugin installs keep working hooks — the
+content surface (skills, rules, commands, personas) is distributed as a
+file projection, not through this plugin.
+
+## Install (canonical, one command)
+
+\`\`\`bash
+npx -y @event4u/agent-config init
+\`\`\`
+
+The installer writes the full content projection, registers the dispatcher
+hooks as a managed block in \`~/.claude/settings.json\` (byte-identical to
+this plugin's hooks, so nothing double-fires), and keeps everything
+upgradeable via \`agent-config upgrade\`.
+
+## Already installed both?
+
+Run \`agent-config doctor\` to check for duplicate surfaces, and
+\`agent-config converge\` to clean up consented duplicates.
+`;
+export function generate_plugin_command_skills() {
+    if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains'))) {
+        return 0;
+    }
+    _mkdirp(MODULE_STATE.PLUGIN_SKILLS_DIR);
+    // 1. Materialize the pointer skill (idempotent overwrite-on-drift).
+    const pointer_dir = path.join(MODULE_STATE.PLUGIN_SKILLS_DIR, PLUGIN_POINTER_SLUG);
+    _mkdirp(pointer_dir);
+    const pointer_file = path.join(pointer_dir, 'SKILL.md');
+    if (_isSymlink(pointer_file)) {
+        fs.unlinkSync(pointer_file);
+    }
+    if (!_isFile(pointer_file) || fs.readFileSync(pointer_file, 'utf-8') !== PLUGIN_POINTER_SKILL_BODY) {
+        fs.writeFileSync(pointer_file, PLUGIN_POINTER_SKILL_BODY);
+    }
+    // 2. Prune every other skill dir so the tree converges to shim shape
+    //    from any prior state. Removable = every entry is a symlink (the
+    //    generated projection shape — SKILL.md and optional evals links into
+    //    src/), or the dir holds only a single SKILL.md file (the old sweep's
+    //    rule). Dirs with real extra files are never touched.
+    let removed_dirs = 0;
+    for (const item of _iterdirSorted(MODULE_STATE.PLUGIN_SKILLS_DIR)) {
+        if (!_isDirNoFollow(item) || _isSymlink(item)) {
+            continue;
+        }
+        if (path.basename(item) === PLUGIN_POINTER_SLUG) {
+            continue;
+        }
+        const entries = _iterdirSorted(item);
+        const all_symlinks = entries.length > 0 && entries.every((e) => _isSymlink(e));
+        const single_skill_md = entries.length === 1 &&
+            path.basename(entries[0]) === 'SKILL.md' &&
+            _isFile(entries[0]);
+        if (all_symlinks || single_skill_md) {
+            for (const e of entries) {
+                fs.unlinkSync(e);
+            }
+            fs.rmdirSync(item);
+            removed_dirs += 1;
+        }
+    }
+    let msg = '  ✅  Plugin skills: bootstrap shim (1 pointer skill) in .claude-plugin/skills/';
+    if (removed_dirs) {
+        msg += ` (${removed_dirs} content entries pruned)`;
+    }
+    info(msg);
+    return 1;
+}
+export function generate_persona_symlinks() {
+    if (!_exists(MODULE_STATE.PERSONAS_SOURCE)) {
+        _print('  ⚠️  dist/agent-src/personas/ not found — skipping personas');
+        return 0;
+    }
+    const personas = _rglobSorted(MODULE_STATE.PERSONAS_SOURCE, '*.md')
+        .filter((p) => _isFile(p) && path.basename(p, '.md') !== 'README')
+        .map((p) => path.basename(p))
+        // glob('*.md') is non-recursive in Python; mirror that — only top level.
+        .filter((name) => _isFile(path.join(MODULE_STATE.PERSONAS_SOURCE, name)));
+    // Python uses PERSONAS_SOURCE.glob("*.md") (non-recursive). Re-derive
+    // from a direct listing to match exactly.
+    const direct = _iterdirSorted(MODULE_STATE.PERSONAS_SOURCE)
+        .filter((p) => p.endsWith('.md') && _isFile(p) && path.basename(p, '.md') !== 'README')
+        .map((p) => path.basename(p))
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    void personas;
+    const list = direct;
+    const tool_dirs = _filter_tool_dirs(PERSONA_TOOL_DIRS);
+    let total = 0;
+    for (const [tool_dir, rel_prefix] of Object.entries(tool_dirs)) {
+        const target_dir = path.join(MODULE_STATE.PROJECT_ROOT, tool_dir);
+        _mkdirp(target_dir);
+        for (const item of _iterdirSorted(target_dir)) {
+            const name = path.basename(item);
+            if (_isSymlink(item) && !list.includes(name) && name !== 'README.md') {
+                fs.unlinkSync(item);
+            }
+        }
+        for (const persona of list) {
+            const link = path.join(target_dir, persona);
+            const target = path.join(rel_prefix, persona);
+            if (_existsOrSymlink(link)) {
+                fs.unlinkSync(link);
+            }
+            fs.symlinkSync(target, link);
+            total += 1;
+        }
+    }
+    info(`  ✅  Created ${total} persona symlinks across ${Object.keys(tool_dirs).length} tool directories (${list.length} personas each)`);
+    return total;
+}
+export function generate_user_type_symlinks() {
+    if (!_exists(MODULE_STATE.USER_TYPES_SOURCE)) {
+        _print('  ⚠️  dist/agent-src/user-types/ not found — skipping user-types');
+        return 0;
+    }
+    const user_types = _iterdirSorted(MODULE_STATE.USER_TYPES_SOURCE)
+        .filter((p) => p.endsWith('.md') && _isFile(p) && path.basename(p, '.md') !== 'README')
+        .map((p) => path.basename(p))
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    const tool_dirs = _filter_tool_dirs(USER_TYPE_TOOL_DIRS);
+    let total = 0;
+    for (const [tool_dir, rel_prefix] of Object.entries(tool_dirs)) {
+        const target_dir = path.join(MODULE_STATE.PROJECT_ROOT, tool_dir);
+        _mkdirp(target_dir);
+        for (const item of _iterdirSorted(target_dir)) {
+            const name = path.basename(item);
+            if (_isSymlink(item) && !user_types.includes(name) && name !== 'README.md') {
+                fs.unlinkSync(item);
+            }
+        }
+        for (const user_type of user_types) {
+            const link = path.join(target_dir, user_type);
+            const target = path.join(rel_prefix, user_type);
+            if (_existsOrSymlink(link)) {
+                fs.unlinkSync(link);
+            }
+            fs.symlinkSync(target, link);
+            total += 1;
+        }
+    }
+    info(`  ✅  Created ${total} user-type symlinks across ${Object.keys(tool_dirs).length} tool directories (${user_types.length} user-types each)`);
+    return total;
+}
+export function generate_plugin_hooks() {
+    const manifest_path = path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'scripts', 'hook_manifest.yaml');
+    if (!_exists(manifest_path)) {
+        process.stderr.write('  ⚠️  scripts/hook_manifest.yaml not found — skipping plugin hooks\n');
+        return 0;
+    }
+    // Single source of truth: the SAME matrix derivation the installer uses
+    // for the managed settings.json block (road-to-claude-code-single-surface
+    // Phase 4) — plugin hooks.json and settings hooks cannot drift by
+    // construction. Backstop: tests/install/claude_hook_matrix_parity.test.ts.
+    const matrix = build_claude_hook_matrix(manifest_path);
+    const hooks = {};
+    for (const [native, command] of Object.entries(matrix)) {
+        hooks[native] = [{ hooks: [{ type: 'command', command }] }];
+    }
+    const hooks_dir = path.join(MODULE_STATE.PROJECT_ROOT, 'hooks');
+    _mkdirp(hooks_dir);
+    const out = path.join(hooks_dir, 'hooks.json');
+    _writeText(out, _jsonDumpsHooks({ hooks }) + '\n');
+    info(`  ✅  Generated hooks/hooks.json (${Object.keys(hooks).length} Claude plugin hooks)`);
+    return Object.keys(hooks).length;
+}
+/** Mirror json.dumps(obj, indent=2) for the hooks payload (insertion order). */
+function _jsonDumpsHooks(obj) {
+    return _pyJson(obj, 0);
+}
+/**
+ * json.dumps(indent=2) equivalent preserving insertion order, no sort_keys,
+ * ensure_ascii=False is fine here (ASCII content). Matches CPython spacing:
+ * `": "` after keys, `,` newline-separated.
+ */
+function _pyJson(value, indent) {
+    const pad = '  '.repeat(indent);
+    const padInner = '  '.repeat(indent + 1);
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return '[]';
+        }
+        const items = value.map((v) => padInner + _pyJson(v, indent + 1));
+        return `[\n${items.join(',\n')}\n${pad}]`;
+    }
+    if (value !== null && typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            return '{}';
+        }
+        const items = entries.map(([k, v]) => `${padInner}${JSON.stringify(k)}: ${_pyJson(v, indent + 1)}`);
+        return `{\n${items.join(',\n')}\n${pad}}`;
+    }
+    return JSON.stringify(value);
+}
+function _generate_tools_inner(cmd_slugs, skill_names) {
+    info('🔧  Generating multi-agent tool directories...\n');
+    const rules = generate_rule_symlinks();
+    const windsurfrules = _tool_active('windsurf') ? generate_windsurfrules() : 0;
+    if (_tool_active('gemini')) {
+        generate_gemini_md();
+    }
+    const skills = _tool_active('claude-code') ? generate_claude_skills(skill_names) : 0;
+    const commands = _tool_active('claude-code') ? generate_claude_commands(cmd_slugs) : 0;
+    const subagents = _tool_active('claude-code') ? generate_claude_subagents() : 0;
+    const subagent_contexts = generate_subagent_host_contexts();
+    const plugin_cmd_skills = _tool_active('claude-code') ? generate_plugin_command_skills() : 0;
+    const plugin_hooks = _tool_active('claude-code') ? generate_plugin_hooks() : 0;
+    const personas = generate_persona_symlinks();
+    const user_types = generate_user_type_symlinks();
+    const cursor_mdc = _tool_active('cursor') ? generate_cursor_mdc_rules() : 0;
+    const windsurf_modern = _tool_active('windsurf') ? generate_windsurf_modern_rules() : 0;
+    const cursor_cmds = _tool_active('cursor') ? generate_cursor_commands(cmd_slugs) : 0;
+    const windsurf_wf = _tool_active('windsurf') ? generate_windsurf_workflows(cmd_slugs) : 0;
+    const summary = `✅  generate-tools — rules=${rules} skills=${skills} ` +
+        `commands=${commands} subagents=${subagents} subagent_contexts=${subagent_contexts} plugin_cmd_skills=${plugin_cmd_skills} ` +
+        `plugin_hooks=${plugin_hooks} ` +
+        `personas=${personas} user_types=${user_types} ` +
+        `cursor_mdc=${cursor_mdc} windsurf_rules=${windsurf_modern} ` +
+        `cursor_commands=${cursor_cmds} windsurf_workflows=${windsurf_wf} ` +
+        `windsurfrules=${windsurfrules}`;
+    if (resolve_level() === 'verbose') {
+        _print(`\n${summary}`);
+    }
+    else {
+        success(summary);
+        flush_summary();
+    }
+}
+export function generate_tools() {
+    const [cmd_slugs, skill_names] = _resolve_active_predicates();
+    const scoped = cmd_slugs !== null;
+    try {
+        _generate_tools_inner(cmd_slugs, skill_names);
+    }
+    catch (e) {
+        if (scoped) {
+            info('  ⚠️  scoped projection failed — restoring full (legacy-all) projection');
+            _generate_tools_inner(null, null);
+        }
+        throw e;
+    }
+    if (!scoped) {
+        info('  ℹ️  Profile mode available — focused surface. ' +
+            'Run `agent-config use --profile=developer`.');
+    }
+}
+// ── .augment/ projection ──────────────────────────────────────────────
+const AUGMENT_SYMLINK_DIRS = [
+    'skills',
+    'commands',
+    'guidelines',
+    'personas',
+    'user-types',
+    'templates',
+    'contexts',
+    'scripts',
+];
+const AUGMENT_SYMLINK_FILES = ['README.md'];
+export function project_to_augment() {
+    if (!_exists(MODULE_STATE.TARGET_DIR)) {
+        _print(`  ⚠️  ${path.basename(MODULE_STATE.TARGET_DIR)}/ not found — nothing to project`);
+        return;
+    }
+    _mkdirp(MODULE_STATE.AUGMENT_DIR);
+    const use_symlinks = _read_augment_rules_use_symlinks();
+    const src_rules = path.join(MODULE_STATE.TARGET_DIR, 'rules');
+    const dst_rules = path.join(MODULE_STATE.AUGMENT_DIR, 'rules');
+    _mkdirp(dst_rules);
+    const existing = new Set(_iterdirSorted(dst_rules)
+        .filter((f) => _isFile(f) || _isSymlink(f))
+        .map((f) => path.basename(f)));
+    const current = new Set();
+    let written = 0;
+    if (_exists(src_rules)) {
+        const rules = _iterdirSorted(src_rules)
+            .filter((p) => p.endsWith('.md') && _isFile(p))
+            .map((p) => path.basename(p))
+            .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+        for (const rule of rules) {
+            const target = path.join(dst_rules, rule);
+            if (_isSymlink(target) || _existsOrSymlink(target)) {
+                fs.unlinkSync(target);
+            }
+            if (use_symlinks) {
+                fs.symlinkSync(path.join('..', '..', 'dist/agent-src', 'rules', rule), target);
+            }
+            else {
+                copy_file(path.join(src_rules, rule), target);
+            }
+            current.add(rule);
+            written += 1;
+        }
+    }
+    let removed_rules = 0;
+    for (const name of existing) {
+        if (!current.has(name)) {
+            fs.unlinkSync(path.join(dst_rules, name));
+            removed_rules += 1;
+        }
+    }
+    const mode_label = use_symlinks ? 'Symlinked' : 'Copied';
+    _print(`  ✅  ${mode_label} ${written} rules to .augment/rules/` +
+        (removed_rules ? ` (${removed_rules} stale removed)` : ''));
+    for (const sub of AUGMENT_SYMLINK_DIRS) {
+        const dst = path.join(MODULE_STATE.AUGMENT_DIR, sub);
+        if (_isSymlink(dst) || _existsOrSymlink(dst)) {
+            if (_isDir(dst) && !_isSymlink(dst)) {
+                fs.rmSync(dst, { recursive: true, force: true });
+            }
+            else {
+                fs.unlinkSync(dst);
+            }
+        }
+        const src = path.join(MODULE_STATE.TARGET_DIR, sub);
+        if (_exists(src)) {
+            fs.symlinkSync(path.join('..', 'dist/agent-src', sub), dst);
+            _print(`  ✅  Symlinked .augment/${sub} → ../dist/agent-src/${sub}`);
+        }
+    }
+    for (const name of AUGMENT_SYMLINK_FILES) {
+        const dst = path.join(MODULE_STATE.AUGMENT_DIR, name);
+        const src = path.join(MODULE_STATE.TARGET_DIR, name);
+        if (_isSymlink(dst) || _existsOrSymlink(dst)) {
+            fs.unlinkSync(dst);
+        }
+        if (_exists(src)) {
+            fs.symlinkSync(path.join('..', 'dist/agent-src', name), dst);
+            _print(`  ✅  Symlinked .augment/${name} → ../dist/agent-src/${name}`);
+        }
+    }
+    const known = new Set([...AUGMENT_SYMLINK_DIRS, ...AUGMENT_SYMLINK_FILES, 'rules', 'state']);
+    for (const item of _iterdirSorted(MODULE_STATE.AUGMENT_DIR)) {
+        const name = path.basename(item);
+        if (known.has(name)) {
+            continue;
+        }
+        if (_isSymlink(item) || _isFile(item)) {
+            fs.unlinkSync(item);
+            _print(`  🗑️  Removed stale .augment/${name}`);
+        }
+        else if (_isDir(item)) {
+            fs.rmSync(item, { recursive: true, force: true });
+            _print(`  🗑️  Removed stale .augment/${name}/`);
+        }
+    }
+}
+export function clean_tools() {
+    const targets = [
+        path.join(MODULE_STATE.PROJECT_ROOT, '.claude'),
+        path.join(MODULE_STATE.PROJECT_ROOT, '.cursor'),
+        path.join(MODULE_STATE.PROJECT_ROOT, '.clinerules'),
+        path.join(MODULE_STATE.PROJECT_ROOT, '.windsurf'),
+        path.join(MODULE_STATE.PROJECT_ROOT, '.windsurfrules'),
+        path.join(MODULE_STATE.PROJECT_ROOT, 'GEMINI.md'),
+    ];
+    for (const t of targets) {
+        if (_isDirNoFollow(t) && !_isSymlink(t)) {
+            fs.rmSync(t, { recursive: true, force: true });
+            _print(`  🗑️  Removed ${_relativeToPosix(t, MODULE_STATE.PROJECT_ROOT)}`);
+        }
+        else if (_existsOrSymlink(t)) {
+            fs.unlinkSync(t);
+            _print(`  🗑️  Removed ${_relativeToPosix(t, MODULE_STATE.PROJECT_ROOT)}`);
+        }
+    }
+    _print('✅  All generated tool files cleaned');
+}
+// --- CLI ---------------------------------------------------------------------
+/** Plain stdout print mirroring Python's print(). */
+function _print(line) {
+    process.stdout.write(`${line}\n`);
+}
+export function main(argv = process.argv.slice(2)) {
+    if (!_exists(MODULE_STATE.SOURCE_DIR) && !_any_source_root_exists()) {
+        _print(`❌  No source directory found (looked at ${MODULE_STATE.SOURCE_DIR} and packages/*/.agent-src.uncondensed)`);
+        return 1;
+    }
+    const arg = argv.length > 0 ? argv[0] : '--sync';
+    if (arg === '--list') {
+        const files = list_md_files(MODULE_STATE.SOURCE_DIR);
+        _print(`📄  ${files.length} .md files total:\n`);
+        for (const f of files) {
+            _print(`  ${f}`);
+        }
+    }
+    else if (arg === '--changed') {
+        const changed = list_changed_md(MODULE_STATE.SOURCE_DIR);
+        if (changed.length === 0) {
+            _print('✅  No .md files changed since last condensation');
+            return 0;
+        }
+        _print(`📝  ${changed.length} .md files changed since last condensation:\n`);
+        for (const f of changed) {
+            _print(`  ${f}`);
+        }
+    }
+    else if (arg === '--mark-done') {
+        if (argv.length < 2) {
+            _print('Usage: python scripts/condense.py --mark-done <relative-path>');
+            return 1;
+        }
+        mark_done(argv[1]);
+    }
+    else if (arg === '--mark-all-done') {
+        mark_all_done();
+    }
+    else if (arg === '--check') {
+        const [missing, stale] = check_sync(MODULE_STATE.SOURCE_DIR, MODULE_STATE.TARGET_DIR);
+        if (missing.length === 0 && stale.length === 0) {
+            _print('✅  dist/agent-src/ is in sync with .agent-src.uncondensed/');
+            return 0;
+        }
+        if (missing.length > 0) {
+            _print(`❌  Missing in dist/agent-src/ (${missing.length}):`);
+            for (const f of missing) {
+                _print(`  ${f}`);
+            }
+        }
+        if (stale.length > 0) {
+            _print(`❌  Stale in dist/agent-src/ (${stale.length}):`);
+            for (const f of stale) {
+                _print(`  ${f}`);
+            }
+        }
+        _print(`\nRun 'task sync' to fix non-.md files, then ask the agent to condense .md files.`);
+        return 1;
+    }
+    else if (arg === '--sync') {
+        _print(`Source: ${MODULE_STATE.SOURCE_DIR}`);
+        _print(`Target: ${MODULE_STATE.TARGET_DIR}\n`);
+        _print('--- Syncing non-.md files ---');
+        const copied = sync_non_md(MODULE_STATE.SOURCE_DIR, MODULE_STATE.TARGET_DIR);
+        _print(`\n--- Cleanup stale files ---`);
+        const deleted = cleanup_stale(MODULE_STATE.SOURCE_DIR, MODULE_STATE.TARGET_DIR);
+        const hashes = load_hashes();
+        const stale_keys = Object.keys(hashes).filter((k) => _resolve_source(k) === null);
+        for (const k of stale_keys) {
+            delete hashes[k];
+        }
+        if (stale_keys.length > 0) {
+            save_hashes(hashes);
+            _print(`  Cleaned ${stale_keys.length} stale hash entries`);
+        }
+        const changed = list_changed_md(MODULE_STATE.SOURCE_DIR);
+        _print(`\n✅  Done: ${copied} copied, ${deleted} stale deleted`);
+        if (changed.length > 0) {
+            _print(`📝  ${changed.length} .md files need condensation (run --changed to see them)`);
+        }
+        else {
+            _print(`✅  All .md files are up to date`);
+        }
+        _print(`\n--- Projecting dist/agent-src/ → .augment/ ---`);
+        project_to_augment();
+    }
+    else if (arg === '--check-hashes') {
+        let has_issues = false;
+        const changed = list_changed_md(MODULE_STATE.SOURCE_DIR);
+        const stale = find_stale_hashes(MODULE_STATE.SOURCE_DIR);
+        if (stale.length > 0) {
+            has_issues = true;
+            _print(`⚠️  ${stale.length} stale hash(es) for deleted source files:\n`);
+            for (const f of stale) {
+                _print(`  ${f}`);
+            }
+            _print(`\nRun 'task sync-clean-hashes' to remove them.\n`);
+        }
+        if (changed.length > 0) {
+            has_issues = true;
+            _print(`❌  ${changed.length} .md file(s) need recondensation:\n`);
+            for (const f of changed) {
+                const stored = load_hashes()[f];
+                const reason = stored === undefined ? 'no hash stored' : 'hash mismatch';
+                _print(`  ${f}  (${reason})`);
+            }
+            _print(`\nRun '/condense' command to recondense these files.`);
+        }
+        if (!has_issues) {
+            _print('✅  All condensation hashes are clean (no stale, no mismatches)');
+            return 0;
+        }
+        return 1;
+    }
+    else if (arg === '--clean-hashes') {
+        const count = clean_stale_hashes(MODULE_STATE.SOURCE_DIR);
+        if (count) {
+            _print(`✅  Removed ${count} stale hash(es)`);
+        }
+        else {
+            _print('✅  No stale hashes found');
+        }
+    }
+    else if (arg === '--generate-tools') {
+        generate_tools();
+    }
+    else if (arg === '--clean-tools') {
+        clean_tools();
+    }
+    else if (arg === '--project-augment') {
+        project_to_augment();
+    }
+    else {
+        _print('Usage: python scripts/condense.py [--sync|--list|--changed|--check|--check-hashes|--clean-hashes|--mark-done <path>|--mark-all-done|--generate-tools|--clean-tools|--project-augment]');
+        return 1;
+    }
+    return 0;
+}
+function _isCliEntry() {
+    if (process.argv[1] === undefined) {
+        return false;
+    }
+    const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (import.meta.url === argvUrl) {
+        return true;
+    }
+    // A symlinked invocation (e.g. via an installed `.augment/` projection,
+    // or macOS /var → /private/var temp dirs) makes the raw URLs differ:
+    // import.meta.url is the resolved real path while argv[1] keeps the
+    // symlink path. Compare realpaths so the entry guard still fires
+    // (without this the CLI silently no-ops when run through a symlink).
+    try {
+        const here = fs.realpathSync(fileURLToPath(import.meta.url));
+        const argv = fs.realpathSync(path.resolve(process.argv[1]));
+        return here === argv;
+    }
+    catch {
+        return false;
+    }
+}
+const isMain = _isCliEntry();
+if (isMain) {
+    process.exit(main());
+}
+//# sourceMappingURL=condense.js.map