@event4u/agent-config 5.10.1 → 6.0.0

package/src/scripts/condense.py

@@ -0,0 +1,1919 @@
+#!/usr/bin/env python3
+"""
+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).
+
+Copies non-.md files as-is. Lists .md files that need condensation (done by the
+Augment agent interactively). Tracks SHA-256 hashes of source files to detect
+changes since last condensation.
+
+Usage:
+    python scripts/condense.py              # sync all non-.md files + cleanup + project
+    python scripts/condense.py --list       # list .md files needing condensation
+    python scripts/condense.py --changed    # list only .md files changed since last condensation
+    python scripts/condense.py --check      # check if directories are in sync
+    python scripts/condense.py --mark-done <relative-path>  # mark file as condensed (update hash)
+    python scripts/condense.py --mark-all-done              # mark ALL .md files as condensed
+    python scripts/condense.py --project-augment            # rebuild .augment/ projection
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import shutil
+import sys
+from pathlib import Path
+try:  # invocation-agnostic import (repo-root-on-path vs scripts-on-path)
+    from scripts._lib.agent_settings import project_settings_path
+except ModuleNotFoundError:  # pragma: no cover
+    from _lib.agent_settings import project_settings_path
+
+import yaml
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from _lib.script_output import info, success, flush_summary, resolve_level  # noqa: E402
+from _lib.agent_src import (  # noqa: E402
+    _SLUG_PREFIX_RE,
+    artefact_roots,
+    iter_all_sources,
+    resolve_logical,
+    strip_source_prefix,
+)
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+# Legacy single-root anchor — kept for backward compatibility with callers
+# that pass it explicitly. Multi-root iteration (post-ADR-017 physical
+# move) goes through `_lib.agent_src` helpers.
+SOURCE_DIR = PROJECT_ROOT / ".agent-src.uncondensed"
+TARGET_DIR = PROJECT_ROOT / "dist/agent-src"
+AUGMENT_DIR = PROJECT_ROOT / ".augment"
+HASH_FILE = PROJECT_ROOT / "internal" / ".condensation-hashes.json"
+SETTINGS_FILE = project_settings_path(PROJECT_ROOT)
+
+
+def _iter_sources():
+    """Yield (physical_path, logical_relpath) for every source artefact.
+
+    Wraps `_lib.agent_src.iter_all_sources` so the condenseor walks every
+    active source root (legacy `.agent-src.uncondensed/` plus any
+    `packages/*/.agent-src.uncondensed/`) and keys outputs by the
+    logical relative path that survives the physical move (ADR-017).
+    """
+    yield from iter_all_sources()
+
+
+def _resolve_source(relative: str) -> Path | None:
+    """Find the physical path that backs a logical relative path."""
+    return resolve_logical(relative)
+
+
+def _any_source_root_exists() -> bool:
+    """True if at least one artefact source root contains files."""
+    return bool(artefact_roots())
+
+# Self-projection tool toggle — see agents/.agent-tools.yml. When the file is
+# absent (e.g. tests run in tmp dirs, consumer projects), `_active_tools`
+# returns ``None`` which is treated as "emit every tool".
+_ALL_TOOLS = frozenset({
+    "claude-code", "claude-desktop", "augment", "copilot",
+    "cursor", "windsurf", "cline", "gemini",
+})
+
+
+def _active_tools() -> frozenset[str] | None:
+    """Return the set of active self-projection tools, or None for "all".
+
+    Reads `agents/.agent-tools.yml` relative to the current `PROJECT_ROOT`
+    so test fixtures that monkey-patch `condense.PROJECT_ROOT` see their
+    own (empty) project root and get the default "all tools" behaviour.
+    """
+    tools_file = PROJECT_ROOT / "agents" / ".agent-tools.yml"
+    if not tools_file.exists():
+        return None
+    try:
+        data = yaml.safe_load(tools_file.read_text()) or {}
+    except yaml.YAMLError:
+        return None
+    tools = data.get("tools") if isinstance(data, dict) else None
+    if not isinstance(tools, list):
+        return None
+    return frozenset(str(t) for t in tools if isinstance(t, str))
+
+
+def _tool_active(tool_id: str) -> bool:
+    """True when ``tool_id`` should be emitted by self-projection."""
+    active = _active_tools()
+    return True if active is None else tool_id in active
+
+# Files to copy as-is even if .md (not condensed by agent)
+COPY_AS_IS = {"README.md"}
+
+# Directories (relative to SOURCE_DIR) whose .md content is data, not prose,
+# and must be copied verbatim. Ghostwriter fixtures carry voice_samples that
+# would be destroyed by telegraph condensation.
+COPY_AS_IS_DIRS = frozenset({"ghostwriter"})
+
+
+def _read_augment_rules_use_symlinks() -> bool:
+    """Read augment.rules_use_symlinks from .agent-settings.yml.
+
+    Returns True only when the setting is present under the top-level
+    ``augment:`` block and resolves to a truthy value. Missing file,
+    missing block, or any other value → False (preserve copy default).
+
+    Centralized loader (road-to-portable-dev-preferences P3): tolerance
+    contract handles missing file / malformed YAML / no PyYAML uniformly.
+    """
+    try:
+        from scripts._lib.agent_settings import load_agent_settings
+    except ImportError:  # pragma: no cover — script-style invocation
+        import sys as _sys
+        from pathlib import Path as _Path
+        _sys.path.insert(0, str(_Path(__file__).resolve().parent))
+        from _lib.agent_settings import load_agent_settings  # type: ignore[import-not-found]
+
+    data = load_agent_settings(project_path=SETTINGS_FILE)
+    augment = data.get("augment")
+    if not isinstance(augment, dict):
+        return False
+    value = augment.get("rules_use_symlinks")
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.strip().lower() in ("true", "yes", "on", "1")
+    if isinstance(value, int):
+        return value == 1
+    return False
+
+
+def _lean_projection_mode() -> str:
+    """Read lean_projection.mode from .agent-settings.yml.
+
+    `eager-all` (default) → every rule body inlined into every projection
+    (today's behaviour). `thin` → kernel full-bodied + non-kernel rules as
+    router-resolved pointers (lean-initial-context Phase 3.1; ~36k GPT tok
+    lighter, measured). Missing / malformed → `eager-all`, so the thin path
+    is strictly opt-in and one-flip-revertible (see docs/contracts/rule-router.md
+    § Kill-switch). The flip MUST be live-A/B-validated before it ships as the
+    default — a thin projection only holds behaviour if the agent resolves the
+    pointer on trigger-match.
+    """
+    try:
+        from scripts._lib.agent_settings import load_agent_settings
+    except ImportError:  # pragma: no cover — script-style invocation
+        import sys as _sys
+        from pathlib import Path as _Path
+        _sys.path.insert(0, str(_Path(__file__).resolve().parent))
+        from _lib.agent_settings import load_agent_settings  # type: ignore[import-not-found]
+
+    data = load_agent_settings(project_path=SETTINGS_FILE)
+    lean = data.get("lean_projection")
+    if isinstance(lean, dict) and str(lean.get("mode", "")).strip().lower() == "thin":
+        return "thin"
+    return "eager-all"
+
+
+def file_hash(filepath: Path) -> str:
+    """Return SHA-256 hex digest of a file."""
+    h = hashlib.sha256()
+    h.update(filepath.read_bytes())
+    return h.hexdigest()
+
+
+# ---------------------------------------------------------------------------
+# Transitive include hashing (road-to-6.0.0-D Phase 0 Step 1)
+#
+# An artefact declares the skills / rules it includes via its frontmatter
+# `skills:` / `rules:` lists. The condensation gate must treat that artefact
+# as stale when an included skill/rule changes — otherwise a moved or edited
+# dependency slips past the hash check silently (the single biggest risk the
+# 6.0.0-D council named). `effective_hash` folds the content hash of every
+# transitive include into the artefact's own content hash.
+#
+# Leaf artefacts (no declared includes) hash exactly like `file_hash`, so the
+# stored hash table only changes for artefacts that actually declare deps —
+# the migration stays contained.
+# ---------------------------------------------------------------------------
+
+_DEP_FRONTMATTER_KEYS = ("skills", "rules")
+
+
+def _slug_to_logical(slug: str) -> str | None:
+    """Map a skill / rule slug to its logical relative path, if it resolves.
+
+    Skill slug ``foo`` → ``skills/foo/SKILL.md``; rule slug ``bar`` →
+    ``rules/bar.md``. Returns the first candidate that backs a real source
+    file, else ``None`` (a typo'd / external slug contributes no edge).
+    """
+    for cand in (f"skills/{slug}/SKILL.md", f"rules/{slug}.md"):
+        if _resolve_source(cand) is not None:
+            return cand
+    return None
+
+
+def _direct_includes(relative: str) -> list[str]:
+    """Logical relpaths an artefact directly includes via frontmatter.
+
+    Reads the artefact's ``skills:`` / ``rules:`` frontmatter lists and
+    resolves each slug to a logical path. Non-resolving slugs are skipped.
+    """
+    source = _resolve_source(relative)
+    if source is None:
+        return []
+    try:
+        meta, _ = _parse_frontmatter(source.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError):
+        return []
+    deps: list[str] = []
+    for key in _DEP_FRONTMATTER_KEYS:
+        value = meta.get(key)
+        if not isinstance(value, list):
+            continue
+        for item in value:
+            if not isinstance(item, str):
+                continue
+            logical = _slug_to_logical(item.strip())
+            if logical is not None and logical != relative:
+                deps.append(logical)
+    return deps
+
+
+def effective_hash(relative: str, _seen: frozenset | None = None) -> str:
+    """Content hash of an artefact folded with its transitive include hashes.
+
+    Changes whenever the artefact's own bytes change OR any skill/rule it
+    transitively includes changes. Cycle-safe: a slug that re-enters the
+    current resolution chain folds only its own content hash, breaking the
+    loop. Leaf artefacts (no includes) return exactly ``file_hash`` so the
+    stored-hash migration is limited to artefacts that declare dependencies.
+    """
+    source = _resolve_source(relative)
+    if source is None:
+        return ""
+    own = file_hash(source)
+    if _seen is not None and relative in _seen:
+        return own  # cycle — fold own content only
+    deps = sorted(set(_direct_includes(relative)))
+    if not deps:
+        return own  # leaf — identical to plain file_hash
+    seen_next = (_seen or frozenset()) | {relative}
+    parts = [own] + [effective_hash(dep, seen_next) for dep in deps]
+    return hashlib.sha256("\n".join(parts).encode("utf-8")).hexdigest()
+
+
+def load_hashes() -> dict:
+    """Load stored condensation hashes from JSON file."""
+    if HASH_FILE.exists():
+        try:
+            return json.loads(HASH_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def save_hashes(hashes: dict) -> None:
+    """Save condensation hashes to JSON file."""
+    HASH_FILE.parent.mkdir(parents=True, exist_ok=True)
+    HASH_FILE.write_text(json.dumps(hashes, indent=2, sort_keys=True) + "\n")
+
+
+def mark_done(relative_path: str) -> None:
+    """Mark a single file as condensed by storing its current source hash.
+
+    Also runs the path rewriter on the just-written `dist/agent-src/<path>` so
+    logical names from the source frontmatter resolve to deployment-correct
+    relative paths in the shipped layer (P1 of road-to-path-fixes.md).
+    Idempotent — re-running is a no-op.
+    """
+    source_file = _resolve_source(relative_path)
+    if source_file is None or not source_file.exists():
+        print(f"❌  Source file not found: {relative_path}")
+        sys.exit(1)
+    apply_path_rewriter(relative_path)
+    hashes = load_hashes()
+    hashes[relative_path] = effective_hash(relative_path)
+    save_hashes(hashes)
+    print(f"✅  Marked as condensed: {relative_path}")
+
+
+def apply_path_rewriter(relative_path: str) -> bool:
+    """Apply `_rewrite_paths` to `dist/agent-src/<relative_path>` in-place.
+
+    Returns True if the file was modified, False otherwise. Silently
+    returns False if the target doesn't exist (condensation hasn't run
+    yet) — `--mark-done` is also valid before content exists.
+    """
+    target = TARGET_DIR / relative_path
+    if not target.exists() or not relative_path.endswith(".md"):
+        return False
+    original = target.read_text(encoding="utf-8")
+    rewritten = _rewrite_paths(original, relative_path)
+    if rewritten == original:
+        return False
+    target.write_text(rewritten, encoding="utf-8")
+    return True
+
+
+def mark_all_done() -> None:
+    """Mark ALL .md files as condensed (e.g. after initial full condensation)."""
+    hashes = load_hashes()
+    count = 0
+    for source_file, relative in _iter_sources():
+        if not should_condense(source_file):
+            continue
+        hashes[relative] = effective_hash(relative)
+        count += 1
+    save_hashes(hashes)
+    print(f"✅  Marked {count} files as condensed")
+
+
+def list_changed_md(source_dir: Path) -> list:
+    """List .md files whose source hash differs from stored hash (= need recondensation).
+
+    The ``source_dir`` parameter is retained for backward compatibility but
+    ignored — iteration walks every active source root (ADR-017).
+    """
+    del source_dir  # multi-root: ignored, kept for signature stability
+    hashes = load_hashes()
+    changed = []
+    for source_file, relative in _iter_sources():
+        if not should_condense(source_file):
+            continue
+        current_hash = effective_hash(relative)
+        stored_hash = hashes.get(relative)
+        if stored_hash != current_hash:
+            changed.append(relative)
+    return changed
+
+
+def find_stale_hashes(source_dir: Path) -> list:
+    """Find hashes stored for source files that no longer exist in any root."""
+    del source_dir  # multi-root: ignored, kept for signature stability
+    hashes = load_hashes()
+    stale = []
+    for relative in sorted(hashes.keys()):
+        if _resolve_source(relative) is None:
+            stale.append(relative)
+    return stale
+
+
+def clean_stale_hashes(source_dir: Path) -> int:
+    """Remove hashes for source files that no longer exist. Returns count removed."""
+    stale = find_stale_hashes(source_dir)
+    if not stale:
+        return 0
+    hashes = load_hashes()
+    for relative in stale:
+        del hashes[relative]
+    save_hashes(hashes)
+    return len(stale)
+
+
+
+def should_condense(filepath: Path) -> bool:
+    """Check if file should be condensed (is .md and not in copy-as-is list)."""
+    if filepath.suffix != ".md":
+        return False
+    if filepath.name in COPY_AS_IS:
+        return False
+    # Determine the logical relative path so the COPY_AS_IS_DIRS check
+    # works for both legacy (`.agent-src.uncondensed/`) and post-move
+    # (`packages/*/.agent-src.uncondensed/`) source roots.
+    rel_parts: tuple[str, ...] = filepath.parts
+    for root in artefact_roots():
+        try:
+            rel_parts = filepath.relative_to(root).parts
+            break
+        except ValueError:
+            continue
+    if rel_parts and rel_parts[0] in COPY_AS_IS_DIRS:
+        return False
+    return True
+
+
+def copy_file(source: Path, target: Path) -> None:
+    """Copy a non-.md file as-is."""
+    target.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source, target)
+
+
+def cleanup_stale(source_dir: Path, target_dir: Path) -> int:
+    """Delete files in target that don't exist in any source root. Returns count."""
+    del source_dir  # multi-root: ignored, kept for signature stability
+    deleted = 0
+    if not target_dir.exists():
+        return 0
+
+    for target_file in sorted(target_dir.rglob("*")):
+        if target_file.is_dir():
+            continue
+        relative = target_file.relative_to(target_dir)
+        if _resolve_source(str(relative)) is None:
+            print(f"  Deleting stale: {relative}")
+            target_file.unlink()
+            deleted += 1
+
+    # Remove empty directories
+    for dirpath in sorted(target_dir.rglob("*"), reverse=True):
+        if dirpath.is_dir() and not any(dirpath.iterdir()):
+            dirpath.rmdir()
+            print(f"  Removing empty dir: {dirpath.relative_to(target_dir)}")
+
+    return deleted
+
+
+def sync_non_md(source_dir: Path, target_dir: Path) -> int:
+    """Copy all non-.md files (and COPY_AS_IS .md files) from every source
+    root to target. Returns count."""
+    del source_dir  # multi-root: ignored, kept for signature stability
+    copied = 0
+    seen: set[str] = set()
+    for source_file, relative in _iter_sources():
+        if should_condense(source_file):
+            continue  # .md files are condensed by the agent, not copied here
+        if relative in seen:
+            continue
+        seen.add(relative)
+        target_file = target_dir / relative
+        copy_file(source_file, target_file)
+        print(f"  Copied: {relative}")
+        copied += 1
+    return copied
+
+
+def list_md_files(source_dir: Path) -> list:
+    """List all .md files that need condensation by the agent."""
+    del source_dir  # multi-root: ignored, kept for signature stability
+    files: list[str] = []
+    seen: set[str] = set()
+    for source_file, relative in _iter_sources():
+        if not should_condense(source_file):
+            continue
+        if relative in seen:
+            continue
+        seen.add(relative)
+        files.append(relative)
+    return sorted(files)
+
+
+def check_sync(source_dir: Path, target_dir: Path) -> tuple:
+    """Check if target is in sync with source(s). Returns (missing, stale) lists."""
+    del source_dir  # multi-root: ignored, kept for signature stability
+    missing = []
+    stale = []
+
+    # Files in any source root but not in target
+    seen: set[str] = set()
+    for _source_file, relative in _iter_sources():
+        if relative in seen:
+            continue
+        seen.add(relative)
+        if not (target_dir / relative).exists():
+            missing.append(relative)
+
+    # Files in target but not in any source root (stale)
+    if target_dir.exists():
+        for target_file in sorted(target_dir.rglob("*")):
+            if target_file.is_dir():
+                continue
+            relative = str(target_file.relative_to(target_dir))
+            if _resolve_source(relative) is None:
+                stale.append(relative)
+
+    return missing, stale
+
+
+# ── Multi-agent tool generation ──────────────────────────────────────
+
+RULES_SOURCE = PROJECT_ROOT / "dist/agent-src" / "rules"
+
+TOOL_DIRS = {
+    ".claude/rules": "../../dist/agent-src/rules",
+    ".cursor/rules": "../../dist/agent-src/rules",
+    ".clinerules": "../dist/agent-src/rules",
+}
+
+SKILLS_SOURCE = PROJECT_ROOT / "dist/agent-src" / "skills"
+COMMANDS_SOURCE = PROJECT_ROOT / "dist/agent-src" / "commands"
+PERSONAS_SOURCE = PROJECT_ROOT / "dist/agent-src" / "personas"
+USER_TYPES_SOURCE = PROJECT_ROOT / "dist/agent-src" / "user-types"
+CLAUDE_SKILLS_DIR = PROJECT_ROOT / ".claude" / "skills"
+# Committed plugin-marketplace projection for command-as-skill entries.
+# The marketplace is consumed as a git repo, so every skills[] path must be
+# committed. Real skills resolve to dist/agent-src/skills/<name> (already
+# committed); commands have no <slug>/SKILL.md shape in source, so their
+# committed projection lives here. .claude/skills/ stays a gitignored,
+# generate-tools-rebuilt local auto-discovery channel.
+PLUGIN_SKILLS_DIR = PROJECT_ROOT / ".claude-plugin" / "skills"
+
+PERSONA_TOOL_DIRS = {
+    ".claude/personas": "../../dist/agent-src/personas",
+    ".cursor/personas": "../../dist/agent-src/personas",
+}
+
+USER_TYPE_TOOL_DIRS = {
+    ".claude/user-types": "../../dist/agent-src/user-types",
+    ".cursor/user-types": "../../dist/agent-src/user-types",
+}
+
+# Map tool-projection directories to the canonical tool ID used by
+# `agents/.agent-tools.yml`. Directories not in this map are always emitted.
+_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",
+}
+
+
+def _filter_tool_dirs(mapping: dict[str, str]) -> dict[str, str]:
+    """Drop entries whose tool ID is not active in `agents/.agent-tools.yml`."""
+    return {
+        d: p for d, p in mapping.items()
+        if _tool_active(_DIR_TOOL_ID.get(d, "claude-code"))
+    }
+
+
+def strip_frontmatter(content: str) -> str:
+    """Remove YAML frontmatter (between --- markers) from content."""
+    if content.startswith("---"):
+        end = content.find("---", 3)
+        if end != -1:
+            content = content[end + 3:].lstrip("\n")
+    return content
+
+
+# ── Path rewriter (P1 of road-to-path-fixes.md) ───────────────────────────
+# Source files use logical names that the rewriter resolves at condense
+# time, so the shipped `dist/agent-src/` (and `.augment/` projection) carry
+# deployment-correct relative paths without the agent author having to
+# know how deep their file lives.
+#
+# Frontmatter rewrites:
+#   load_context: / load_context_eager:
+#     contexts/<area>/<file>.md                          (logical, preferred)
+#     .agent-src.uncondensed/contexts/<area>/<file>.md  (legacy)
+#       → ../contexts/<area>/<file>.md  (relative from dist/agent-src/rules/)
+#   triggers[].path_prefix:
+#     LEFT ALONE — `path_prefix:` is a literal match pattern, not a
+#     file reference. Source-of-truth rules that fire on edits under
+#     `.agent-src.uncondensed/` keep that prefix verbatim (see
+#     road-to-path-fixes.md P2.2 / Modified Option 1).
+#
+# Body-link rewrites:
+#   ../../docs/guidelines/<file>.md  →  ../docs/guidelines/<file>.md
+#   ../../docs/contracts/<file>.md   →  ../docs/contracts/<file>.md
+#
+# Idempotent: applying twice is a no-op (rewritten patterns no longer
+# match the source patterns).
+
+_LEGACY_SRC_PREFIX = ".agent-src.uncondensed/"
+_PROJECTED_SRC_PREFIX = "dist/agent-src/"
+# Pre-ADR-057 projected prefix — still stripped defensively so content
+# authored against the old root-level output keeps resolving.
+_LEGACY_PROJECTED_SRC_PREFIX = ".agent-src/"
+
+# A YAML list item under load_context*: `  - some/path.md` (optionally quoted)
+_FM_LIST_ITEM_RE = re.compile(r'^(\s*-\s*)(["\']?)([^"\'\n]+?\.md)(["\']?)\s*$')
+
+# `path_prefix:` line — top-level or under `triggers:` (with leading dash)
+_FM_PATH_PREFIX_RE = re.compile(
+    r'^(\s*(?:-\s+)?path_prefix:\s*)(["\']?)([^"\'\n]+?)(["\']?)\s*$'
+)
+
+# Body-link patterns (relative two-up to docs/) — capture the docs/... tail
+_BODY_DOCS_RE = re.compile(r'\.\./\.\./(docs/(?:guidelines|contracts)/[^)\s]+\.md)')
+
+
+def _depth_prefix(source_relative_path: str) -> str:
+    """Return the `../` chain to climb from `<source_relative_path>` back to
+    the source root. A file at `rules/X.md` (1 dir deep) needs `../`; a
+    file at `commands/council/default.md` (2 dirs deep) needs `../../`.
+    """
+    parts = Path(source_relative_path).parts
+    depth = max(len(parts) - 1, 1)
+    return "../" * depth
+
+
+def _split_frontmatter(content: str):
+    """Return (frontmatter_lines, body) — frontmatter_lines is None if no FM."""
+    if not content.startswith("---\n"):
+        return None, content
+    end = content.find("\n---\n", 4)
+    if end == -1:
+        return None, content
+    fm_text = content[4:end]
+    body = content[end + len("\n---\n"):]
+    return fm_text.split("\n"), body
+
+
+def _rewrite_load_context_value(value: str, prefix: str) -> str:
+    """Rewrite a single `load_context` list-item value to a deployment path."""
+    # Already relative or absolute → leave alone (idempotence).
+    if value.startswith(("../", "./", "/")):
+        return value
+    # Legacy fully-qualified source prefix.
+    if value.startswith(_LEGACY_SRC_PREFIX):
+        return prefix + value[len(_LEGACY_SRC_PREFIX):]
+    # Projected source prefix (defensive — also strip).
+    if value.startswith(_PROJECTED_SRC_PREFIX):
+        return prefix + value[len(_PROJECTED_SRC_PREFIX):]
+    if value.startswith(_LEGACY_PROJECTED_SRC_PREFIX):
+        return prefix + value[len(_LEGACY_PROJECTED_SRC_PREFIX):]
+    # Logical name (e.g. `contexts/execution/foo.md`).
+    return prefix + value
+
+
+def _rewrite_path_prefix_value(value: str) -> str:
+    """No-op for `triggers[].path_prefix:` values.
+
+    `path_prefix:` is a literal match pattern the host evaluates against
+    the file the agent is editing — not a file reference. Rewriting it
+    breaks the workflow it was authored for: source-of-truth rules that
+    fire when the agent edits files under `.agent-src.uncondensed/`
+    keep that prefix verbatim. The prefix ban therefore applies only to
+    `load_context:` entries and body links (see road-to-path-fixes.md
+    P2.2 + the AI-Council convergence on 2026-05-06).
+    """
+    return value
+
+
+def _rewrite_frontmatter_lines(lines, prefix):
+    """Apply load_context / path_prefix rewrites to a frontmatter line list."""
+    in_load_context = False
+    out = []
+    for line in lines:
+        bare = line.lstrip()
+        if bare.startswith(("load_context:", "load_context_eager:")):
+            in_load_context = True
+            out.append(line)
+            continue
+        if in_load_context:
+            m = _FM_LIST_ITEM_RE.match(line)
+            if m:
+                indent, q1, value, q2 = m.groups()
+                rewritten = _rewrite_load_context_value(value, prefix)
+                out.append(f"{indent}{q1}{rewritten}{q2}")
+                continue
+            in_load_context = False
+            # fall through to path_prefix / passthrough
+        m = _FM_PATH_PREFIX_RE.match(line)
+        if m:
+            head, q1, value, q2 = m.groups()
+            out.append(f"{head}{q1}{_rewrite_path_prefix_value(value)}{q2}")
+            continue
+        out.append(line)
+    return out
+
+
+def _rewrite_body_links(body: str, prefix: str) -> str:
+    """Rewrite `../../docs/{guidelines,contracts}/...` to use depth-prefix."""
+    return _BODY_DOCS_RE.sub(prefix + r"\1", body)
+
+
+# ── Human-review banner injection (Phase 5.3 / ADR-018) ───────────────────
+# Source artefacts may set `trust.human_review_required: true` in their
+# frontmatter. The condenseor injects a short, parser-stable banner block
+# at the top of the projected body so every downstream surface (agent
+# memory, .augment, .claude, etc.) surfaces the gate. Idempotent — the
+# marker comment prevents double-injection on re-condense.
+
+_HRR_BANNER_MARKER = "<!-- agent-config:human-review-banner -->"
+
+# Plain YAML list item — any scalar, used to read `packs:` / `workspaces:`
+# blocks where values are bare identifiers, not file paths.
+_FM_PLAIN_LIST_RE = re.compile(r'^\s*-\s*(["\']?)([^"\'\n]+?)\1\s*$')
+
+
+def _parse_trust_and_owner(fm_lines):
+    """Extract `trust.level`, `human_review_required`, and an owner hint
+    from a frontmatter line list. Owner falls back to the first pack
+    prefix (`finance-basic` → `finance`), then the first workspace,
+    then `unknown`.
+    """
+    # Default to the schema default `core` so the HUMAN REVIEW banner still
+    # renders if a future artefact sets `human_review_required: true` while
+    # omitting the (defaulted) `trust.level` line (abstraction-reduction
+    # preflight Decision D). The banner only fires when `hrr` is true, so this
+    # never affects artefacts that omit the whole trust block.
+    level = "core"
+    hrr = False
+    packs: list[str] = []
+    workspaces: list[str] = []
+    in_trust = False
+    in_packs = False
+    in_workspaces = False
+    for line in fm_lines:
+        stripped = line.lstrip()
+        indent = len(line) - len(stripped)
+        if indent == 0 and stripped.endswith(":"):
+            key = stripped[:-1]
+            in_trust = key == "trust"
+            in_packs = key == "packs"
+            in_workspaces = key == "workspaces"
+            continue
+        if in_trust and stripped.startswith("level:"):
+            level = stripped.split(":", 1)[1].strip().strip('"').strip("'")
+        elif in_trust and stripped.startswith("human_review_required:"):
+            val = stripped.split(":", 1)[1].strip()
+            hrr = val.lower() == "true"
+        elif in_packs or in_workspaces:
+            m = _FM_PLAIN_LIST_RE.match(line)
+            if m:
+                value = m.group(2).strip()
+                (packs if in_packs else workspaces).append(value)
+    owner = "unknown"
+    if packs:
+        owner = packs[0].split("-")[0]
+    elif workspaces:
+        owner = workspaces[0]
+    return level, hrr, owner
+
+
+def _inject_hrr_banner(body: str, level: str, owner: str) -> str:
+    """Prepend the HUMAN_REVIEW banner block to `body`. Idempotent — a
+    body that already carries `_HRR_BANNER_MARKER` is returned unchanged.
+    """
+    if _HRR_BANNER_MARKER in body:
+        return body
+    banner = (
+        f"{_HRR_BANNER_MARKER}\n"
+        f"> HUMAN REVIEW REQUIRED · trust: {level} · owner: {owner}\n\n"
+    )
+    return banner + body.lstrip("\n")
+
+
+def _rewrite_paths(content: str, source_relative_path: str) -> str:
+    """Rewrite logical / legacy paths in `content` for a file shipped at
+    `dist/agent-src/{source_relative_path}`. Idempotent.
+
+    See module-level comment above for the full pattern catalog.
+    Also injects the HUMAN_REVIEW banner when the source frontmatter
+    sets `trust.human_review_required: true` (Phase 5.3 / ADR-018).
+    """
+    prefix = _depth_prefix(source_relative_path)
+    fm_lines, body = _split_frontmatter(content)
+    body = _rewrite_body_links(body, prefix)
+    if fm_lines is None:
+        return body
+    new_fm = _rewrite_frontmatter_lines(fm_lines, prefix)
+    level, hrr, owner = _parse_trust_and_owner(fm_lines)
+    if hrr and level:
+        body = _inject_hrr_banner(body, level, owner)
+    return "---\n" + "\n".join(new_fm) + "\n---\n" + body
+
+
+def generate_rule_symlinks() -> int:
+    """Create symlink directories for rules (.claude/rules/, .cursor/rules/, .clinerules/).
+
+    Symlinks ALL .md files from dist/agent-src/rules/ into tool-specific directories.
+    """
+    # All .md files in dist/agent-src/rules/ — not just universal ones
+    rules = sorted([f.name for f in RULES_SOURCE.glob("*.md")])
+    tool_dirs = _filter_tool_dirs(TOOL_DIRS)
+
+    # Thin-projection opt-in (lean-initial-context Phase 3.1). Default
+    # `eager-all` keeps the symlink behaviour below untouched; `thin` writes
+    # kernel rules full + non-kernel rules as router-resolved pointers.
+    thin_files: dict[str, str] | None = None
+    if _lean_projection_mode() == "thin":
+        try:
+            from scripts.project_thin_rules import build_thin
+        except ImportError:  # pragma: no cover — script-style invocation
+            from project_thin_rules import build_thin  # type: ignore[import-not-found]
+        thin_files = build_thin(RULES_SOURCE)
+
+    total = 0
+    for tool_dir, rel_prefix in tool_dirs.items():
+        target_dir = PROJECT_ROOT / tool_dir
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        # Clean stale symlinks
+        for item in target_dir.iterdir():
+            if item.is_symlink() and item.name not in rules and item.name != "README.md":
+                item.unlink()
+
+        for rule in rules:
+            link = target_dir / rule
+            if link.exists() or link.is_symlink():
+                link.unlink()
+            if thin_files is not None:
+                # Thin mode: write a real file (kernel full / non-kernel pointer),
+                # not a symlink to the full source body.
+                link.write_text(thin_files[rule], encoding="utf-8")
+            else:
+                link.symlink_to(Path(rel_prefix) / rule)
+            total += 1
+
+    # Verify counts match across all tool directories
+    source_count = len(rules)
+    for tool_dir in tool_dirs:
+        target_dir = PROJECT_ROOT / tool_dir
+        tool_count = len([f for f in target_dir.iterdir() if f.suffix == ".md"])
+        if tool_count != source_count:
+            print(f"  ⚠️  {tool_dir}: {tool_count} rules (expected {source_count})")
+
+    info(f"  ✅  Created {total} rule symlinks across {len(tool_dirs)} tool directories ({source_count} rules each)")
+    return total
+
+
+def generate_windsurfrules() -> int:
+    """Generate .windsurfrules by concatenating all rules (no frontmatter).
+    """
+    rules = sorted([f.name for f in RULES_SOURCE.glob("*.md")])
+    parts = ["# Auto-generated from dist/agent-src/rules/ — do not edit directly\n"]
+
+    for rule in rules:
+        path = RULES_SOURCE / rule
+        content = strip_frontmatter(path.read_text())
+        parts.append(f"---\n\n{content.strip()}\n")
+
+    output = PROJECT_ROOT / ".windsurfrules"
+    output.write_text("\n".join(parts) + "\n")
+    info(f"  ✅  Generated .windsurfrules ({len(rules)} rules)")
+    return len(rules)
+
+
+# ── Modern editor formats (road-to-simplicity-and-everywhere Phase 5) ─
+# Cursor `.cursor/rules/*.mdc` (frontmatter: description, globs,
+# alwaysApply) and Windsurf `.windsurf/rules/*.md` (frontmatter:
+# trigger, description, globs) are the formats current editors prefer.
+# Legacy `.windsurfrules` aggregate stays for users who prefer it.
+
+CURSOR_RULES_MDC_DIR = PROJECT_ROOT / ".cursor" / "rules"
+WINDSURF_RULES_DIR = PROJECT_ROOT / ".windsurf" / "rules"
+WINDSURF_WORKFLOWS_DIR = PROJECT_ROOT / ".windsurf" / "workflows"
+CURSOR_COMMANDS_DIR = PROJECT_ROOT / ".cursor" / "commands"
+
+
+def _parse_frontmatter(content: str) -> tuple[dict, str]:
+    """Split a `---`-delimited YAML frontmatter from the body."""
+    if not content.startswith("---"):
+        return {}, content
+    end = content.find("\n---", 3)
+    if end == -1:
+        return {}, content
+    raw = content[3:end].strip()
+    body = content[end + 4:].lstrip("\n")
+    try:
+        meta = yaml.safe_load(raw) or {}
+    except yaml.YAMLError:
+        meta = {}
+    return meta if isinstance(meta, dict) else {}, body
+
+
+def _yaml_scalar(value: str) -> str:
+    """Return a YAML-safe single-line scalar for a frontmatter value.
+
+    Descriptions can contain ``:``, ``#``, or quotes — characters that break
+    an unquoted YAML scalar (e.g. ``description: Hard Floor: ...`` is invalid
+    YAML). A JSON string is itself a valid YAML double-quoted scalar, so
+    ``json.dumps`` gives correct escaping for free.
+    """
+    return json.dumps(value, ensure_ascii=False)
+
+
+def _emit_cursor_mdc(source: Path, target: Path) -> None:
+    """Write a Cursor `.mdc` file with Cursor-shaped frontmatter."""
+    meta, body = _parse_frontmatter(source.read_text())
+    description = (meta.get("description") or "").replace("\n", " ").strip()
+    always_apply = bool(meta.get("alwaysApply") or meta.get("type") == "always")
+    lines = [
+        "---",
+        f"description: {_yaml_scalar(description)}",
+        "globs: ",
+        f"alwaysApply: {'true' if always_apply else 'false'}",
+        "---",
+        "",
+        body.rstrip() + "\n",
+    ]
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text("\n".join(lines))
+
+
+def _emit_windsurf_rule(source: Path, target: Path) -> None:
+    """Write a Windsurf rule with Wave-8 frontmatter (trigger/description/globs)."""
+    meta, body = _parse_frontmatter(source.read_text())
+    description = (meta.get("description") or "").replace("\n", " ").strip()
+    always_apply = bool(meta.get("alwaysApply") or meta.get("type") == "always")
+    trigger = "always_on" if always_apply else "model_decision"
+    lines = [
+        "---",
+        f"trigger: {trigger}",
+        f"description: {_yaml_scalar(description)}",
+        "globs: ",
+        "---",
+        "",
+        body.rstrip() + "\n",
+    ]
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text("\n".join(lines))
+
+
+def _clean_modern_dir(target_dir: Path, valid_names: set[str]) -> None:
+    """Drop files in `target_dir` whose names are not in `valid_names`."""
+    if not target_dir.exists():
+        return
+    for item in target_dir.iterdir():
+        if item.name == "README.md":
+            continue
+        if item.name not in valid_names:
+            if item.is_dir() and not item.is_symlink():
+                shutil.rmtree(item)
+            else:
+                item.unlink()
+
+
+def generate_cursor_mdc_rules() -> int:
+    """Emit `.cursor/rules/*.mdc` per source rule (alongside legacy `.md` symlinks)."""
+    rules = sorted(RULES_SOURCE.glob("*.md"))
+    valid = {f"{r.stem}.mdc" for r in rules}
+    _clean_modern_dir(CURSOR_RULES_MDC_DIR, valid | {r.name for r in rules})
+    for rule in rules:
+        _emit_cursor_mdc(rule, CURSOR_RULES_MDC_DIR / f"{rule.stem}.mdc")
+    info(f"  ✅  Wrote {len(rules)} `.cursor/rules/*.mdc` files")
+    return len(rules)
+
+
+def generate_windsurf_modern_rules() -> int:
+    """Emit `.windsurf/rules/*.md` per source rule (Wave-8 frontmatter)."""
+    rules = sorted(RULES_SOURCE.glob("*.md"))
+    valid = {r.name for r in rules}
+    _clean_modern_dir(WINDSURF_RULES_DIR, valid)
+    for rule in rules:
+        _emit_windsurf_rule(rule, WINDSURF_RULES_DIR / rule.name)
+    info(f"  ✅  Wrote {len(rules)} `.windsurf/rules/*.md` files")
+    return len(rules)
+
+
+def generate_cursor_commands(active_command_slugs: set[str] | None = None) -> int:
+    """Symlink `.cursor/commands/<slug>.md` per source command.
+
+    `active_command_slugs` is `None` for legacy-all (every command projected)
+    or a slug allowlist for scoped projection; the `_clean_modern_dir` pass
+    then reaps any command no longer in the active set.
+    """
+    if not (PROJECT_ROOT / "src" / "domains").is_dir():
+        return 0
+    cmds = [
+        (sf, slug)
+        for sf, slug in _iter_commands()
+        if active_command_slugs is None or slug in active_command_slugs
+    ]
+    valid = {f"{slug}.md" for _, slug in cmds}
+    _clean_modern_dir(CURSOR_COMMANDS_DIR, valid)
+    CURSOR_COMMANDS_DIR.mkdir(parents=True, exist_ok=True)
+    count = 0
+    for source_file, slug in cmds:
+        link = CURSOR_COMMANDS_DIR / f"{slug}.md"
+        if link.exists() or link.is_symlink():
+            link.unlink()
+        rel = Path("../..") / source_file.relative_to(PROJECT_ROOT)
+        link.symlink_to(rel)
+        count += 1
+    info(f"  ✅  Linked {count} `.cursor/commands/*.md` files")
+    return count
+
+
+def generate_windsurf_workflows(active_command_slugs: set[str] | None = None) -> int:
+    """Symlink `.windsurf/workflows/<slug>.md` per source command.
+
+    `active_command_slugs` is `None` for legacy-all or a slug allowlist for
+    scoped projection (see `generate_cursor_commands`).
+    """
+    if not (PROJECT_ROOT / "src" / "domains").is_dir():
+        return 0
+    cmds = [
+        (sf, slug)
+        for sf, slug in _iter_commands()
+        if active_command_slugs is None or slug in active_command_slugs
+    ]
+    valid = {f"{slug}.md" for _, slug in cmds}
+    _clean_modern_dir(WINDSURF_WORKFLOWS_DIR, valid)
+    WINDSURF_WORKFLOWS_DIR.mkdir(parents=True, exist_ok=True)
+    count = 0
+    for source_file, slug in cmds:
+        link = WINDSURF_WORKFLOWS_DIR / f"{slug}.md"
+        if link.exists() or link.is_symlink():
+            link.unlink()
+        rel = Path("../..") / source_file.relative_to(PROJECT_ROOT)
+        link.symlink_to(rel)
+        count += 1
+    info(f"  ✅  Linked {count} `.windsurf/workflows/*.md` files")
+    return count
+
+
+
+
+def generate_gemini_md() -> None:
+    """Create GEMINI.md symlink to AGENTS.md."""
+    link = PROJECT_ROOT / "GEMINI.md"
+    if link.exists() or link.is_symlink():
+        link.unlink()
+    link.symlink_to("AGENTS.md")
+    info("  ✅  Created GEMINI.md → AGENTS.md symlink")
+
+
+def _command_slug(source_file: Path) -> str:
+    """Return the flat .claude/skills/ slug for a command source file.
+
+    Top-level commands keep their stem (`commit.md` → `commit`). Nested
+    commands flatten the relative path with `-` (`council/default.md` →
+    `council-default`). Keeps slug collisions out of `.claude/skills/`
+    while preserving native nested invocation in `dist/agent-src/commands/`.
+    """
+    rel = source_file.relative_to(COMMANDS_SOURCE)
+    return "-".join(rel.with_suffix("").parts)
+
+
+def _iter_commands():
+    """Yield (source_file, slug) for every command, sourced from `src/domains/`.
+
+    Repointed (ADR-044 amendment, 2026-06-04) from the legacy
+    `dist/agent-src/commands/` tree to the canonical
+    `src/domains/<pack>/<verb>/command.md` source via
+    `_lib.agent_src.iter_commands()`. The slug is the pack-stripped hyphenated
+    subpath (`_command_path_to_slug`) — the path is the single source of truth
+    per the amendment. `source_file` is the physical `src/domains/` path; every
+    consumer builds its symlink target relative to `PROJECT_ROOT`, not
+    `COMMANDS_SOURCE`.
+    """
+    src_domains = PROJECT_ROOT / "src" / "domains"
+    if not src_domains.is_dir():
+        return
+    for source_file in sorted(src_domains.rglob("command.md")):
+        rel = source_file.relative_to(PROJECT_ROOT).as_posix()
+        slug = _command_path_to_slug(rel)
+        if not slug:
+            continue
+        # ADR-044 amendment A3: a pack may opt into a slug prefix; the path
+        # stays the single source of truth (PROJECT_ROOT-aware for tests that
+        # monkey-patch the root).
+        pack_id = source_file.relative_to(src_domains).parts[0]
+        prefix = _domains_slug_prefix(pack_id)
+        if prefix and slug != prefix and not slug.startswith(prefix + "-"):
+            slug = f"{prefix}-{slug}"
+        yield source_file, slug
+
+
+# --- Per-skill model auto-switch (ADR-035 / road-to-model-capability-tiers) ---
+
+# The SINGLE generator-owned tier→Claude-model mapping (ADR-035 § 3). Claude
+# Code is the only surface that consumes a native `model:`, so this is the only
+# place a capability tier resolves to a concrete model. `inherit`/absent emit
+# nothing and stay pure symlinks. Non-Claude agents never get a per-vendor
+# table — the rule surfaces the tier name as a suggestion.
+# Tier→model mapping + frontmatter regex live in the shared _lib module so the
+# repo generator (here) and the consumer install finalizer
+# (install.py::finalize_claude_model_tiers) can never drift (ADR-034/035).
+from _lib.model_tier import (  # noqa: E402
+    TIER_TO_CLAUDE_MODEL as _TIER_TO_CLAUDE_MODEL,
+    MODEL_TIER_RE as _MODEL_TIER_RE,
+)
+
+
+def _read_model_auto_switch() -> str:
+    """Read `model.auto_switch` from .agent-settings.yml.
+
+    Returns `auto` | `suggest` | `off`; default `suggest`. Only `auto` makes
+    the generator emit a native Claude `model:` key (ADR-034 § 4) — `suggest`
+    and `off` keep skills/commands as pure symlinks so the package never
+    silently overrides a user's explicit `/model` choice.
+    """
+    try:
+        from scripts._lib.agent_settings import load_agent_settings
+    except ImportError:  # pragma: no cover — script-style invocation
+        import sys as _sys
+        from pathlib import Path as _Path
+        _sys.path.insert(0, str(_Path(__file__).resolve().parent))
+        from _lib.agent_settings import load_agent_settings  # type: ignore[import-not-found]
+    data = load_agent_settings(project_path=SETTINGS_FILE)
+    model = data.get("model")
+    value = model.get("auto_switch") if isinstance(model, dict) else None
+    if isinstance(value, str) and value.strip().lower() in ("auto", "suggest", "off"):
+        return value.strip().lower()
+    return "suggest"
+
+
+# --- Pack-scoped projection (ADR-040 / road-to-6.0.0-B Step 8) ---------------
+
+
+def _read_projection_mode() -> str:
+    """Read `projection.mode` from .agent-settings.yml.
+
+    Returns `legacy-all` | `scoped`; default `legacy-all`. Only `scoped`
+    narrows the projected artefact set; `legacy-all` projects the full surface
+    byte-identically to 5.x. Scoping is opt-in by this key alone — never
+    inferred from `profile.id`.
+    """
+    try:
+        from scripts._lib.agent_settings import load_agent_settings
+    except ImportError:  # pragma: no cover — script-style invocation
+        import sys as _sys
+        from pathlib import Path as _Path
+        _sys.path.insert(0, str(_Path(__file__).resolve().parent))
+        from _lib.agent_settings import load_agent_settings  # type: ignore[import-not-found]
+    data = load_agent_settings(project_path=SETTINGS_FILE)
+    proj = data.get("projection")
+    value = proj.get("mode") if isinstance(proj, dict) else None
+    if isinstance(value, str) and value.strip().lower() in ("legacy-all", "scoped"):
+        return value.strip().lower()
+    return "legacy-all"
+
+
+def _domains_slug_prefix(pack_id: str) -> str:
+    """Return ``slug_prefix`` from ``PROJECT_ROOT/src/domains/<pack>/pack.yaml``.
+
+    PROJECT_ROOT-aware mirror of ``_lib.agent_src.pack_slug_prefix`` so tests
+    that monkey-patch ``condense.PROJECT_ROOT`` see their fixture's manifest.
+    Empty string = no prefix (the default). ADR-044 amendment A3.
+    """
+    manifest = PROJECT_ROOT / "src" / "domains" / pack_id / "pack.yaml"
+    if not manifest.is_file():
+        return ""
+    m = _SLUG_PREFIX_RE.search(manifest.read_text(encoding="utf-8"))
+    return m.group(1) if m else ""
+
+
+def _command_path_to_slug(manifest_path: str) -> str:
+    """Map a manifest command path to the flat generator slug.
+
+    `.../commands/council/analysis.md` → `council-analysis` — identical to
+    `_command_slug()` (which flattens the path relative to COMMANDS_SOURCE),
+    so the predicate matches what the generators emit.
+
+    Layout-agnostic: a 6.0.0-D domains command
+    (`src/domains/<pack>/council/analysis/command.md`) carries no literal
+    ``commands`` path segment, so derive the slug from the LOGICAL command
+    path (`commands/<subpath>.md`) via ``strip_source_prefix``. Falls back to
+    the literal-segment scan for already-logical / projection paths.
+    """
+    logical = strip_source_prefix(manifest_path)
+    if logical and logical.startswith("commands/"):
+        return "-".join(Path(logical[len("commands/"):]).with_suffix("").parts)
+    parts = Path(manifest_path).parts
+    i = parts.index("commands")
+    return "-".join(Path(*parts[i + 1:]).with_suffix("").parts)
+
+
+def _skill_path_to_name(manifest_path: str) -> str:
+    """Map a manifest skill path to its directory name.
+
+    `.../skills/accessibility-auditor/SKILL.md` → `accessibility-auditor` —
+    the key the skills generators iterate on.
+    """
+    parts = Path(manifest_path).parts
+    i = parts.index("skills")
+    return parts[i + 1]
+
+
+def _resolve_active_predicates() -> tuple[set[str] | None, set[str] | None]:
+    """Return `(active_command_slugs, active_skill_names)` for the projection.
+
+    `(None, None)` ⇒ legacy-all (no filtering — byte-identical to 5.x). In
+    `scoped` mode the selected packs are the active profile's `packs` UNIONED
+    with the `runtime.active_packs` overlay; the resolver expands that over the
+    `requires` graph and resolves the active command/skill set.
+    """
+    if _read_projection_mode() != "scoped":
+        return None, None
+    try:
+        from scripts.config import packs as packs_mod
+        from scripts.config import session_profiles as sp_mod
+        from scripts.config.profiles import resolve_profile
+        from scripts._lib.agent_settings import load_agent_settings
+    except ImportError:  # pragma: no cover — script-style invocation
+        import sys as _sys
+        _sys.path.insert(0, str(PROJECT_ROOT))
+        from scripts.config import packs as packs_mod  # type: ignore
+        from scripts.config import session_profiles as sp_mod  # type: ignore
+        from scripts.config.profiles import resolve_profile  # type: ignore
+        from scripts._lib.agent_settings import load_agent_settings  # type: ignore
+    settings = load_agent_settings(project_path=SETTINGS_FILE)
+    profile = resolve_profile(project_root=PROJECT_ROOT, user_settings=settings)
+    selected = sorted(set(profile.packs) | set(sp_mod.read_overlay(PROJECT_ROOT)))
+    active = packs_mod.resolve_active_set(PROJECT_ROOT, selected)
+    cmd_slugs = {_command_path_to_slug(p) for p in active.commands}
+    skill_names = {_skill_path_to_name(p) for p in active.skills}
+    return cmd_slugs, skill_names
+
+
+def _model_tier(skill_md: Path) -> str | None:
+    """Return the `model_tier` frontmatter value, or None if absent."""
+    if not skill_md.exists():
+        return None
+    text = skill_md.read_text(encoding="utf-8", errors="replace")
+    if not text.startswith("---\n"):
+        return None
+    end = text.find("\n---\n", 4)
+    if end == -1:
+        return None
+    m = _MODEL_TIER_RE.search(text[4:end])
+    return m.group(1) if m else None
+
+
+def _render_native_model_md(src_md: Path, tier: str) -> str:
+    """Rewrite the source `model_tier: <tier>` line to a native Claude
+    `model: <mapped>` key via the generator-owned mapping (ADR-035 § 3). The
+    rest of the SKILL.md is byte-identical."""
+    text = src_md.read_text(encoding="utf-8")
+    model = _TIER_TO_CLAUDE_MODEL[tier]
+    return _MODEL_TIER_RE.sub(f"model: {model}", text, count=1)
+
+
+def generate_claude_skills(active_skill_names: set[str] | None = None) -> int:
+    """Create .claude/skills/ entries for ALL skills in dist/agent-src/skills/.
+
+    Default: a directory symlink → dist/agent-src/skills/<name> (verbatim).
+    When `model.auto_switch: auto` AND a skill declares
+    `model_tier: lite|medium|high`, the entry becomes a real directory whose
+    sub-files are symlinked but whose SKILL.md is a rendered copy carrying a
+    native Claude `model:` key (ADR-034 Option (b) — only model-bearing skills
+    break the symlink). Idempotent: each entry is rebuilt from scratch.
+    """
+    if not SKILLS_SOURCE.exists():
+        print("  ⚠️  dist/agent-src/skills/ not found — skipping skills", file=sys.stderr)
+        return 0
+
+    # All skill directories in dist/agent-src/skills/. Under scoped projection
+    # (active_skill_names not None) keep only the active set; the stale-cleanup
+    # loop below then reaps any now-inactive skill entry.
+    skills = sorted([d.name for d in SKILLS_SOURCE.iterdir() if d.is_dir()])
+    if active_skill_names is not None:
+        skills = [s for s in skills if s in active_skill_names]
+    skill_set = set(skills)
+    # All command slugs (to protect from stale cleanup)
+    command_slugs = {slug for _, slug in _iter_commands()}
+
+    CLAUDE_SKILLS_DIR.mkdir(parents=True, exist_ok=True)
+    auto = _read_model_auto_switch() == "auto"
+
+    # Clean stale entries (symlinks AND rendered skill dirs) — but never touch
+    # command dirs (real dir whose SKILL.md is a symlink) or the README.
+    for item in CLAUDE_SKILLS_DIR.iterdir():
+        if item.name in skill_set or item.name in command_slugs or item.name == "README.md":
+            continue
+        if item.is_symlink():
+            item.unlink()
+        elif item.is_dir():
+            skill_md = item / "SKILL.md"
+            # A rendered skill dir has a *real* SKILL.md copy; a command dir has
+            # a SKILL.md *symlink* (left for generate_claude_commands to manage).
+            if skill_md.is_file() and not skill_md.is_symlink():
+                shutil.rmtree(item)
+
+    count = 0
+    rendered = 0
+    for skill in skills:
+        link = CLAUDE_SKILLS_DIR / skill
+        src_dir = SKILLS_SOURCE / skill
+        value = _model_tier(src_dir / "SKILL.md") if auto else None
+        # Rebuild from scratch for idempotency (symlink ↔ rendered-dir flips).
+        if link.is_symlink():
+            link.unlink()
+        elif link.is_dir():
+            shutil.rmtree(link)
+        elif link.exists():
+            link.unlink()
+        if value in _TIER_TO_CLAUDE_MODEL:
+            link.mkdir(parents=True)
+            for entry in sorted(src_dir.iterdir()):
+                if entry.name == "SKILL.md":
+                    (link / "SKILL.md").write_text(
+                        _render_native_model_md(entry, value), encoding="utf-8"
+                    )
+                else:
+                    (link / entry.name).symlink_to(
+                        Path("../../../dist/agent-src/skills") / skill / entry.name
+                    )
+            rendered += 1
+        else:
+            link.symlink_to(Path("../../dist/agent-src/skills") / skill)
+        count += 1
+
+    suffix = f" ({rendered} rendered with native model:)" if rendered else ""
+    info(f"  ✅  Created {count} skill entries in .claude/skills/{suffix}")
+    return count
+
+
+def extract_description_from_md(content: str) -> str:
+    """Extract description from first # heading or first non-empty line."""
+    for line in content.strip().split("\n"):
+        line = line.strip()
+        if line.startswith("# "):
+            return line[2:].strip()
+        if line and not line.startswith("#"):
+            return line[:120]
+    return ""
+
+
+def generate_claude_commands(active_command_slugs: set[str] | None = None) -> int:
+    """Create .claude/skills/{slug}/SKILL.md symlinks for ALL Augment commands.
+
+    Commands in dist/agent-src/commands/ are the single source of truth.
+    They must include name: and disable-model-invocation: true in frontmatter
+    (added once, then maintained as part of the command file).
+
+    Top-level commands use their filename stem as the slug. Nested
+    cluster commands (e.g. `commands/council/default.md`) are flattened
+    to `council-default` so directories never collide in `.claude/skills/`.
+    """
+    if not (PROJECT_ROOT / "src" / "domains").is_dir():
+        print("  ⚠️  src/domains/ not found — skipping commands", file=sys.stderr)
+        return 0
+
+    CLAUDE_SKILLS_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Collect skill names to avoid overwriting real skills with same-name commands
+    skill_names = set()
+    if SKILLS_SOURCE.exists():
+        skill_names = {d.name for d in SKILLS_SOURCE.iterdir() if d.is_dir()}
+
+    # Track current command slugs for stale-directory cleanup
+    current_slugs: set[str] = set()
+    count = 0
+    skipped = 0
+    rendered = 0
+    auto = _read_model_auto_switch() == "auto"
+    for source_file, slug in _iter_commands():
+        # Scoped projection: skip commands outside the active set. They are not
+        # added to current_slugs, so the stale-cleanup pass below reaps any
+        # existing dir for them (switch-down behaviour).
+        if active_command_slugs is not None and slug not in active_command_slugs:
+            continue
+        # Skip if a real skill with the same name exists — skill takes priority
+        if slug in skill_names:
+            skipped += 1
+            continue
+
+        current_slugs.add(slug)
+
+        # Create skill directory (real dir, SKILL.md symlinked or rendered)
+        skill_dir = CLAUDE_SKILLS_DIR / slug
+        skill_dir.mkdir(parents=True, exist_ok=True)
+
+        skill_file = skill_dir / "SKILL.md"
+        if skill_file.exists() or skill_file.is_symlink():
+            skill_file.unlink()
+
+        rel_path = source_file.relative_to(PROJECT_ROOT)
+        value = _model_tier(source_file) if auto else None
+        if value in _TIER_TO_CLAUDE_MODEL:
+            # Render a copy carrying the native Claude model: key (ADR-034).
+            skill_file.write_text(
+                _render_native_model_md(source_file, value), encoding="utf-8"
+            )
+            rendered += 1
+        else:
+            # Symlink: .claude/skills/{slug}/SKILL.md → ../../../src/domains/<pack>/<verb>/command.md
+            rel_target = Path("../../..") / rel_path
+            skill_file.symlink_to(rel_target)
+        count += 1
+
+    # Clean stale command skill directories — real dirs from removed commands.
+    # Only delete if the directory contains exactly the SKILL.md symlink we created.
+    removed_dirs = 0
+    for item in CLAUDE_SKILLS_DIR.iterdir():
+        if not item.is_dir() or item.is_symlink():
+            continue
+        if item.name in skill_names or item.name in current_slugs:
+            continue
+        skill_md = item / "SKILL.md"
+        # Stale command dir = exactly one SKILL.md, either symlinked (default)
+        # or a rendered copy (native-model command, ADR-034). Skill-render dirs
+        # are protected above (item.name in skill_names) and via the skills
+        # generator, so this only reaps removed commands.
+        if skill_md.is_symlink() or skill_md.is_file():
+            entries = list(item.iterdir())
+            if len(entries) == 1 and entries[0].name == "SKILL.md":
+                skill_md.unlink()
+                item.rmdir()
+                removed_dirs += 1
+
+    msg = f"  ✅  Created {count} command entries in .claude/skills/"
+    if rendered:
+        msg += f" ({rendered} rendered with native model:)"
+    if skipped:
+        msg += f" ({skipped} skipped — same-name skill exists)"
+    if removed_dirs:
+        msg += f" ({removed_dirs} stale dirs removed)"
+    info(msg)
+    return count
+
+
+def generate_plugin_command_skills() -> int:
+    """Mirror command-as-skill entries into the committed .claude-plugin/skills/.
+
+    The plugin marketplace references each command entry as a <slug>/SKILL.md
+    path that must be committed (git-consumed marketplace). Commands have no
+    such shape in source, so this projects them as symlinks:
+    .claude-plugin/skills/<slug>/SKILL.md → ../../../dist/agent-src/commands/<rel>.
+
+    Symlink-only by design: the committed .claude/skills/ shape was always
+    symlinks (ADR-034 model-rendered copies are local-only, never committed),
+    so the distributed marketplace behaviour is preserved exactly. The local
+    auto-discovery channel (.claude/skills/, gitignored) keeps model rendering
+    for the dev loop.
+    """
+    if not (PROJECT_ROOT / "src" / "domains").is_dir():
+        return 0
+
+    PLUGIN_SKILLS_DIR.mkdir(parents=True, exist_ok=True)
+
+    skill_names: set[str] = set()
+    if SKILLS_SOURCE.exists():
+        skill_names = {d.name for d in SKILLS_SOURCE.iterdir() if d.is_dir()}
+
+    current_slugs: set[str] = set()
+    count = 0
+    for source_file, slug in _iter_commands():
+        # A real skill of the same name takes priority — skip the command.
+        if slug in skill_names:
+            continue
+        current_slugs.add(slug)
+
+        skill_dir = PLUGIN_SKILLS_DIR / slug
+        skill_dir.mkdir(parents=True, exist_ok=True)
+        skill_file = skill_dir / "SKILL.md"
+        if skill_file.exists() or skill_file.is_symlink():
+            skill_file.unlink()
+
+        rel_path = source_file.relative_to(PROJECT_ROOT)
+        rel_target = Path("../../..") / rel_path
+        skill_file.symlink_to(rel_target)
+        count += 1
+
+    # Reap stale command dirs from removed commands (exactly one SKILL.md).
+    removed_dirs = 0
+    for item in PLUGIN_SKILLS_DIR.iterdir():
+        if not item.is_dir() or item.is_symlink():
+            continue
+        if item.name in current_slugs:
+            continue
+        skill_md = item / "SKILL.md"
+        if skill_md.is_symlink() or skill_md.is_file():
+            entries = list(item.iterdir())
+            if len(entries) == 1 and entries[0].name == "SKILL.md":
+                skill_md.unlink()
+                item.rmdir()
+                removed_dirs += 1
+
+    msg = f"  ✅  Created {count} command entries in .claude-plugin/skills/"
+    if removed_dirs:
+        msg += f" ({removed_dirs} stale dirs removed)"
+    info(msg)
+    return count
+
+
+def generate_persona_symlinks() -> int:
+    """Create symlink directories for personas (.claude/personas/, .cursor/personas/).
+
+    Symlinks each persona .md file from dist/agent-src/personas/ into tool-specific
+    directories. Excludes README.md — that's authoring documentation, not a persona.
+    """
+    if not PERSONAS_SOURCE.exists():
+        print("  ⚠️  dist/agent-src/personas/ not found — skipping personas")
+        return 0
+
+    personas = sorted([
+        f.name for f in PERSONAS_SOURCE.glob("*.md") if f.stem != "README"
+    ])
+    tool_dirs = _filter_tool_dirs(PERSONA_TOOL_DIRS)
+    total = 0
+    for tool_dir, rel_prefix in tool_dirs.items():
+        target_dir = PROJECT_ROOT / tool_dir
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        # Clean stale symlinks
+        for item in target_dir.iterdir():
+            if item.is_symlink() and item.name not in personas and item.name != "README.md":
+                item.unlink()
+
+        for persona in personas:
+            link = target_dir / persona
+            target = Path(rel_prefix) / persona
+            if link.exists() or link.is_symlink():
+                link.unlink()
+            link.symlink_to(target)
+            total += 1
+
+    info(f"  ✅  Created {total} persona symlinks across {len(tool_dirs)} tool directories ({len(personas)} personas each)")
+    return total
+
+
+def generate_user_type_symlinks() -> int:
+    """Create symlink directories for user-types (.claude/user-types/, .cursor/user-types/).
+
+    Symlinks each user-type .md file from dist/agent-src/user-types/ into tool-specific
+    directories. Excludes README.md and _template/ — those are authoring scaffolding,
+    not user-type lenses.
+    """
+    if not USER_TYPES_SOURCE.exists():
+        print("  ⚠️  dist/agent-src/user-types/ not found — skipping user-types")
+        return 0
+
+    user_types = sorted([
+        f.name for f in USER_TYPES_SOURCE.glob("*.md") if f.stem != "README"
+    ])
+    tool_dirs = _filter_tool_dirs(USER_TYPE_TOOL_DIRS)
+    total = 0
+    for tool_dir, rel_prefix in tool_dirs.items():
+        target_dir = PROJECT_ROOT / tool_dir
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        # Clean stale symlinks
+        for item in target_dir.iterdir():
+            if item.is_symlink() and item.name not in user_types and item.name != "README.md":
+                item.unlink()
+
+        for user_type in user_types:
+            link = target_dir / user_type
+            target = Path(rel_prefix) / user_type
+            if link.exists() or link.is_symlink():
+                link.unlink()
+            link.symlink_to(target)
+            total += 1
+
+    info(f"  ✅  Created {total} user-type symlinks across {len(tool_dirs)} tool directories ({len(user_types)} user-types each)")
+    return total
+
+
+def generate_plugin_hooks() -> int:
+    """Generate ``hooks/hooks.json`` at the plugin root from the hook manifest.
+
+    Claude Code plugins auto-discover hooks at ``<plugin-root>/hooks/hooks.json``
+    (Plugins reference). The agent-config plugin's source is the repo root
+    (``.claude-plugin/marketplace.json``), so the file lands at
+    ``PROJECT_ROOT/hooks/hooks.json``.
+
+    Delivering the Claude lifecycle hooks via **plugin scope** — instead of
+    writing them into the shared ``.claude/settings.json`` ``hooks`` array —
+    means no shared ``hooks`` array in any settings file, so there is no
+    collision with a neighbour tool's hooks or with a developer's
+    ``settings.local.json``. Claude Code merges plugin-scope and
+    settings-scope hooks and dedups by command string.
+
+    The command resolves the binary project-local-first
+    (``$CLAUDE_PROJECT_DIR/agent-config`` when executable — maintainer dev-loop)
+    and falls back to ``agent-config`` on PATH (global-only consumer per
+    ADR-020, where the repo carries no wrapper). It always passes
+    ``--project-dir "$CLAUDE_PROJECT_DIR"`` so a globally resolved binary still
+    scans the project the event fired in. The universal dispatcher then reads
+    ``scripts/hook_manifest.yaml`` at runtime to fan out to the active
+    concerns (each a no-op when its feature is disabled).
+    """
+    manifest_path = PROJECT_ROOT / "src" / "scripts" / "hook_manifest.yaml"
+    if not manifest_path.exists():
+        print("  ⚠️  scripts/hook_manifest.yaml not found — skipping plugin hooks",
+              file=sys.stderr)
+        return 0
+
+    manifest = yaml.safe_load(manifest_path.read_text(encoding="utf-8")) or {}
+    hook_spec = manifest.get("schema_version", 1)
+    claude_events = manifest.get("platforms", {}).get("claude", {}) or {}
+    aliases = manifest.get("native_event_aliases", {}).get("claude", {}) or {}
+    # Reverse the native→agent-config map so we can emit native event names.
+    ac_to_native = {ac: native for native, ac in aliases.items()}
+
+    hooks: dict[str, list] = {}
+    for ac_event, concerns in claude_events.items():
+        if not concerns:
+            continue
+        native = ac_to_native.get(ac_event)
+        if native is None:
+            continue
+        # Resolve the binary project-local-first, PATH-fallback: a maintainer
+        # dev-loop (or any repo carrying a project-local wrapper) uses its own
+        # ./agent-config; a global-only consumer (ADR-020 — nothing in the
+        # repo) falls back to the globally-installed `agent-config` on PATH.
+        # Either way pass --project-dir "$CLAUDE_PROJECT_DIR" so a globally
+        # resolved binary still scans the project the event fired in.
+        command = (
+            'BIN="$CLAUDE_PROJECT_DIR/agent-config"; [ -x "$BIN" ] || BIN=agent-config; '
+            f'"$BIN" dispatch:hook --platform claude --event {ac_event} '
+            f'--native-event {native} --project-dir "$CLAUDE_PROJECT_DIR" '
+            f'--min-version {hook_spec}'
+        )
+        hooks[native] = [{"hooks": [{"type": "command", "command": command}]}]
+
+    hooks_dir = PROJECT_ROOT / "hooks"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+    out = hooks_dir / "hooks.json"
+    out.write_text(json.dumps({"hooks": hooks}, indent=2) + "\n", encoding="utf-8")
+    info(f"  ✅  Generated hooks/hooks.json ({len(hooks)} Claude plugin hooks)")
+    return len(hooks)
+
+
+def _generate_tools_inner(
+    cmd_slugs: set[str] | None, skill_names: set[str] | None
+) -> None:
+    """Run every tool generator once. `cmd_slugs` / `skill_names` are `None`
+    for legacy-all (full surface) or allowlists for scoped projection. Only the
+    four consumer-local native generators honour the allowlists; the committed
+    plugin marketplace (`.claude-plugin/`) and the Augment tree always project
+    the full set in 6.0.0 (ADR-040 / road-to-6.0.0-B Step 8, D3)."""
+    info("🔧  Generating multi-agent tool directories...\n")
+    rules = generate_rule_symlinks()
+    windsurfrules = generate_windsurfrules() if _tool_active("windsurf") else 0
+    if _tool_active("gemini"):
+        generate_gemini_md()
+    skills = generate_claude_skills(skill_names) if _tool_active("claude-code") else 0
+    commands = generate_claude_commands(cmd_slugs) if _tool_active("claude-code") else 0
+    plugin_cmd_skills = generate_plugin_command_skills() if _tool_active("claude-code") else 0
+    plugin_hooks = generate_plugin_hooks() if _tool_active("claude-code") else 0
+    personas = generate_persona_symlinks()
+    user_types = generate_user_type_symlinks()
+    cursor_mdc = generate_cursor_mdc_rules() if _tool_active("cursor") else 0
+    windsurf_modern = generate_windsurf_modern_rules() if _tool_active("windsurf") else 0
+    cursor_cmds = generate_cursor_commands(cmd_slugs) if _tool_active("cursor") else 0
+    windsurf_wf = generate_windsurf_workflows(cmd_slugs) if _tool_active("windsurf") else 0
+    summary = (
+        f"✅  generate-tools — rules={rules} skills={skills} "
+        f"commands={commands} plugin_cmd_skills={plugin_cmd_skills} "
+        f"plugin_hooks={plugin_hooks} "
+        f"personas={personas} user_types={user_types} "
+        f"cursor_mdc={cursor_mdc} windsurf_rules={windsurf_modern} "
+        f"cursor_commands={cursor_cmds} windsurf_workflows={windsurf_wf} "
+        f"windsurfrules={windsurfrules}"
+    )
+    if resolve_level() == "verbose":
+        print(f"\n{summary}")
+    else:
+        success(summary)
+        flush_summary()
+
+
+def generate_tools() -> None:
+    """Generate all tool-specific directories and files.
+
+    `agents/.agent-tools.yml` gates per-tool emission. When the file
+    is missing, every tool is emitted (preserves test fixtures and
+    pre-gating behaviour). See `_active_tools()` and `_tool_active()`.
+
+    Honours `projection.mode` (ADR-040): `legacy-all` (default) projects the
+    full surface; `scoped` projects only the active profile + packs. A failed
+    scoped projection restores the full (legacy-all) tree so the host tool is
+    never left with a partial set, then re-raises.
+    """
+    cmd_slugs, skill_names = _resolve_active_predicates()
+    scoped = cmd_slugs is not None
+    try:
+        _generate_tools_inner(cmd_slugs, skill_names)
+    except Exception:
+        if scoped:
+            info("  ⚠️  scoped projection failed — restoring full (legacy-all) projection")
+            _generate_tools_inner(None, None)
+        raise
+    if not scoped:
+        info(
+            "  ℹ️  Profile mode available — focused surface. "
+            "Run `agent-config use --profile=developer`."
+        )
+
+
+# ── .augment/ projection ──────────────────────────────────────────────
+# The package uses dist/agent-src/ as the tool-agnostic condensed source of truth.
+# .augment/ is a generated projection so that Augment Code (which reads from
+# .augment/) works on the package repo itself. Rules default to copies
+# because Augment Code historically does not load symlinked rule files;
+# flip augment.rules_use_symlinks: true in .agent-settings.yml to switch
+# them to symlinks (everything else is always symlinked).
+
+# Subdirectories of dist/agent-src/ that map into .augment/ as symlinks.
+AUGMENT_SYMLINK_DIRS = ("skills", "commands", "guidelines", "personas", "user-types", "templates", "contexts", "scripts")
+# Top-level files to symlink into .augment/ (README, etc.)
+AUGMENT_SYMLINK_FILES = ("README.md",)
+
+
+def project_to_augment() -> None:
+    """Mirror dist/agent-src/ into .augment/. Symlink everything except rules,
+    which default to copies; opt into rule symlinks via
+    augment.rules_use_symlinks in .agent-settings.yml."""
+    if not TARGET_DIR.exists():
+        print(f"  ⚠️  {TARGET_DIR.name}/ not found — nothing to project")
+        return
+
+    AUGMENT_DIR.mkdir(parents=True, exist_ok=True)
+
+    use_symlinks = _read_augment_rules_use_symlinks()
+
+    # Rules: copy by default (Augment Code historically does not load
+    # symlinked rules), or symlink when augment.rules_use_symlinks is true.
+    src_rules = TARGET_DIR / "rules"
+    dst_rules = AUGMENT_DIR / "rules"
+    dst_rules.mkdir(parents=True, exist_ok=True)
+    existing = {f.name for f in dst_rules.iterdir() if f.is_file() or f.is_symlink()}
+    current = set()
+    written = 0
+    if src_rules.exists():
+        for rule in sorted(src_rules.glob("*.md")):
+            target = dst_rules / rule.name
+            # Always remove first to avoid copy↔symlink mode mismatch.
+            if target.is_symlink() or target.exists():
+                target.unlink()
+            if use_symlinks:
+                target.symlink_to(Path("..") / ".." / "dist/agent-src" / "rules" / rule.name)
+            else:
+                shutil.copy2(rule, target)
+            current.add(rule.name)
+            written += 1
+    # Remove stale rule files
+    removed_rules = 0
+    for name in existing - current:
+        (dst_rules / name).unlink()
+        removed_rules += 1
+    mode_label = "Symlinked" if use_symlinks else "Copied"
+    print(f"  ✅  {mode_label} {written} rules to .augment/rules/" + (f" ({removed_rules} stale removed)" if removed_rules else ""))
+
+    # Subdirectories: replace each with a symlink → ../dist/agent-src/<subdir>
+    for sub in AUGMENT_SYMLINK_DIRS:
+        dst = AUGMENT_DIR / sub
+        if dst.is_symlink() or dst.exists():
+            if dst.is_dir() and not dst.is_symlink():
+                shutil.rmtree(dst)
+            else:
+                dst.unlink()
+        src = TARGET_DIR / sub
+        if src.exists():
+            dst.symlink_to(Path("..") / "dist/agent-src" / sub, target_is_directory=True)
+            print(f"  ✅  Symlinked .augment/{sub} → ../dist/agent-src/{sub}")
+
+    # Top-level files: symlink
+    for name in AUGMENT_SYMLINK_FILES:
+        dst = AUGMENT_DIR / name
+        src = TARGET_DIR / name
+        if dst.is_symlink() or dst.exists():
+            dst.unlink()
+        if src.exists():
+            dst.symlink_to(Path("..") / "dist/agent-src" / name)
+            print(f"  ✅  Symlinked .augment/{name} → ../dist/agent-src/{name}")
+
+    # Cleanup: remove any stray top-level entries in .augment/ that are no longer projected.
+    # `state` holds runtime state files written by hooks (onboarding-gate,
+    # context-hygiene, …) and must survive sync — it is regenerated by
+    # the next hook fire, not by condense.
+    known = set(AUGMENT_SYMLINK_DIRS) | set(AUGMENT_SYMLINK_FILES) | {"rules", "state"}
+    for item in AUGMENT_DIR.iterdir():
+        if item.name in known:
+            continue
+        if item.is_symlink() or item.is_file():
+            item.unlink()
+            print(f"  🗑️  Removed stale .augment/{item.name}")
+        elif item.is_dir():
+            shutil.rmtree(item)
+            print(f"  🗑️  Removed stale .augment/{item.name}/")
+
+
+def clean_tools() -> None:
+    """Remove all generated tool directories and files."""
+    import shutil as _shutil
+    targets = [
+        PROJECT_ROOT / ".claude",
+        PROJECT_ROOT / ".cursor",
+        PROJECT_ROOT / ".clinerules",
+        PROJECT_ROOT / ".windsurf",
+        PROJECT_ROOT / ".windsurfrules",
+        PROJECT_ROOT / "GEMINI.md",
+    ]
+    for t in targets:
+        if t.is_dir():
+            _shutil.rmtree(t)
+            print(f"  🗑️  Removed {t.relative_to(PROJECT_ROOT)}")
+        elif t.exists() or t.is_symlink():
+            t.unlink()
+            print(f"  🗑️  Removed {t.relative_to(PROJECT_ROOT)}")
+    print("✅  All generated tool files cleaned")
+
+
+
+def main() -> None:
+    # Multi-root awareness (ADR-017): tolerate a missing legacy
+    # `.agent-src.uncondensed/` as long as at least one package-scoped
+    # source root carries artefacts.
+    if not SOURCE_DIR.exists() and not _any_source_root_exists():
+        print(f"❌  No source directory found (looked at {SOURCE_DIR} and packages/*/.agent-src.uncondensed)")
+        sys.exit(1)
+
+    arg = sys.argv[1] if len(sys.argv) > 1 else "--sync"
+
+    if arg == "--list":
+        files = list_md_files(SOURCE_DIR)
+        print(f"📄  {len(files)} .md files total:\n")
+        for f in files:
+            print(f"  {f}")
+
+    elif arg == "--changed":
+        changed = list_changed_md(SOURCE_DIR)
+        if not changed:
+            print("✅  No .md files changed since last condensation")
+            sys.exit(0)
+        print(f"📝  {len(changed)} .md files changed since last condensation:\n")
+        for f in changed:
+            print(f"  {f}")
+
+    elif arg == "--mark-done":
+        if len(sys.argv) < 3:
+            print("Usage: python scripts/condense.py --mark-done <relative-path>")
+            sys.exit(1)
+        mark_done(sys.argv[2])
+
+    elif arg == "--mark-all-done":
+        mark_all_done()
+
+    elif arg == "--check":
+        missing, stale = check_sync(SOURCE_DIR, TARGET_DIR)
+        if not missing and not stale:
+            print("✅  dist/agent-src/ is in sync with .agent-src.uncondensed/")
+            sys.exit(0)
+        if missing:
+            print(f"❌  Missing in dist/agent-src/ ({len(missing)}):")
+            for f in missing:
+                print(f"  {f}")
+        if stale:
+            print(f"❌  Stale in dist/agent-src/ ({len(stale)}):")
+            for f in stale:
+                print(f"  {f}")
+        print(f"\nRun 'task sync' to fix non-.md files, then ask the agent to condense .md files.")
+        sys.exit(1)
+
+    elif arg == "--sync":
+        print(f"Source: {SOURCE_DIR}")
+        print(f"Target: {TARGET_DIR}\n")
+        print("--- Syncing non-.md files ---")
+        copied = sync_non_md(SOURCE_DIR, TARGET_DIR)
+        print(f"\n--- Cleanup stale files ---")
+        deleted = cleanup_stale(SOURCE_DIR, TARGET_DIR)
+        # Also cleanup stale hashes (multi-root aware — resolve against
+        # every artefact root, not just the legacy SOURCE_DIR).
+        hashes = load_hashes()
+        stale_keys = [k for k in hashes if _resolve_source(k) is None]
+        for k in stale_keys:
+            del hashes[k]
+        if stale_keys:
+            save_hashes(hashes)
+            print(f"  Cleaned {len(stale_keys)} stale hash entries")
+        changed = list_changed_md(SOURCE_DIR)
+        print(f"\n✅  Done: {copied} copied, {deleted} stale deleted")
+        if changed:
+            print(f"📝  {len(changed)} .md files need condensation (run --changed to see them)")
+        else:
+            print(f"✅  All .md files are up to date")
+        print(f"\n--- Projecting dist/agent-src/ → .augment/ ---")
+        project_to_augment()
+
+    elif arg == "--check-hashes":
+        has_issues = False
+        changed = list_changed_md(SOURCE_DIR)
+        stale = find_stale_hashes(SOURCE_DIR)
+
+        if stale:
+            has_issues = True
+            print(f"⚠️  {len(stale)} stale hash(es) for deleted source files:\n")
+            for f in stale:
+                print(f"  {f}")
+            print(f"\nRun 'task sync-clean-hashes' to remove them.\n")
+
+        if changed:
+            has_issues = True
+            print(f"❌  {len(changed)} .md file(s) need recondensation:\n")
+            for f in changed:
+                stored = load_hashes().get(f)
+                reason = "no hash stored" if stored is None else "hash mismatch"
+                print(f"  {f}  ({reason})")
+            print(f"\nRun '/condense' command to recondense these files.")
+
+        if not has_issues:
+            print("✅  All condensation hashes are clean (no stale, no mismatches)")
+            sys.exit(0)
+        sys.exit(1)
+
+    elif arg == "--clean-hashes":
+        count = clean_stale_hashes(SOURCE_DIR)
+        if count:
+            print(f"✅  Removed {count} stale hash(es)")
+        else:
+            print("✅  No stale hashes found")
+
+    elif arg == "--generate-tools":
+        generate_tools()
+
+    elif arg == "--clean-tools":
+        clean_tools()
+
+    elif 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]")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()