@andespindola/crow-skills 0.7.1 → 0.9.0

package/crow_skills/integrations.py

@@ -12,10 +12,19 @@ checked on the host versions listed in docs/cli.md:
   when the user has not set a status line.
 - tmux-status: a segment appended to ``status-right`` from a sourced snippet,
   for every agent, only when tmux is installed and already configured.
-
-Gemini CLI (footer takes built-in items only), Antigravity (no status/footer
-setting) and Devin CLI (no status line) have no surface that can display an
-external value; they get the tmux segment and ``crow-skills progress``.
+- agy-statusline: ``statusLine`` in ~/.gemini/antigravity-cli/settings.json,
+  stacked under Antigravity's default line (``stack_with_default``).
+- *-hooks: the crow mode hook (crow_hook.py) in each CLI's own hook config:
+  claude (~/.claude/settings.json), codex (~/.codex/hooks.json), Gemini CLI
+  (~/.gemini/settings.json), agy (~/.gemini/config/hooks.json) and Devin
+  (~/.config/devin/config.json). Entries are appended after the user's own and
+  identified by the script path; nothing else in those files changes.
+- claude-command / gemini-command: a ``/crow on|off|status`` slash command in
+  a file of its own (~/.claude/commands/crow.md, ~/.gemini/commands/crow.toml).
+
+Gemini CLI (footer takes built-in items only), Codex (built-in items only)
+and Devin CLI (no status line) show the mode as a one-line systemMessage
+from the hook when it changes; they also get the tmux segment.
 
 Ownership: one key (claude), one marked block (codex, tmux.conf) and two whole
 files under ~/.config/crow-skills and the CLI state. Every edited file is
@@ -39,19 +48,28 @@ from .guide import protect, read_regular, sha, tomllib, write_atomic
 from .source import CrowError
 from .storage import atomic_json, checked, private_dir, read_json
 
-NAMES = ("claude-statusline", "codex-statusline", "tmux-status")
-OWNERS = {"claude-statusline": ("claude",), "codex-statusline": ("codex",),
-          "tmux-status": ("claude", "codex", "gemini", "devin")}
+NAMES = ("claude-statusline", "claude-hooks", "claude-command", "codex-statusline", "codex-hooks",
+         "gemini-hooks", "gemini-command", "agy-hooks", "agy-statusline", "devin-hooks", "tmux-status")
+OWNERS = {"claude-statusline": ("claude",), "claude-hooks": ("claude",), "claude-command": ("claude",),
+          "codex-statusline": ("codex",), "codex-hooks": ("codex",),
+          "gemini-hooks": ("gemini",), "gemini-command": ("gemini",), "agy-hooks": ("gemini",), "agy-statusline": ("gemini",),
+          "devin-hooks": ("devin",), "tmux-status": ("claude", "codex", "gemini", "devin")}
+HOOK_SCRIPT = "crow_hook.py"
+RESOURCES_SCRIPT = "crow_resources.py"
+COMMAND_HEADER = "Gerenciado por crow-skills (comando /crow). Não edite; use crow-skills integrations."
 BEGIN = "# >>> crow-skills integrations (gerenciado; use crow-skills integrations uninstall) >>>"
 END = "# <<< crow-skills integrations <<<"
 CODEX_ITEMS = ["model-with-reasoning", "context-remaining", "current-dir", "task-progress", "used-tokens"]
 SNIPPET_HEADER = "# Gerenciado por crow-skills (integração tmux). Não edite; use crow-skills integrations."
 UNSUPPORTED = {
-    "gemini": ("Agente gemini do instalador = Antigravity (agy): sem status line nem rodapé configurável; no ledger use host agy, "
-               "nunca gemini (gemini é o Gemini CLI, cujo rodapé ui.footer.items só aceita itens nativos). "
-               "Use o segmento tmux ou crow-skills progress."),
-    "devin": "Devin CLI não tem status line nem rodapé configurável; use o segmento tmux ou crow-skills progress.",
+    "gemini": ("Gemini CLI: o rodapé (ui.footer.items) só aceita itens nativos; o modo aparece como systemMessage do hook quando muda. "
+               "O Antigravity (agy, mesmo agente gemini do instalador) recebe agy-statusline. No ledger, agy é host agy, nunca gemini."),
+    "devin": ("Devin CLI não tem status line nem rodapé configurável; o modo aparece como systemMessage do hook quando muda. "
+              "Use o segmento tmux ou crow-skills progress para o resto."),
+    "codex": ("Codex: o rodapé só aceita itens nativos e não mostra o modo crow; ele aparece como systemMessage do hook no início "
+              "da sessão e quando muda."),
 }
+UNSUPPORTED_ROW = {"gemini": "gemini-cli-statusline", "devin": "devin-statusline", "codex": "codex-mode-indicator"}
 
 
 def tmux_binary():
@@ -92,6 +110,45 @@ def script_source():
     return (Path(__file__).resolve().parent / "progress.py").read_bytes()
 
 
+def hook_script_path(store):
+    return root(store) / HOOK_SCRIPT
+
+
+def hook_source():
+    return (Path(__file__).resolve().parent / "hook.py").read_bytes()
+
+
+def resources_script_path(store):
+    return root(store) / RESOURCES_SCRIPT
+
+
+def resources_source():
+    return (Path(__file__).resolve().parent / "resources.py").read_bytes()
+
+
+def remove_bytecode(store):
+    """__pycache__ beside the copied scripts (written when the status line imports crow_hook):
+    removed with them, only when it holds nothing but their bytecode."""
+    cache = root(store) / "__pycache__"
+    if cache.is_symlink() or not cache.is_dir():
+        return
+    names = ("crow_progress.", "crow_hook.", "crow_resources.")
+    entries = list(cache.iterdir())
+    if all(e.is_file() and not e.is_symlink() and e.name.startswith(names) and e.suffix == ".pyc" for e in entries):
+        try:
+            for entry in entries:
+                entry.unlink()
+            cache.rmdir()
+        except OSError:
+            pass  # a hook wrote bytecode meanwhile: the directory stays, nothing else is touched
+
+
+def scripts(store):
+    """(installed path, source bytes) of every script the hooks and status lines run."""
+    return ((script_path(store), script_source()), (hook_script_path(store), hook_source()),
+            (resources_script_path(store), resources_source()))
+
+
 def quoted_ok(*paths):
     return all(not re.search(r"[\"'\\$`\n]", str(p)) for p in paths)
 
@@ -106,17 +163,6 @@ def backup(store, name, data):
     return path.name
 
 
-def restore_bytes(store, record, path, old):
-    """Original bytes from the install backup, when the file still holds exactly what we wrote."""
-    name = record.get("backup")
-    if old is None or not name or record.get("written_sha") != sha(old) or "/" in name:
-        return None
-    try:
-        return read_regular(checked(root(store) / "backups" / name))
-    except (CrowError, OSError):
-        return None
-
-
 def write(path, data, old):
     mode = (path.lstat().st_mode & 0o777) if old is not None else 0o644
     if not path.parent.exists():
@@ -124,19 +170,97 @@ def write(path, data, old):
     write_atomic(path, data, mode)
 
 
-# --- claude ---------------------------------------------------------------------------------
+# JSON files shared by integrations (claude settings.json holds the status line and the hooks)
+# keep one restore point per file, state["files"][path]: the bytes before crow-skills first
+# wrote it and the sha of what it last wrote. sync() binds these to the state being built.
+_FILES = {}
+_LIVE = {}
 
-def claude_sync(store, home, record, desired, python, dry):
-    path = protect(home / ".claude" / "settings.json", home)
+
+def tracked_write(store, path, data, old, label):
+    key = str(path)
+    entry = _FILES.get(key)
+    if entry is None:
+        entry = _FILES[key] = {"backup": backup(store, label, old), "created_file": old is None}
+    elif entry.get("written_sha") != sha(old or b""):
+        entry["backup"] = None  # edited outside crow-skills since: from now on only our keys are removed
+    write(path, data, old)
+    entry["written_sha"] = sha(data)
+
+
+def release(store, name, path, current, label, remaining):
+    """Write the file without name's content. The last crow-skills user of an untouched file
+    gets the original bytes back (or the file removed, if crow-skills created it)."""
+    key = str(path)
+    entry = _FILES.get(key)
+    others = [n for n, r in _LIVE.items() if n != name and isinstance(r, dict) and r.get("path") == key]
+    backup(store, label, current)
+    if others:
+        data = dump(remaining)
+        write(path, data, current)
+        if entry is not None:
+            if entry.get("written_sha") != sha(current or b""):
+                entry["backup"] = None
+            entry["written_sha"] = sha(data)
+        return
+    _FILES.pop(key, None)
+    untouched = entry is not None and entry.get("written_sha") == sha(current or b"")
+    if untouched and entry.get("created_file"):
+        path.unlink()
+        return
+    if untouched and entry.get("backup") and "/" not in entry["backup"]:
+        try:
+            original = read_regular(checked(root(store) / "backups" / entry["backup"]))
+        except (CrowError, OSError):
+            original = None
+        if original is not None:
+            write(path, original, current)
+            return
+    if entry is not None and entry.get("created_file") and not remaining:
+        path.unlink()
+        return
+    write(path, dump(remaining), current)
+
+
+# --- JSON status lines (claude, agy) --------------------------------------------------------
+
+STATUSLINES = {
+    "claude-statusline": {"path": (".claude", "settings.json"), "chain": "claude-statusline-chain.json",
+                          "backup": "claude-settings", "label": "~/.claude/settings.json", "args": "",
+                          "defaults": {"padding": 0}, "requires": None},
+    "agy-statusline": {"path": (".gemini", "antigravity-cli", "settings.json"), "chain": "agy-statusline-chain.json",
+                       "backup": "agy-settings", "label": "~/.gemini/antigravity-cli/settings.json", "args": " --host agy",
+                       "defaults": {"stack_with_default": True}, "requires": (".gemini", "antigravity-cli")},
+}
+
+
+def read_json_object(path, label):
+    """(bytes, dict) of a JSON settings file, or (bytes, None, reason) when it cannot be edited safely."""
     old = read_regular(path)
     try:
-        settings = json.loads(old.decode("utf-8")) if old is not None and old.strip() else {}
+        data = json.loads(old.decode("utf-8")) if old is not None and old.strip() else {}
     except (UnicodeDecodeError, ValueError):
-        return None, "skip", "~/.claude/settings.json não é JSON válido; nada alterado."
-    if not isinstance(settings, dict):
-        return None, "skip", "~/.claude/settings.json não é um objeto JSON; nada alterado."
+        return old, None, label + " não é JSON válido; nada alterado."
+    if not isinstance(data, dict):
+        return old, None, label + " não é um objeto JSON; nada alterado."
+    return old, data, None
+
+
+def dump(data):
+    return (json.dumps(data, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
+
+
+def statusline_sync(name, store, home, record, desired, python, dry):
+    spec = STATUSLINES[name]
+    if spec["requires"] and not (home.joinpath(*spec["requires"])).is_dir() and not record:
+        return None, "skip" if desired else "unchanged", (spec["label"] + ": CLI não configurado neste perfil; nada alterado."
+                                                          if desired else None)
+    path = protect(home.joinpath(*spec["path"]), home)
+    old, settings, problem = read_json_object(path, spec["label"])
+    if problem:
+        return (record if desired else None), "skip", problem
     current = settings.get("statusLine")
-    chain_file = root(store) / "claude-statusline-chain.json"
+    chain_file = root(store) / spec["chain"]
     if not desired:
         if not record:
             return None, "unchanged", None
@@ -150,15 +274,7 @@ def claude_sync(store, home, record, desired, python, dry):
             settings.pop("statusLine", None)
         if dry:
             return None, "remove", None
-        original = None if record.get("created_file") else restore_bytes(store, record, path, old)
-        backup(store, "claude-settings", old)
-        if record.get("created_file") and not settings:
-            path.unlink()
-        elif original is not None:
-            # Nothing else changed since the install: give the file back byte for byte.
-            write(path, original, old)
-        else:
-            write(path, (json.dumps(settings, ensure_ascii=False, indent=2) + "\n").encode("utf-8"), old)
+        release(store, name, path, old, spec["backup"], settings)
         if chain_file.exists():
             chain_file.unlink()
         return None, "remove", None
@@ -169,14 +285,14 @@ def claude_sync(store, home, record, desired, python, dry):
     if record and current != record["value"]:
         return record, "skip", "statusLine foi alterado depois da instalação; não sobrescrito. Rode crow-skills integrations uninstall para desfazer o controle."
     if not record and current is not None:
-        if not (isinstance(current, dict) and current.get("type") == "command" and isinstance(current.get("command"), str)):
+        if not (isinstance(current, dict) and current.get("type", "command") == "command" and isinstance(current.get("command"), str)):
             return None, "skip", "statusLine existente não é do tipo command; não encadeado nem substituído."
         previous = current
-    command = shlex.quote(str(python)) + " " + shlex.quote(str(script)) + " statusline"
+    command = shlex.quote(str(python)) + " " + shlex.quote(str(script)) + " statusline" + spec["args"]
     if previous is not None:
         command += " --chain-file " + shlex.quote(str(chain_file))
     # A chained status line keeps its own keys (padding and any other); only the command changes.
-    value = {k: v for k, v in previous.items() if k not in ("type", "command")} if previous is not None else {"padding": 0}
+    value = {k: v for k, v in previous.items() if k not in ("type", "command")} if previous is not None else dict(spec["defaults"])
     value = {"type": "command", "command": command, **value}
     if record and current == value:
         return record, "unchanged", None
@@ -188,19 +304,278 @@ def claude_sync(store, home, record, desired, python, dry):
         return new_record, action, None
     if previous is not None:
         atomic_json(chain_file, {"command": previous["command"]})
-    safety = backup(store, "claude-settings", old)
-    # The restore point is the pre-install backup. An update keeps it only while the file
-    # still holds exactly what this CLI wrote; otherwise uninstall restores the key only.
-    if record:
-        new_record["backup"] = record.get("backup") if record.get("written_sha") == sha(old or b"") else None
-    else:
-        new_record["backup"] = safety
-    data = (json.dumps(settings, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
-    write(path, data, old)
-    new_record["written_sha"] = sha(data)
+    # The restore point is the file's pre-install backup (state["files"]). An update keeps it only
+    # while the file still holds exactly what this CLI wrote; otherwise uninstall restores the key only.
+    tracked_write(store, path, dump(settings), old, spec["backup"])
     return new_record, action, None
 
 
+def claude_sync(store, home, record, desired, python, dry):
+    return statusline_sync("claude-statusline", store, home, record, desired, python, dry)
+
+
+def agy_statusline_sync(store, home, record, desired, python, dry):
+    return statusline_sync("agy-statusline", store, home, record, desired, python, dry)
+
+
+# --- hooks (crow mode + events) --------------------------------------------------------------
+
+# (event, async). Only the prompt event (and a SessionStart that shows the mode) wait for the
+# hook; every other event is recorded asynchronously where the CLI supports it.
+CLAUDE_EVENTS = [("SessionStart", True), ("UserPromptSubmit", False), ("PreToolUse", True), ("PostToolUse", True),
+                 ("PostToolUseFailure", True), ("PermissionRequest", True), ("Notification", True), ("SubagentStart", True),
+                 ("SubagentStop", True), ("Stop", True), ("StopFailure", True), ("PreCompact", True), ("SessionEnd", True)]
+CODEX_EVENTS = [("SessionStart", False), ("UserPromptSubmit", False), ("PreToolUse", True), ("PostToolUse", True),
+                ("PermissionRequest", True), ("SubagentStart", True), ("SubagentStop", True), ("Stop", True)]
+GEMINI_EVENTS = ["SessionStart", "BeforeAgent", "BeforeTool", "AfterTool", "AfterAgent", "Notification", "PreCompress", "SessionEnd"]
+AGY_EVENTS = ["SessionStart", "PreToolUse", "PostToolUse", "PreInvocation", "PostInvocation", "Stop"]
+DEVIN_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PermissionRequest", "SubagentStop", "Stop",
+                "SessionEnd"]
+AGY_KEY = "crow-skills"
+
+
+def devin_dir(home):
+    if home == Path.home().resolve() and os.environ.get("XDG_CONFIG_HOME"):
+        return Path(os.environ["XDG_CONFIG_HOME"]).expanduser() / "devin"
+    return home / ".config" / "devin"
+
+
+HOOKS = {
+    "claude-hooks": {"host": "claude", "file": lambda h: h / ".claude" / "settings.json", "label": "~/.claude/settings.json",
+                     "layout": "groups", "requires": None, "backup": "claude-settings"},
+    "codex-hooks": {"host": "codex", "file": lambda h: h / ".codex" / "hooks.json", "label": "~/.codex/hooks.json",
+                    "layout": "groups", "requires": lambda h: h / ".codex", "backup": "codex-hooks"},
+    "gemini-hooks": {"host": "gemini", "file": lambda h: h / ".gemini" / "settings.json", "label": "~/.gemini/settings.json",
+                     "layout": "groups", "requires": lambda h: h / ".gemini" / "settings.json", "backup": "gemini-settings"},
+    "agy-hooks": {"host": "agy", "file": lambda h: h / ".gemini" / "config" / "hooks.json", "label": "~/.gemini/config/hooks.json",
+                  "layout": "agy", "requires": lambda h: h / ".gemini" / "antigravity-cli", "backup": "agy-hooks"},
+    "devin-hooks": {"host": "devin", "file": lambda h: devin_dir(h) / "config.json", "label": "~/.config/devin/config.json",
+                    "layout": "groups", "requires": lambda h: devin_dir(h) / "config.json", "backup": "devin-config"},
+}
+
+
+def codex_hooks_feature(home):
+    """Codex runs hooks only with [features] hooks = true; report it, never edit it here."""
+    try:
+        data = tomllib.loads((home / ".codex" / "config.toml").read_text(encoding="utf-8")) if tomllib else {}
+    except (OSError, ValueError):
+        data = {}
+    if (data.get("features") or {}).get("hooks") is True:
+        return ""
+    return " Habilite também [features] hooks = true em ~/.codex/config.toml (não alterado pelo crow-skills)."
+
+
+def hook_command(store, home, python, host, event):
+    return (shlex.quote(str(python)) + " -I -S " + shlex.quote(str(hook_script_path(store))) + " hook --host " + host +
+            " --event " + event + " --home " + shlex.quote(str(home)))
+
+
+def hook_entries(store, home, python, host):
+    """{event: [hook entry]} in the host's own schema."""
+    command = lambda event: hook_command(store, home, python, host, event)  # noqa: E731
+    if host == "claude":
+        return {e: [dict({"type": "command", "command": command(e), "timeout": 5}, **({"async": True} if a else {}))]
+                for e, a in CLAUDE_EVENTS}
+    if host == "codex":
+        return {e: [dict({"type": "command", "command": command(e), "timeout": 5}, **({"async": True} if a else {}))]
+                for e, a in CODEX_EVENTS}
+    if host == "gemini":
+        return {e: [{"type": "command", "name": "crow-skills-" + e, "command": command(e), "timeout": 3000}] for e in GEMINI_EVENTS}
+    if host == "agy":
+        return {e: [{"type": "command", "command": command(e), "timeout": 3}] for e in AGY_EVENTS}
+    return {e: [{"type": "command", "command": command(e)}] for e in DEVIN_EVENTS}
+
+
+def is_ours(entry, store):
+    return isinstance(entry, dict) and isinstance(entry.get("command"), str) and str(hook_script_path(store)) in entry["command"]
+
+
+def strip_hooks(data, store, layout):
+    """A copy of the settings without this CLI's hook entries (user entries keep their order)."""
+    result = deepcopy(data)
+    if layout == "agy":
+        block = result.get(AGY_KEY)
+        if isinstance(block, dict) and all(isinstance(v, list) and all(is_ours(e, store) for e in v) for v in block.values()):
+            result.pop(AGY_KEY)
+        return result
+    hooks = result.get("hooks")
+    if not isinstance(hooks, dict):
+        return result
+    for event in list(hooks):
+        groups = hooks[event]
+        if not isinstance(groups, list):
+            continue
+        kept = []
+        for group in groups:
+            if isinstance(group, dict) and isinstance(group.get("hooks"), list):
+                remaining = [h for h in group["hooks"] if not is_ours(h, store)]
+                if not remaining and group["hooks"]:
+                    continue  # a group that held only our entries
+                if len(remaining) != len(group["hooks"]):
+                    group = dict(group, hooks=remaining)
+            kept.append(group)
+        if kept:
+            hooks[event] = kept
+        elif groups:
+            hooks.pop(event)
+    if not hooks and data.get("hooks"):
+        result.pop("hooks")  # emptied by removing our entries: the key was ours to add
+    return result
+
+
+def refresh_in_place(data, entries, store, layout):
+    """Replace our existing entries where they are (same events, one entry each), so a re-sync
+    never moves the user's hooks or ours; None when the layout does not match the desired one."""
+    result = deepcopy(data)
+    if layout == "agy":
+        if not isinstance(result.get(AGY_KEY), dict):
+            return None
+        result[AGY_KEY] = entries  # an existing key keeps its position
+        return result
+    hooks = result.get("hooks")
+    if not isinstance(hooks, dict):
+        return None
+    found = {}
+    for event, groups in hooks.items():
+        for gi, group in enumerate(groups if isinstance(groups, list) else []):
+            for hi, item in enumerate(group.get("hooks", []) if isinstance(group, dict) else []):
+                if is_ours(item, store):
+                    found.setdefault(event, []).append((gi, hi))
+    if set(found) != set(entries) or any(len(v) != 1 or len(entries[e]) != 1 for e, v in found.items()):
+        return None
+    for event, [(gi, hi)] in found.items():
+        hooks[event][gi]["hooks"][hi] = entries[event][0]
+    return result
+
+
+def add_hooks(data, entries, layout):
+    result = deepcopy(data)
+    if layout == "agy":
+        result[AGY_KEY] = entries
+        return result
+    hooks = result.setdefault("hooks", {})
+    for event, items in entries.items():
+        hooks.setdefault(event, []).append({"hooks": items})  # appended: the user's hooks keep their index (Codex trust)
+    return result
+
+
+def hooks_sync(name, store, home, record, desired, python, dry):
+    spec = HOOKS[name]
+    target = spec["file"](home)
+    if desired and not record and spec["requires"] is not None and not os.path.exists(spec["requires"](home)):
+        return None, "skip", spec["label"] + ": CLI não configurado neste perfil; nada alterado."
+    path = protect(target, home)
+    old, data, problem = read_json_object(path, spec["label"])
+    if problem:
+        return (record if desired else None), "skip", problem
+    if spec["layout"] == "groups" and not isinstance(data.get("hooks", {}), dict):
+        return (record if desired else None), "skip", spec["label"] + ": chave hooks com formato inesperado; nada alterado."
+    stripped = strip_hooks(data, store, spec["layout"])
+    if not desired:
+        if not record:
+            return None, "unchanged", None
+        if stripped == data:
+            return None, "skip", "Entradas do crow-skills já ausentes de " + spec["label"] + "; controle encerrado."
+        if dry:
+            return None, "remove", None
+        release(store, name, path, old, spec["backup"], stripped)
+        return None, "remove", None
+    if not quoted_ok(python, hook_script_path(store), home):
+        return record, "skip", "Caminho do Python, do estado ou do home contém aspas/variáveis; hooks não configurados."
+    entries = hook_entries(store, home, python, spec["host"])
+    wanted = refresh_in_place(data, entries, store, spec["layout"]) or add_hooks(stripped, entries, spec["layout"])
+    if wanted == data:
+        if record:
+            return record, "unchanged", None
+        return {"path": str(path), "installed_at": now(), "created_file": False}, "adopt", None
+    action = "update" if record else "install"
+    new_record = {"path": str(path), "installed_at": now(),
+                  "created_file": record.get("created_file", False) if record else old is None}
+    note = None
+    if spec["host"] == "codex":
+        note = ("Codex só executa hook novo ou alterado depois de aprovado: abra o Codex, rode /hooks e aprove as entradas "
+                "do crow-skills (o hook do usuário já aprovado continua no mesmo índice).") + codex_hooks_feature(home)
+    if dry:
+        return new_record, action, note
+    tracked_write(store, path, dump(wanted), old, spec["backup"])
+    return new_record, action, note
+
+
+# --- /crow slash commands ------------------------------------------------------------------------
+
+COMMANDS = {
+    "claude-command": {"file": (".claude", "commands", "crow.md"), "requires": None, "host": "claude"},
+    "gemini-command": {"file": (".gemini", "commands", "crow.toml"), "requires": (".gemini", "settings.json"), "host": "gemini"},
+}
+
+
+def command_content(name, store, home, python):
+    call = (shlex.quote(str(python)) + " -I -S " + shlex.quote(str(hook_script_path(store))) + " mode")
+    tail = " --home " + shlex.quote(str(home)) + " --by " + COMMANDS[name]["host"]
+    if name == "claude-command":
+        return ("---\n"
+                "description: Liga ou desliga o modo crow (crow-behaviour) em todas as sessões e CLIs. Uso: /crow on | off | status\n"
+                "argument-hint: on | off | status\n"
+                "allowed-tools: Bash(" + call + ":*)\n"
+                "disable-model-invocation: true\n"
+                "---\n"
+                "<!-- " + COMMAND_HEADER + " -->\n\n"
+                "!`case \"$ARGUMENTS\" in on|off|status|toggle|'') " + call + " $ARGUMENTS" + tail + " ;; *) echo 'uso: /crow on|off|status' ;; esac`\n\n"
+                "Responda ao usuário só com a linha acima (o estado do modo crow), sem carregar skills nem executar mais nada.\n")
+    return ("# " + COMMAND_HEADER + "\n"
+            'description = "Liga ou desliga o modo crow (crow-behaviour) em todas as sessões e CLIs: /crow on | off | status"\n'
+            'prompt = """\n'
+            "!{" + call + " {{args}}" + tail + "}\n\n"
+            "Responda ao usuário só com a linha acima (o estado do modo crow), sem carregar skills nem executar mais nada.\n"
+            '"""\n')
+
+
+def command_sync(name, store, home, record, desired, python, dry):
+    spec = COMMANDS[name]
+    path = home.joinpath(*spec["file"])
+    if desired and not record and spec["requires"] and not home.joinpath(*spec["requires"]).exists():
+        return None, "skip", "/".join(spec["requires"]) + " ausente: CLI não configurado neste perfil; nada alterado."
+    path = protect(path, home)
+    current = read_regular(path) if os.path.lexists(path) else None
+    managed = current is not None and COMMAND_HEADER.encode("utf-8") in current
+    if not desired:
+        if not record:
+            return None, "unchanged", None
+        if current is None or not managed or sha(current) != record.get("written_sha"):
+            return None, "skip", str(path) + " foi alterado ou removido; mantido como está e removido do controle do crow-skills."
+        if dry:
+            return None, "remove", None
+        path.unlink()
+        for directory in record.get("created_dirs", []):
+            try:
+                os.rmdir(directory)
+            except OSError:
+                pass
+        return None, "remove", None
+    if current is not None and not managed:
+        return record, "skip", str(path) + " existe e não é gerenciado; comando /crow não instalado."
+    if record and current is not None and sha(current) != record.get("written_sha"):
+        return record, "skip", str(path) + " foi editado depois da instalação; não sobrescrito."
+    if not quoted_ok(python, hook_script_path(store), home):
+        return record, "skip", "Caminho do Python, do estado ou do home contém aspas/variáveis; comando /crow não instalado."
+    content = command_content(name, store, home, python).encode("utf-8")
+    if record and current == content:
+        return record, "unchanged", None
+    created = record.get("created_dirs", []) if record else []
+    if not record:
+        parent = path.parent
+        while not parent.exists() and home in parent.parents:
+            created.append(str(parent))
+            parent = parent.parent
+    new_record = {"path": str(path), "installed_at": now(), "written_sha": sha(content), "created_dirs": created}
+    if dry:
+        return new_record, "update" if record else "install", None
+    if not path.parent.exists():
+        path.parent.mkdir(parents=True, mode=0o755)
+    write_atomic(path, content, 0o644)
+    return new_record, "update" if record else "install", None
+
+
 # --- codex ---------------------------------------------------------------------------------
 
 def marked(text):
@@ -448,7 +823,10 @@ def tmux_sync(store, home, record, desired, python, dry):
     return new_record, action, note
 
 
-SYNC = {"claude-statusline": claude_sync, "codex-statusline": codex_sync, "tmux-status": tmux_sync}
+SYNC = {"claude-statusline": claude_sync, "codex-statusline": codex_sync, "tmux-status": tmux_sync,
+        "agy-statusline": agy_statusline_sync,
+        **{name: (lambda n: lambda *a: hooks_sync(n, *a))(name) for name in HOOKS},
+        **{name: (lambda n: lambda *a: command_sync(n, *a))(name) for name in COMMANDS}}
 
 
 # --- orchestration -------------------------------------------------------------------------
@@ -466,15 +844,27 @@ def sync(store, home, wanted, dry_run=False, python=None):
     except CrowError as exc:
         report["skipped"].append({"integration": "*", "reason": str(exc)})
         return report
-    after = {"schema_version": 1, "integrations": dict(state["integrations"])}
+    after = {"schema_version": 1, "integrations": dict(state["integrations"]), "files": dict(state.get("files") or {})}
+    for record in state["integrations"].values():
+        # Records written by 0.7.x kept the restore point in the record itself.
+        if isinstance(record, dict) and record.get("written_sha") and record.get("path") and record["path"] not in after["files"] \
+                and str(record["path"]).endswith(".json"):
+            after["files"][record["path"]] = {"backup": record.get("backup"), "created_file": record.get("created_file", False),
+                                              "written_sha": record["written_sha"]}
+    global _FILES, _LIVE
+    _FILES = {k: dict(v) for k, v in after["files"].items()}
+    _LIVE = after["integrations"]
     with (nullcontext() if dry_run else store.lock()):
         if not dry_run and any(set(OWNERS[n]) & set(wanted) for n in NAMES):
-            script = script_path(store)
             private_dir(root(store))
-            source = script_source()
-            if not script.exists() or sha(script.read_bytes()) != sha(source):
-                write_atomic(checked(script), source, 0o644)
-        for name in NAMES:
+            for script, source in scripts(store):
+                if not script.exists() or sha(script.read_bytes()) != sha(source):
+                    write_atomic(checked(script), source, 0o644)
+        # Removals first and in reverse order, then installs in order: two integrations that
+        # edit the same file (claude settings.json) restore it last-in, first-out, byte for byte.
+        order = [n for n in reversed(NAMES) if not set(OWNERS[n]) & set(wanted)] + \
+                [n for n in NAMES if set(OWNERS[n]) & set(wanted)]
+        for name in order:
             desired = bool(set(OWNERS[name]) & set(wanted))
             record = state["integrations"].get(name)
             try:
@@ -493,13 +883,20 @@ def sync(store, home, wanted, dry_run=False, python=None):
                 after["integrations"].pop(name, None)
             else:
                 after["integrations"][name] = new_record
+        after["files"] = {k: v for k, v in _FILES.items()
+                          if any(isinstance(r, dict) and r.get("path") == k for r in after["integrations"].values())}
+        if not after["files"]:
+            after.pop("files")
         if not dry_run:
             if after != state:
                 atomic_json(state_path(store), after)
             if not after["integrations"]:
-                script = script_path(store)
-                if script.exists():
-                    script.unlink()
+                for script in (script_path(store), hook_script_path(store), resources_script_path(store)):
+                    if script.exists():
+                        script.unlink()
+                remove_bytecode(store)
+    for key in ("changes", "skipped"):
+        report[key].sort(key=lambda c: NAMES.index(c["integration"]) if c["integration"] in NAMES else 99)
     report["dry_run"] = dry_run
     return report
 
@@ -516,5 +913,5 @@ def status(store, home):
                 row["note"] = "tmux.conf é symlink; linha source-file adicionada manualmente pelo usuário."
         rows.append(row)
     for agent, reason in UNSUPPORTED.items():
-        rows.append({"integration": agent + "-statusline", "agents": [agent], "status": "unsupported", "note": reason})
+        rows.append({"integration": UNSUPPORTED_ROW[agent], "agents": [agent], "status": "unsupported", "note": reason})
     return rows