@event4u/agent-config 1.16.0 → 1.17.0

package/scripts/command_suggester/loader.py

@@ -26,7 +26,10 @@ def load_commands(commands_dir: Path) -> list[CommandSpec]:
     this loader.
     """
     specs: list[CommandSpec] = []
-    for path in sorted(commands_dir.glob("*.md")):
+    for path in sorted(commands_dir.rglob("*.md")):
+        # Skip cluster authoring docs — not commands.
+        if path.name == "AGENTS.md":
+            continue
         text = path.read_text(encoding="utf-8")
         data, _offset = parse_frontmatter(text)
         if data is None:

package/scripts/compress.py

@@ -312,6 +312,29 @@ def generate_gemini_md() -> None:
     print("  ✅  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 `.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 .md file (recursive)."""
+    if not COMMANDS_SOURCE.exists():
+        return
+    for source_file in sorted(COMMANDS_SOURCE.rglob("*.md")):
+        # Skip the cluster AGENTS.md authoring doc (not a command).
+        if source_file.name == "AGENTS.md":
+            continue
+        yield source_file, _command_slug(source_file)
+
+
 def generate_claude_skills() -> None:
     """Create .claude/skills/ symlinks for ALL skills in .agent-src/skills/.
     """
@@ -321,16 +344,14 @@ def generate_claude_skills() -> None:
 
     # All skill directories in .agent-src/skills/
     skills = sorted([d.name for d in SKILLS_SOURCE.iterdir() if d.is_dir()])
-    # All command names (to protect from stale cleanup)
-    command_names = set()
-    if COMMANDS_SOURCE.exists():
-        command_names = {f.stem for f in COMMANDS_SOURCE.glob("*.md")}
+    # 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)
 
     # Clean stale symlinks (but not converted commands or README)
     for item in CLAUDE_SKILLS_DIR.iterdir():
-        if item.is_symlink() and item.name not in skills and item.name not in command_names and item.name != "README.md":
+        if item.is_symlink() and item.name not in skills and item.name not in command_slugs and item.name != "README.md":
             item.unlink()
 
     count = 0
@@ -357,11 +378,15 @@ def extract_description_from_md(content: str) -> str:
 
 
 def generate_claude_commands() -> None:
-    """Create .claude/skills/{name}/SKILL.md symlinks for ALL Augment commands.
+    """Create .claude/skills/{slug}/SKILL.md symlinks for ALL Augment commands.
 
     Commands in .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 COMMANDS_SOURCE.exists():
         print("  ⚠️  .agent-src/commands/ not found — skipping commands")
@@ -374,32 +399,53 @@ def generate_claude_commands() -> None:
     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
-    for source_file in sorted(COMMANDS_SOURCE.glob("*.md")):
-        name = source_file.stem
-
+    for source_file, slug in _iter_commands():
         # Skip if a real skill with the same name exists — skill takes priority
-        if name in skill_names:
+        if slug in skill_names:
             skipped += 1
             continue
 
+        current_slugs.add(slug)
+
         # Create skill directory (real dir, symlinked SKILL.md inside)
-        skill_dir = CLAUDE_SKILLS_DIR / name
+        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()
 
-        # Symlink: .claude/skills/{name}/SKILL.md → ../../../.agent-src/commands/{name}.md
-        rel_target = Path("../../../.agent-src/commands") / source_file.name
+        # Symlink: .claude/skills/{slug}/SKILL.md → ../../../.agent-src/commands/<rel-path>
+        rel_path = source_file.relative_to(COMMANDS_SOURCE)
+        rel_target = Path("../../../.agent-src/commands") / 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"
+        if skill_md.is_symlink():
+            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 symlinks in .claude/skills/"
     if skipped:
         msg += f" ({skipped} skipped — same-name skill exists)"
+    if removed_dirs:
+        msg += f" ({removed_dirs} stale dirs removed)"
     print(msg)
 
 

package/scripts/generate_index.py

@@ -95,7 +95,10 @@ def _collect_rules() -> list[Entry]:
 
 def _collect_commands() -> list[Entry]:
     out = []
-    for cmd_md in sorted((SRC / "commands").glob("*.md")):
+    cmd_dir = SRC / "commands"
+    for cmd_md in sorted(cmd_dir.rglob("*.md")):
+        if cmd_md.name == "AGENTS.md":
+            continue
         fm = _parse_frontmatter(cmd_md.read_text(encoding="utf-8"))
         is_shim = bool(fm.get("superseded_by"))
         extra = ""
@@ -103,12 +106,13 @@ def _collect_commands() -> list[Entry]:
             extra = f"shim → /{fm['superseded_by']}"
         elif fm.get("cluster"):
             extra = f"cluster: {fm['cluster']}"
+        rel = cmd_md.relative_to(cmd_dir)
         out.append(Entry(
             kind="shim" if is_shim else "command",
             name=fm.get("name") or cmd_md.stem,
             description=_truncate(fm.get("description", "")),
             extra=extra,
-            path=f".agent-src.uncompressed/commands/{cmd_md.name}",
+            path=f".agent-src.uncompressed/commands/{rel}",
         ))
     return out
 

package/scripts/generate_ownership_matrix.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""Generate the file-ownership matrix.
+
+Produces:
+
+  * docs/contracts/file-ownership-matrix.json (machine, internal-locked)
+  * agents/contexts/structural/file-ownership-matrix.md (human-readable)
+
+Walks `.agent-src.uncompressed/{rules,skills,commands,contexts,personas}/`,
+parses frontmatter for `load_context:` / `load_context_eager:`, scans
+markdown bodies for inline links to `.md` files inside the scanned roots,
+and emits READ_ONLY edges plus depth-2 transitive closure of load_context
+chains. Depth-3 chains abort the build (matches the 0.2.4 nesting cap).
+
+Contract: docs/contracts/file-ownership-matrix.md
+Roadmap:  road-to-structural-optimization.md § 0.1
+
+Modes:
+  --check      Regenerate to memory and diff against committed JSON.
+               Exit 0 if identical, 1 if drifted.
+  (default)    Regenerate JSON + MD in place; exit 0 on success.
+
+Exit codes: 0 = ok, 1 = drift (--check), 2 = depth-3 chain, 3 = internal.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable
+
+import yaml
+
+ROOT = Path(__file__).resolve().parent.parent
+SRC_ROOT = ROOT / ".agent-src.uncompressed"
+
+SCAN_DIRS = ("rules", "skills", "commands", "contexts", "personas")
+
+JSON_OUT = ROOT / "docs" / "contracts" / "file-ownership-matrix.json"
+MD_OUT = ROOT / "agents" / "contexts" / "structural" / "file-ownership-matrix.md"
+
+LINK_RE = re.compile(r"\]\(([^)]+\.md)(?:#[^)]*)?\)")
+
+
+@dataclass
+class FileEntry:
+    path: str
+    kind: str
+    rule_type: str | None = None
+    load_context: list[str] = field(default_factory=list)
+    load_context_eager: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Edge:
+    source: str
+    target: str
+    type: str
+    via: str
+    depth: int
+
+
+def _rel(p: Path) -> str:
+    return p.relative_to(ROOT).as_posix()
+
+
+def _kind_for(rel: str) -> str:
+    parts = rel.split("/")
+    if len(parts) >= 3 and parts[0] == ".agent-src.uncompressed":
+        return parts[1].rstrip("s") if parts[1] != "personas" else "persona"
+    return "unknown"
+
+
+def _parse_frontmatter(p: Path) -> dict:
+    text = p.read_text(encoding="utf-8")
+    if not text.startswith("---\n"):
+        return {}
+    end = text.find("\n---\n", 4)
+    if end == -1:
+        return {}
+    try:
+        data = yaml.safe_load(text[4:end])
+    except yaml.YAMLError:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _collect_files(src_root: Path) -> list[Path]:
+    out: list[Path] = []
+    for sub in SCAN_DIRS:
+        d = src_root / sub
+        if d.exists():
+            out.extend(sorted(d.rglob("*.md")))
+    return out
+
+
+def _resolve(target: str, src_root: Path) -> Path | None:
+    """Resolve a path string (repo-relative or short) into an absolute Path
+    under src_root or the repo root. Return None if not under a scanned root."""
+    cand = src_root.parent / target if "/" in target else src_root / target
+    try:
+        rel = cand.resolve().relative_to(src_root.parent)
+    except ValueError:
+        return None
+    parts = rel.parts
+    if len(parts) >= 3 and parts[0] == ".agent-src.uncompressed" and parts[1] in SCAN_DIRS:
+        return cand if cand.exists() else None
+    return None
+
+
+def build_matrix(src_root: Path) -> tuple[dict[str, FileEntry], list[Edge], list[str]]:
+    """Build the file map + edge list. Returns (files, edges, depth3_chains).
+
+    depth3_chains is non-empty iff the depth invariant is violated; the
+    caller must abort with exit code 2.
+    """
+    files: dict[str, FileEntry] = {}
+    for f in _collect_files(src_root):
+        rel = f.relative_to(src_root.parent).as_posix()
+        fm = _parse_frontmatter(f)
+        rtype = fm.get("type")
+        if isinstance(rtype, str):
+            rtype = rtype.strip('"').strip("'")
+        else:
+            rtype = None
+        lazy = fm.get("load_context") or []
+        eager = fm.get("load_context_eager") or []
+        if not isinstance(lazy, list):
+            lazy = []
+        if not isinstance(eager, list):
+            eager = []
+        files[rel] = FileEntry(
+            path=rel,
+            kind=_kind_for(rel),
+            rule_type=rtype,
+            load_context=[str(x) for x in lazy if isinstance(x, str)],
+            load_context_eager=[str(x) for x in eager if isinstance(x, str)],
+        )
+
+    edges: list[Edge] = []
+    for rel, entry in files.items():
+        for tgt in entry.load_context:
+            edges.append(Edge(rel, tgt, "READ_ONLY", "load_context", 1))
+        for tgt in entry.load_context_eager:
+            edges.append(Edge(rel, tgt, "READ_ONLY", "load_context_eager", 1))
+
+    # Body markdown links — only count edges to files we know about
+    for rel, entry in files.items():
+        body = (src_root.parent / rel).read_text(encoding="utf-8")
+        body = body.split("\n---\n", 1)[-1] if body.startswith("---\n") else body
+        seen_targets: set[str] = set()
+        for m in LINK_RE.finditer(body):
+            href = m.group(1).strip()
+            if href.startswith("http"):
+                continue
+            resolved = _resolve_link(rel, href, src_root)
+            if resolved is None or resolved == rel or resolved in seen_targets:
+                continue
+            if resolved in files:
+                seen_targets.add(resolved)
+                edges.append(Edge(rel, resolved, "READ_ONLY", "body_link", 1))
+
+    # Transitive closure on load_context* edges, depth 2; depth 3 aborts.
+    lc_edges_by_src: dict[str, list[str]] = {}
+    for e in edges:
+        if e.via in ("load_context", "load_context_eager"):
+            lc_edges_by_src.setdefault(e.source, []).append(e.target)
+
+    transitive: list[Edge] = []
+    depth3: list[str] = []
+    for src, lvl1_targets in lc_edges_by_src.items():
+        for t1 in lvl1_targets:
+            for t2 in lc_edges_by_src.get(t1, []):
+                if t2 == src or t2 == t1:
+                    continue
+                transitive.append(Edge(src, t2, "READ_ONLY", "load_context_transitive", 2))
+                # depth-3 probe
+                for t3 in lc_edges_by_src.get(t2, []):
+                    if t3 in (src, t1, t2):
+                        continue
+                    depth3.append(f"{src} → {t1} → {t2} → {t3}")
+
+    edges.extend(transitive)
+    for rel in files:
+        edges.append(Edge(rel, rel, "WRITE", "self", 0))
+
+    edges.sort(key=lambda e: (e.source, e.target, e.via, e.depth))
+    return files, edges, depth3
+
+
+def _resolve_link(source_rel: str, href: str, src_root: Path) -> str | None:
+    """Resolve a markdown link href (relative to source file) to a repo-relative
+    path inside a scanned root, or None."""
+    if href.startswith(".agent-src.uncompressed/") or href.startswith("agents/"):
+        cand = (src_root.parent / href).resolve()
+    else:
+        base = (src_root.parent / source_rel).parent
+        cand = (base / href).resolve()
+    try:
+        rel = cand.relative_to(src_root.parent).as_posix()
+    except ValueError:
+        return None
+    parts = rel.split("/")
+    if len(parts) >= 3 and parts[0] == ".agent-src.uncompressed" and parts[1] in SCAN_DIRS:
+        return rel if cand.exists() else None
+    return None
+
+
+def _to_json(files: dict[str, FileEntry], edges: list[Edge]) -> dict:
+    return {
+        "version": 1,
+        "generated_by": "scripts/generate_ownership_matrix.py",
+        "source_of_truth": ".agent-src.uncompressed/",
+        "files": {
+            rel: {
+                "kind": e.kind,
+                "rule_type": e.rule_type,
+                "load_context": e.load_context,
+                "load_context_eager": e.load_context_eager,
+            }
+            for rel, e in sorted(files.items())
+        },
+        "edges": [
+            {
+                "source": e.source,
+                "target": e.target,
+                "type": e.type,
+                "via": e.via,
+                "depth": e.depth,
+            }
+            for e in edges
+        ],
+    }
+
+
+def _to_markdown(payload: dict) -> str:
+    lines: list[str] = [
+        "# File-ownership matrix (regenerated)",
+        "",
+        "> **Do not edit.** Regenerated by `scripts/generate_ownership_matrix.py`.",
+        "> Schema: [`docs/contracts/file-ownership-matrix.md`](../../../docs/contracts/file-ownership-matrix.md).",
+        "",
+        f"- Schema version: `{payload['version']}`",
+        f"- Source of truth: `{payload['source_of_truth']}`",
+        f"- Files indexed: **{len(payload['files'])}**",
+        f"- Edges (incl. self-WRITE): **{len(payload['edges'])}**",
+        "",
+        "## READ_ONLY edges",
+        "",
+        "| Source | Target | Via | Depth |",
+        "|---|---|---|---:|",
+    ]
+    ro = [e for e in payload["edges"] if e["type"] == "READ_ONLY"]
+    for e in ro:
+        lines.append(f"| `{e['source']}` | `{e['target']}` | `{e['via']}` | {e['depth']} |")
+    if not ro:
+        lines.append("| _(none)_ |  |  |  |")
+    lines += [
+        "",
+        "## Files by kind",
+        "",
+        "| Kind | Count |",
+        "|---|---:|",
+    ]
+    counts: dict[str, int] = {}
+    for f in payload["files"].values():
+        counts[f["kind"]] = counts.get(f["kind"], 0) + 1
+    for k in sorted(counts):
+        lines.append(f"| `{k}` | {counts[k]} |")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _write_outputs(payload: dict, json_out: Path, md_out: Path) -> None:
+    json_out.parent.mkdir(parents=True, exist_ok=True)
+    md_out.parent.mkdir(parents=True, exist_ok=True)
+    json_out.write_text(json.dumps(payload, indent=2, sort_keys=False) + "\n", encoding="utf-8")
+    md_out.write_text(_to_markdown(payload) + "\n", encoding="utf-8")
+
+
+def main(argv: Iterable[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--check", action="store_true",
+                    help="Regenerate to memory and diff against committed JSON.")
+    args = ap.parse_args(list(argv) if argv is not None else None)
+
+    if not SRC_ROOT.is_dir():
+        print(f"❌  source dir missing: {SRC_ROOT}", file=sys.stderr)
+        return 3
+
+    files, edges, depth3 = build_matrix(SRC_ROOT)
+    if depth3:
+        print("❌  load_context depth-3 chain detected (limit is 2):", file=sys.stderr)
+        for chain in depth3:
+            print(f"  🔴 {chain}", file=sys.stderr)
+        return 2
+
+    payload = _to_json(files, edges)
+
+    if args.check:
+        if not JSON_OUT.exists():
+            print(f"❌  {JSON_OUT.relative_to(ROOT)} not committed; run `task generate-ownership-matrix`",
+                  file=sys.stderr)
+            return 1
+        committed = json.loads(JSON_OUT.read_text(encoding="utf-8"))
+        if committed != payload:
+            print("❌  ownership matrix is stale — run `task generate-ownership-matrix` and commit",
+                  file=sys.stderr)
+            return 1
+        print(f"✅  ownership matrix in sync ({len(files)} files, {len(edges)} edges)")
+        return 0
+
+    _write_outputs(payload, JSON_OUT, MD_OUT)
+    print(f"✅  wrote {JSON_OUT.relative_to(ROOT)} ({len(files)} files, {len(edges)} edges)")
+    print(f"✅  wrote {MD_OUT.relative_to(ROOT)}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/hooks/augment-roadmap-progress.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# Augment Code lifecycle-hook trampoline for roadmap-progress-sync.
+#
+# Augment requires hook scripts to use the .sh extension and live at
+# either a system path (/etc/augment/...) or user scope
+# (~/.augment/...). This trampoline lives at user scope and dispatches
+# every PostToolUse event to whichever workspace fired it, so a single
+# install covers every project that has ./agent-config available.
+#
+# Behaviour:
+#   - Read the JSON event from stdin into a buffer.
+#   - Extract workspace_roots[0]; bail silently when missing.
+#   - cd into that workspace; bail silently when it is not a directory
+#     or does not contain ./agent-config.
+#   - Re-pipe the original JSON into
+#       ./agent-config roadmap-progress:hook --platform augment
+#     so roadmap_progress_hook.py runs the path filter and decides
+#     whether to regenerate the dashboard.
+#   - Always exit 0 — PostToolUse hooks must never block.
+
+set -u
+
+EVENT_DATA="$(cat)"
+
+# Extract workspace_roots[0] using whichever JSON tool is available.
+WORKSPACE=""
+if command -v jq >/dev/null 2>&1; then
+    WORKSPACE="$(printf '%s' "$EVENT_DATA" \
+        | jq -r '.workspace_roots[0] // empty' 2>/dev/null)"
+elif command -v python3 >/dev/null 2>&1; then
+    WORKSPACE="$(printf '%s' "$EVENT_DATA" | python3 -c '
+import json, sys
+try:
+    data = json.load(sys.stdin)
+except Exception:
+    sys.exit(0)
+roots = data.get("workspace_roots") or []
+if roots:
+    print(roots[0])
+' 2>/dev/null)"
+fi
+
+if [ -z "$WORKSPACE" ] || [ ! -d "$WORKSPACE" ]; then
+    exit 0
+fi
+
+cd "$WORKSPACE" 2>/dev/null || exit 0
+
+if [ ! -x ./agent-config ]; then
+    exit 0
+fi
+
+printf '%s' "$EVENT_DATA" \
+    | ./agent-config roadmap-progress:hook --platform augment \
+        >/dev/null 2>&1 || true
+
+exit 0

package/scripts/install.py

@@ -464,44 +464,65 @@ def ensure_augment_bridge(project_root: Path, force: bool) -> None:
 # .augment/settings.json is plugin enablement, not hooks.
 AUGMENT_USER_DIR = Path.home() / ".augment"
 AUGMENT_USER_HOOKS_DIR = AUGMENT_USER_DIR / "hooks"
-AUGMENT_TRAMPOLINE_NAME = "augment-chat-history.sh"
-AUGMENT_HOOK_EVENTS = ("SessionStart", "SessionEnd", "Stop", "PostToolUse")
+AUGMENT_CHAT_HISTORY_TRAMPOLINE = "augment-chat-history.sh"
+AUGMENT_ROADMAP_PROGRESS_TRAMPOLINE = "augment-roadmap-progress.sh"
+# (trampoline name, list of events it should fire on). Each trampoline
+# is a self-contained workspace router; mapping them per-event keeps the
+# wiring explicit and lets a future hook bind to a different surface
+# without touching the chat-history one.
+AUGMENT_HOOK_BINDINGS = (
+    (AUGMENT_CHAT_HISTORY_TRAMPOLINE,
+     ("SessionStart", "SessionEnd", "Stop", "PostToolUse")),
+    (AUGMENT_ROADMAP_PROGRESS_TRAMPOLINE,
+     ("PostToolUse",)),
+)
+
+
+def _deploy_augment_trampoline(package_root: Path, name: str, force: bool) -> Path | None:
+    src = package_root / "scripts" / "hooks" / name
+    if not src.exists():
+        skip(f"augment trampoline missing in package: {src}")
+        return None
+    AUGMENT_USER_HOOKS_DIR.mkdir(parents=True, exist_ok=True)
+    dst = AUGMENT_USER_HOOKS_DIR / name
+    src_text = src.read_text(encoding="utf-8")
+    if dst.exists() and dst.read_text(encoding="utf-8") == src_text and not force:
+        skip(f"~/.augment/hooks/{name} already up to date")
+    else:
+        dst.write_text(src_text, encoding="utf-8")
+        dst.chmod(0o755)
+        success(f"~/.augment/hooks/{name} installed")
+    return dst
 
 
 def ensure_augment_user_hooks(package_root: Path, force: bool) -> None:
-    """Deploy the Augment lifecycle-hook trampoline at user scope.
+    """Deploy the Augment lifecycle-hook trampolines at user scope.
 
     Augment hook scripts must use the .sh extension and be referenced by
     absolute path; user scope is the only surface that fires for both the
     CLI and the IDE plugins. This installs once per developer (not per
-    project) — the trampoline reads workspace_roots from the event payload
-    and dispatches into whichever project is active at hook-fire time.
+    project) — each trampoline reads workspace_roots from the event
+    payload and dispatches into whichever project is active at hook-fire
+    time.
+
+    Two trampolines are deployed:
+      - augment-chat-history.sh   → SessionStart/SessionEnd/Stop/PostToolUse
+      - augment-roadmap-progress.sh → PostToolUse (path-filtered to
+        agents/roadmaps/ — see scripts/roadmap_progress_hook.py)
     """
-    src = package_root / "scripts" / "hooks" / AUGMENT_TRAMPOLINE_NAME
-    if not src.exists():
-        skip(f"augment trampoline missing in package: {src}")
-        return
-
-    AUGMENT_USER_HOOKS_DIR.mkdir(parents=True, exist_ok=True)
-    dst = AUGMENT_USER_HOOKS_DIR / AUGMENT_TRAMPOLINE_NAME
+    per_event: dict[str, list] = {}
+    for name, events in AUGMENT_HOOK_BINDINGS:
+        dst = _deploy_augment_trampoline(package_root, name, force)
+        if dst is None:
+            continue
+        entry = {"hooks": [{"type": "command", "command": str(dst)}]}
+        for event in events:
+            per_event.setdefault(event, []).append(entry)
 
-    src_text = src.read_text(encoding="utf-8")
-    if dst.exists() and dst.read_text(encoding="utf-8") == src_text and not force:
-        skip(f"~/.augment/hooks/{AUGMENT_TRAMPOLINE_NAME} already up to date")
-    else:
-        dst.write_text(src_text, encoding="utf-8")
-        dst.chmod(0o755)
-        success(f"~/.augment/hooks/{AUGMENT_TRAMPOLINE_NAME} installed")
+    if not per_event:
+        return
 
-    hook_entry = {
-        "hooks": [
-            {
-                "type": "command",
-                "command": str(dst),
-            },
-        ],
-    }
-    settings_patch: dict = {"hooks": {event: [hook_entry] for event in AUGMENT_HOOK_EVENTS}}
+    settings_patch: dict = {"hooks": per_event}
     merge_json_file(
         AUGMENT_USER_DIR / "settings.json",
         settings_patch,