@r1z4x/tezgah 1.9.2 → 1.13.0

package/bin/tezgah-setup

@@ -166,6 +166,28 @@ DSH_WEB_PATCH = os.path.join(DSH_WEB, "cordis.patch.yml")
 DSH_STATUSLINE = "tezgah-dsh-statusline"
 OMP = tp.HOST_DIRS["omp"]
 OMP_AGENT = os.path.join(OMP, "agent")
+QWEN = tp.HOST_DIRS["qwen"]
+DROID = tp.HOST_DIRS["droid"]
+COMMANDCODE = tp.HOST_DIRS["commandcode"]
+COPILOT = tp.HOST_DIRS["copilot"]
+GEMINI = tp.HOST_DIRS["gemini"]
+# tezgah's own Gemini extension: a dir Gemini loads from <home>/.gemini/extensions
+# with no `gemini extensions install` (extension-manager.ts reads every subdir;
+# only a non-empty `security.allowedExtensions` asks for install metadata)
+GEMINI_EXT = os.path.join(GEMINI, "extensions", "tezgah")
+ANTIGRAVITY = tp.HOST_DIRS["antigravity"]
+# Antigravity's global hooks file: one top-level name per hook set, and the
+# Antigravity App and IDE load it too (docs/hooks); tezgah owns the `tezgah` name
+AGY_HOOKS = os.path.join(os.path.dirname(ANTIGRAVITY), "config", "hooks.json")
+GOOSE = tp.HOST_DIRS["goose"]
+# tezgah's own Goose plugin under ~/.agents/plugins, wholly tezgah's
+GOOSE_PLUGIN = tp.GOOSE_PLUGIN
+AMP = tp.HOST_DIRS["amp"]
+# tezgah's Amp system plugin, one file Amp loads with every other .ts there
+AMP_PLUGIN = tp.AMP_PLUGIN
+# Amp's commit trailers, both on by default (docs cli/settings): the co-author
+# line and the thread link; tezgah turns both off unless the user set them
+AMP_ATTRIBUTION = ("amp.git.commit.coauthor.enabled", "amp.git.commit.ampThread.enabled")
 OMP_MCP_SCHEMA = ("https://raw.githubusercontent.com/can1357/oh-my-pi/main/"
                   "packages/coding-agent/src/config/mcp-schema.json")
 # App-analysis servers omp drops on its own. While its native `browser` (the eval
@@ -188,7 +210,7 @@ LOCAL_BIN = os.path.join(HOME, ".local", "bin")
 SKILLS = ["harness", "tezgah-contract", "ponytail", "i-have-adhd", "no-ai-slop",
           "analyze-app", "plan-add", "plan-status", "plan-sync", "research",
           "product-analysis", "product-flow", "feature-audit", "design-contract",
-          "design-library", "pm-frameworks", "ai-research", "rl-env"]
+          "design-library", "hallmark", "pm-frameworks", "ai-research", "rl-env"]
 
 
 def skills_linked(base):
@@ -209,8 +231,22 @@ RESEARCH_SKILLS = frozenset(("ai-research", "rl-env"))
 # explicit value wins.
 OPENCODE_IGNORE = [".git/**", "node_modules/**", "dist/**", "build/**",
                    ".venv/**", "__pycache__/**", ".ruff_cache/**"]
+
+
+def opencode_v2():
+    """opencode 2 keeps its terminal settings in cli.json (it migrates tui.json
+    into it once, on first start) and ignores tui.json afterwards."""
+    return os.path.isfile(os.path.join(OPENCODE, "cli.json"))
+
+
+# The opencode 2 status line: a link to the plugin directory hosts/opencode/tui/cli,
+# listed in cli.json `plugins` as file://<this path>.
+OPENCODE_CLI_PLUGIN = os.path.join(OPENCODE, "tui-plugins", "tezgah-cli")
+
+
 WORKFLOW_FILES = ["graph-map.js", "graph-review.js", "graph-impact.js"]
-ALL_HOSTS = ["claude", "codex", "opencode", "cursor", "dsh", "omp"]
+ALL_HOSTS = ["claude", "codex", "opencode", "cursor", "dsh", "omp", "qwen", "droid",
+             "commandcode", "copilot", "gemini", "antigravity", "goose", "amp"]
 # orx ships an installable skill shim for four agents; dsh has no orx harness,
 # so research routing there falls back to `orx skill` on the shell. omp has no
 # orx target of its own, and needs none: orx's `codex` target writes its shim to
@@ -231,7 +267,8 @@ MATERIALISED = os.path.join(tp.CONFIG_DIR, "materialised")
 # copies die with ~/.config/tezgah; the pre-multi-host setup wrote them to
 # ~/.claude, which OFF_DIRS still honors, so a full uninstall sweeps those by
 # name too - a switch left behind is a rule that stays silent with no file saying why.
-OFF_SWITCH_NAMES = ("adhd-off", "agents-off", "consult-off", "docs-judge-off", "exec-mode.off",
+OFF_SWITCH_NAMES = ("adhd-off", "agents-off", "consult-off", "design-off", "docs-judge-off",
+                    "exec-mode.off",
                     "judge-off", "lang-off", "orchestrate-off", "ponytail-auto.off",
                     "pretooluse-off", "reminder-off", "research-off", "slices-off",
                     "spec-off", "task-off", "triage-off", "update-check-off", "verify-off",
@@ -310,6 +347,73 @@ CURSOR_HOOK_EVENTS = {
     "afterFileEdit": {"timeout": 10},
     "afterAgentResponse": {"timeout": 5},
 }
+# Qwen Code 0.21.13: a matcher is a regex over the runtime tool id, and a
+# command hook's `timeout` is in MILLISECONDS (60000 by default) - the seconds
+# value the other manifests carry would time every hook out. Stop and
+# SubagentStop run the integrity rule, which may ask a judge, so they get more.
+# Qwen takes MCP tools as `mcp__<server>__<tool>`.
+QWEN_PRETOOL_MATCHER = ("^(run_shell_command|monitor|write_file|edit|replace|notebook_edit|"
+                        "agent|grep_search|mcp__.*)$")
+QWEN_HOOK_EVENTS = (("SessionStart", None, 5000), ("UserPromptSubmit", None, 5000),
+                    ("PreToolUse", QWEN_PRETOOL_MATCHER, 5000),
+                    ("PostToolUse", None, 5000), ("PostToolUseFailure", None, 5000),
+                    ("SubagentStart", None, 5000), ("SubagentStop", None, 30000),
+                    ("Stop", None, 30000))
+# Factory Droid 0.251.0 (docs.factory.com harness/hooks): a matcher is a
+# case-sensitive regex over the tool id, and `timeout` is in seconds. Droid has
+# no SubagentStart and no failure event. MCP tools are `mcp__<server>__<tool>`.
+DROID_PRETOOL_MATCHER = "^(Execute|Create|Edit|ApplyPatch|Task|Grep|mcp__.*)$"
+DROID_HOOK_EVENTS = (("SessionStart", None, 5), ("UserPromptSubmit", None, 5),
+                     ("PreToolUse", DROID_PRETOOL_MATCHER, 5), ("PostToolUse", None, 5),
+                     ("SubagentStop", None, 30), ("Stop", None, 30))
+# Command Code (commandcode.ai/docs/hooks): four events, `timeout` in seconds, and
+# a matcher tested against the tool's display name (SHELL, READ, WRITE, EDIT) -
+# its settings hooks see no other tool, so MCP, subagent and web calls are not
+# gated there. A matcher on SessionStart or Stop stops the hook from firing.
+COMMANDCODE_PRETOOL_MATCHER = "shell|write|edit"
+COMMANDCODE_HOOK_EVENTS = (("SessionStart", None, 5),
+                           ("PreToolUse", COMMANDCODE_PRETOOL_MATCHER, 5),
+                           ("PostToolUse", None, 5), ("Stop", None, 30))
+# GitHub Copilot CLI (docs.github.com hooks-reference): tezgah's own file in the
+# user hooks dir, flat entries with `timeoutSec` in seconds. The PascalCase names
+# get snake_case payloads and Claude tool names; `subagentStart` has no PascalCase
+# form, so its camelCase payload names no event and the command passes it. A
+# PascalCase PreToolUse matcher is anchored and tested against the Claude tool
+# name; an MCP tool is `<server>-<tool>`. A timed-out PreToolUse lets the call
+# through, hence 10 s there.
+COPILOT_PRETOOL_MATCHER = "^(?:Bash|Write|Edit|Agent|Task|Grep|.+-.+)$"
+COPILOT_HOOK_EVENTS = (("SessionStart", None, 5), ("UserPromptSubmit", None, 5),
+                       ("PreToolUse", COPILOT_PRETOOL_MATCHER, 10), ("PostToolUse", None, 5),
+                       ("PostToolUseFailure", None, 5), ("subagentStart", None, 5),
+                       ("SubagentStop", None, 30), ("Stop", None, 30))
+# Gemini CLI (geminicli hooks reference): `timeout` in MILLISECONDS, a BeforeTool
+# matcher is a regex over the tool name, a lifecycle matcher an exact string (so
+# none). A subagent is a tool of its own name; an MCP tool is
+# `mcp_<server>_<tool>`. AfterAgent runs the integrity rule, which may ask a judge.
+GEMINI_PRETOOL_MATCHER = ("^(run_shell_command|write_file|replace|grep_search|"
+                          "search_file_content|codebase_investigator|generalist|"
+                          "invoke_agent|mcp_.*)$")
+GEMINI_HOOK_EVENTS = (("SessionStart", None, 5000), ("BeforeAgent", None, 5000),
+                      ("BeforeTool", GEMINI_PRETOOL_MATCHER, 5000),
+                      ("AfterTool", None, 5000), ("AfterAgent", None, 30000))
+# Antigravity CLI (docs/hooks): `timeout` in seconds; a tool event is a matcher
+# group (a regex over the tool name, "" for every tool), a lifecycle event a bare
+# handler. The payload names no event, so the command does (argv[1]). An MCP
+# tool's name is undocumented, so none is matched. Stop runs the integrity rule.
+ANTIGRAVITY_PRETOOL_MATCHER = ("^(run_command|write_to_file|replace_file_content|"
+                               "multi_replace_file_content|invoke_subagent|grep_search)$")
+ANTIGRAVITY_HOOK_EVENTS = (("SessionStart", None, 5), ("PreInvocation", None, 5),
+                           ("PreToolUse", ANTIGRAVITY_PRETOOL_MATCHER, 5),
+                           ("PostToolUse", "", 5), ("Stop", None, 30))
+# Goose (docs guides/context-engineering/hooks): `timeout` in seconds, a matcher a
+# regex tested unanchored (so anchored here) against the tool name. The built-in
+# developer tools are bare (`shell`, `write`, `edit`), an extension's tool is
+# `<extension>__<tool>`. Only PreToolUse and Stop can block; Stop runs the
+# integrity rule. `on_failure` is left at its default `allow` (X-D2).
+GOOSE_PRETOOL_MATCHER = "^(shell|write|edit|.+__.+)$"
+GOOSE_HOOK_EVENTS = (("SessionStart", None, 5), ("UserPromptSubmit", None, 5),
+                     ("PreToolUse", GOOSE_PRETOOL_MATCHER, 5), ("PostToolUse", None, 5),
+                     ("PostToolUseFailure", None, 5), ("Stop", None, 30))
 # The feature selection for THIS run: None means "read config.json['features']",
 # and an absent key there means the registry's declared default, which is what
 # makes a config written before this existed behave exactly as it used to.
@@ -454,14 +558,22 @@ def hook_entries(hosts):
     what re-arming would change."""
     out = {}
     for h in hosts:
-        if h in ("codex", "cursor"):
-            groups = codex_hook_groups() if h == "codex" else cursor_hook_entries()
+        if h in ("codex", "cursor", "qwen", "droid", "commandcode", "copilot", "gemini",
+                 "antigravity", "goose"):
+            groups = {"codex": codex_hook_groups, "cursor": cursor_hook_entries,
+                      "qwen": qwen_hook_groups, "droid": droid_hook_groups,
+                      "commandcode": commandcode_hook_groups,
+                      "copilot": copilot_hook_entries, "gemini": gemini_hook_groups,
+                      "antigravity": antigravity_hook_groups,
+                      "goose": goose_hook_groups}[h]()
             out[h] = ta.own_groups({"hooks": {ev: [g] for ev, g in groups.items()}})
         elif h == "opencode":
             src = os.path.join(HERE, "hosts", "opencode", "plugins", "tezgah.js")
             out[h] = {d: src for d in ta.OPENCODE_DIRS}
         elif h == "omp":
             out[h] = {"bridge": omp_bridge()}
+        elif h == "amp":
+            out[h] = {"plugin": ta.amp_plugin(HERE)}
         else:
             out[h] = ta.registration(h, HERE)[0] or {}
     return out
@@ -665,7 +777,13 @@ def write_json(path, data):
     An unchanged write is not free: it moves a host file's mtime and lays down a
     `.tezgah-bak`, so a command whose whole point is idempotence (a repeated
     --disable) would report a change it never made. Returns True when it wrote."""
-    text = json.dumps(data, indent=2) + "\n"
+    return write_text(path, json.dumps(data, indent=2) + "\n")
+
+
+def write_text(path, text):
+    """write_json's write for text already rendered (a JSON-with-comments file
+    edited in place): unchanged bytes skip it, a backup comes first, and the
+    file keeps its mode. Returns True when it wrote."""
     try:
         with open(path, encoding="utf-8") as fh:
             if fh.read() == text:
@@ -675,8 +793,15 @@ def write_json(path, data):
     mkdirp(os.path.dirname(path))
     backup(path)
     tmp = path + ".tmp"
-    with open(tmp, "w", encoding="utf-8") as fh:
+    existed = os.path.exists(path)
+    # over an existing file the copy is born owner-only, then takes the file's
+    # mode: a settings file holding provider keys is never readable by others,
+    # not even between the write and the mode copy
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600 if existed else 0o666)
+    with open(fd, "w", encoding="utf-8") as fh:
         fh.write(text)
+    if existed:
+        shutil.copymode(path, tmp)  # an owner-only config stays owner-only
     os.replace(tmp, path)
     return True
 
@@ -713,7 +838,8 @@ def backup_base(path):
 
 def backup(path):
     """Copy `path` to `<backup_base>.<timestamp>.tezgah-bak` before a write
-    changes it.
+    changes it, owner-only: a host config can hold provider keys (Qwen's
+    settings.json does), and a copy must not be readable where the file was not.
 
     The suffix stays `.tezgah-bak`, so managed() and the uninstall cleanup still
     know it; past BACKUP_CAP the middle copies go, never the oldest."""
@@ -729,6 +855,7 @@ def backup(path):
     try:
         mkdirp(os.path.dirname(dst))
         shutil.copy2(path, dst)
+        os.chmod(dst, 0o600)
         d, name = os.path.split(base)
         old = sorted(entry for entry in os.listdir(d or ".")
                      if (m := BACKUP_RE.fullmatch(entry)) and m.group(1) == name)
@@ -1039,7 +1166,10 @@ def install_common(new_roots, hosts):
         (tp.roots() or [tp.DEFAULT_ROOT])
     if tp.codegraph_bin():
         cfg["codegraph_bin"] = tp.codegraph_bin()
-    cfg["hosts"] = hosts
+    # merged with the record, never replaced: arming one host must not drop
+    # the others, whose wiring stays on disk and which --upgrade reads from here
+    recorded = cfg.get("hosts") if isinstance(cfg.get("hosts"), list) else []
+    cfg["hosts"] = recorded + [h for h in hosts if h not in recorded]
     # The resolved selection, written beside roots/hosts: the next run reads one
     # persisted answer instead of the flags some earlier run happened to carry,
     # which is what lets --disable mean anything. A key absent here (and in the
@@ -1081,6 +1211,15 @@ def install_common(new_roots, hosts):
             ("tezgah-render-table", os.path.join(HERE, "skills", "plan-add", "render_table.py")),
             ("tezgah-codex-hook", os.path.join(HERE, "hosts", "codex", "hook.py")),
             ("tezgah-cursor-hook", os.path.join(HERE, "hosts", "cursor", "hook.py")),
+            ("tezgah-qwen-hook", os.path.join(HERE, "hosts", "qwen", "hook.py")),
+            ("tezgah-droid-hook", os.path.join(HERE, "hosts", "droid", "hook.py")),
+            ("tezgah-commandcode-hook",
+             os.path.join(HERE, "hosts", "commandcode", "hook.py")),
+            ("tezgah-copilot-hook", os.path.join(HERE, "hosts", "copilot", "hook.py")),
+            ("tezgah-gemini-hook", os.path.join(HERE, "hosts", "gemini", "hook.py")),
+            ("tezgah-antigravity-hook",
+             os.path.join(HERE, "hosts", "antigravity", "hook.py")),
+            ("tezgah-goose-hook", os.path.join(HERE, "hosts", "goose", "hook.py")),
             ("tezgah-statusline", os.path.join(HERE, "statusline.py")),
             ("tezgah-triage", os.path.join(HERE, "bin", "tezgah-triage")),
             ("tezgah-migrate", os.path.join(HERE, "bin", "tezgah-migrate")),
@@ -1090,6 +1229,8 @@ def install_common(new_roots, hosts):
             ("tezgah-route", os.path.join(HERE, "bin", "tezgah-route")),
             ("tezgah-lessons", os.path.join(HERE, "bin", "tezgah-lessons")),
             ("tezgah-skill", os.path.join(HERE, "bin", "tezgah-skill")),
+            ("tezgah-review-quote", os.path.join(HERE, "bin", "tezgah-review-quote")),
+            ("tezgah-ocr-review", os.path.join(HERE, "bin", "tezgah-ocr-review")),
             # `tezgah` is this installer under the name `tezgah update` is typed
             # with (npm ships the same name). Not here on purpose: tezgah-dsh
             # (wired as ~/.local/bin/dsh, see dsh_launcher) and
@@ -1594,7 +1735,7 @@ def opencode_contract():
 def contract_artifacts(hosts):
     """{path: (fresh render, writer)} for every always-on contract artifact
     these hosts read: the managed block of each static rules file (Claude,
-    Codex, omp) and opencode's contract and skill routers."""
+    Codex, omp, Qwen, Droid) and opencode's contract and skill routers."""
     out = {}
     for h in hosts:
         if h in STATIC_RULES:
@@ -1647,6 +1788,11 @@ def skill_description(path):
     else:
         inline = re.search(r"description:\s*(.+)", block.group(1))
         desc = inline.group(1).strip().strip("\"'") if inline else ""
+    return _trigger_line(desc)
+
+
+def _trigger_line(desc):
+    """The sentence of `desc` carrying its `Use when ...` trigger, cut at 140."""
     desc = re.sub(r"\s+", " ", desc).strip()
     sentences = re.split(r"(?<=[.!?])\s+", desc)
     line = next((s for s in sentences if re.match(r"(?:Also )?[Uu]se\b", s)),
@@ -1654,6 +1800,22 @@ def skill_description(path):
     return line[:137].rstrip() + "..." if len(line) > 140 else line
 
 
+def skill_when_line(path):
+    """The trigger line of a SKILL.md body's `## When to use` first paragraph.
+
+    The frontmatter description is a short bilingual trigger list now, too short
+    for two near-neighbours to share subject words; the long text it replaced
+    opens the body's `## When to use`, and that is what still tells them apart.
+    Best effort like skill_description: anything unreadable yields ""."""
+    try:
+        with open(path, encoding="utf-8", errors="replace") as fh:
+            text = fh.read()
+    except OSError:
+        return ""
+    para = re.search(r"^## When to use\n\s*\n(.*?)(?:\n\s*\n|\Z)", text, re.M | re.S)
+    return _trigger_line(para.group(1)) if para else ""
+
+
 def skill_category(name, path=""):
     if name in RESEARCH_SKILLS:
         return "research & papers"
@@ -1734,12 +1896,12 @@ under out up down off again more most other some such only own same too very can
 will just don should now read reads reading use used uses using also one two
 three every each any all both new old
 """.split())
-# Two skills a session could pick either way from: their router lines share this
-# many subject words, so the description alone cannot settle the choice. Three is
-# where the shipped set stops pairing near-neighbours - `plan-add` / `plan-status`
-# / `plan-sync` share four terms and `product-analysis` / `feature-audit` three,
-# while at two `harness` / `no-ai-slop` pair over "asks, user" and the section
-# reads as noise.
+# Two skills a session could pick either way from: the trigger lines of their
+# `## When to use` share this many subject words, so the description alone
+# cannot settle the choice. Three is where the shipped set pairs near-neighbours -
+# `plan-add` / `plan-status` / `plan-sync` share four or five terms,
+# `product-analysis` / `feature-audit` and `design-contract` / `design-library`
+# three - while `ponytail` / `i-have-adhd` stay apart.
 COLLISION_SHARED = 3
 
 
@@ -1758,7 +1920,7 @@ def skill_collisions(groups):
     router is what a session picks from when the descriptions tie. It reads the
     shipped names only: a vendored library's internal collisions are its own
     index's business, and a pair tezgah cannot rename is not a tezgah decision."""
-    lines = {name: skill_description(path)
+    lines = {name: skill_when_line(path)
              for cat in ROUTER_ORDER for name, path in groups[cat]
              if name in SKILLS}
     names = sorted(lines)
@@ -1778,7 +1940,8 @@ def _collision_section(pairs):
     out = [
         "## Collisions",
         "",
-        "Pairs a description alone cannot settle: both router lines carry the"
+        "Pairs a description alone cannot settle: both entries' `## When to use`"
+        " lines carry the"
         " words below, so a session could pick either way from them. Read both"
         " entries before choosing.",
         "",
@@ -1856,20 +2019,38 @@ def install_opencode():
     write_artifact(SKILL_ROUTER_FULL, full, write_if_changed)
     print("%s %s (always-on, %d chars)" % (OK, SKILL_ROUTER, len(always)))
     print("%s %s (on demand, %d chars)" % (OK, SKILL_ROUTER_FULL, len(full)))
-    # TUI status line: opencode has no command statusLine, only a TUI plugin
-    # declared in tui.json. Local path spec resolves relative to tui.json.
-    print(link(os.path.join(HERE, "hosts", "opencode", "tui", "tezgah-tui.tsx"),
-               os.path.join(OPENCODE, "tui-plugins", "tezgah-tui.tsx")))
-    tpath = os.path.join(OPENCODE, "tui.json")
-    tui = read_config(tpath, {"$schema": "https://opencode.ai/tui.json"})
-    if tui is not None:
-        plugins = tui.get("plugin") or []
-        spec = "./tui-plugins/tezgah-tui.tsx"
-        if spec not in [p if isinstance(p, str) else p[0] for p in plugins]:
-            plugins.append(spec)
-        tui["plugin"] = plugins
-        write_json(tpath, tui)
-        print("%s tui.json (status line plugin)" % OK)
+    # TUI status line: opencode has no command statusLine, only a TUI plugin.
+    # opencode 1 declares it in tui.json (a local spec resolves relative to it);
+    # opencode 2 ignores tui.json and lists CLI plugins in cli.json `plugins`. A
+    # local v2 entry must name a DIRECTORY whose `tui` module default-exports
+    # Plugin.define({id, setup}) - a spec naming a file is skipped (measured on
+    # v2.0.32) - so the directory hosts/opencode/tui/cli is what gets linked.
+    v2 = opencode_v2()
+    if v2:
+        dst = OPENCODE_CLI_PLUGIN
+        print(link(os.path.join(HERE, "hosts", "opencode", "tui", "cli"), dst))
+        cpath = os.path.join(OPENCODE, "cli.json")
+        cli = read_config(cpath, {})
+        if cli is not None:
+            plugins = cli.get("plugins") or []
+            if "file://" + dst not in plugins:
+                plugins.append("file://" + dst)
+            cli["plugins"] = plugins
+            write_json(cpath, cli)
+            print("%s cli.json (status line plugin)" % OK)
+    else:
+        print(link(os.path.join(HERE, "hosts", "opencode", "tui", "tezgah-tui.tsx"),
+                   os.path.join(OPENCODE, "tui-plugins", "tezgah-tui.tsx")))
+        tpath = os.path.join(OPENCODE, "tui.json")
+        tui = read_config(tpath, {"$schema": "https://opencode.ai/tui.json"})
+        if tui is not None:
+            plugins = tui.get("plugin") or []
+            spec = "./tui-plugins/tezgah-tui.tsx"
+            if spec not in [p if isinstance(p, str) else p[0] for p in plugins]:
+                plugins.append(spec)
+            tui["plugin"] = plugins
+            write_json(tpath, tui)
+            print("%s tui.json (status line plugin)" % OK)
     cfg = read_config(os.path.join(OPENCODE, "opencode.json"),
                       {"$schema": "https://opencode.ai/config.json"})
     if cfg is None:
@@ -1921,7 +2102,8 @@ def install_opencode():
     # Context hygiene: prune replaces old tool results in the prompt with
     # "[Old tool result content cleared]" so a long session stops re-sending
     # every output on every step. setdefault keeps a user's explicit choice.
-    cfg.setdefault("compaction", {}).setdefault("prune", True)
+    if not v2:  # opencode 2 omits it as an unsupported legacy setting
+        cfg.setdefault("compaction", {}).setdefault("prune", True)
     wat = cfg.setdefault("watcher", {})
     ign = wat.setdefault("ignore", [])
     for pat in OPENCODE_IGNORE:
@@ -1929,7 +2111,8 @@ def install_opencode():
             ign.append(pat)
     changed = write_json(os.path.join(OPENCODE, "opencode.json"), cfg)
     print("%s opencode.json (instructions + skill router + mcp + skill deny)" % OK)
-    print("%s opencode.json (compaction.prune + watcher.ignore)" % OK)
+    print("%s opencode.json (%swatcher.ignore)"
+          % (OK, "" if v2 else "compaction.prune + "))
     if changed or dropped:
         restart_hint("opencode", os.path.join(OPENCODE, "opencode.json"))
 
@@ -2026,6 +2209,470 @@ def install_cursor():
         restart_hint("cursor", mpath)
 
 
+def qwen_hook_groups():
+    """{event: the group install_qwen writes}; `hook_entries` plans from it."""
+    cmd = tp.hook_command(os.path.join(tp.BIN_DIR, "tezgah-qwen-hook"))
+    out = {}
+    for ev, matcher, timeout in QWEN_HOOK_EVENTS:
+        group = {"matcher": matcher} if matcher else {}
+        group["hooks"] = [{"type": "command", "command": cmd, "timeout": timeout}]
+        out[ev] = group
+    return out
+
+
+def install_qwen():
+    """Qwen Code: hook groups and the status line in `settings.json`, skill
+    links, and the always-on block in `QWEN.md`. settings.json is shared - Orca
+    writes its own hooks there and the user keeps provider keys in it - so only a
+    group naming tezgah is replaced, the test uninstall drops by, and the backup
+    `write_json` lays down is owner-only (`backup`)."""
+    print("\nqwen:")
+    path = os.path.join(QWEN, "settings.json")
+    data = read_config(path, {})
+    if data is not None:
+        hooks = data.setdefault("hooks", {})
+        for ev, group in qwen_hook_groups().items():
+            arr = hooks.setdefault(ev, [])
+            arr[:] = [e for e in arr if "tezgah" not in json.dumps(e)]
+            arr.append(group)
+        # Qwen's command status line: the session JSON on stdin, ANSI kept
+        data.setdefault("ui", {})["statusLine"] = {
+            "type": "command",
+            "command": tp.hook_command(
+                os.path.join(tp.BIN_DIR, "tezgah-statusline")) + " --qwen",
+            "respectUserColors": True,
+        }
+        write_json(path, data)
+        print("%s %s (hooks + ui.statusLine)" % (OK, path))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(QWEN, "skills", s)))
+    print("%s %s (always-on contract)" % (OK, write_rules("qwen")))
+
+
+def droid_hook_groups():
+    """{event: the group install_droid writes}; `hook_entries` plans from it."""
+    cmd = tp.hook_command(os.path.join(tp.BIN_DIR, "tezgah-droid-hook"))
+    out = {}
+    for ev, matcher, timeout in DROID_HOOK_EVENTS:
+        group = {"matcher": matcher} if matcher else {}
+        group["hooks"] = [{"type": "command", "command": cmd, "timeout": timeout}]
+        out[ev] = group
+    return out
+
+
+# a JSON string, kept, or a `//` / `/* */` comment, dropped
+JSONC_TOKENS = re.compile(r'("(?:\\.|[^"\\])*")|//[^\n]*|/\*.*?\*/', re.S)
+
+
+def read_jsonc(path):
+    """The object in a JSON-with-comments file (Droid's settings.json), {} when
+    the file is absent, None when it does not parse. A whole rewrite would drop
+    the user's comments, so the only writers are `jsonc_put`/`jsonc_drop`.
+    ponytail: a trailing comma inside a string value is dropped too; the readers
+    only ask for top-level keys."""
+    try:
+        with open(path, encoding="utf-8") as fh:
+            text = fh.read()
+    except FileNotFoundError:
+        return {}
+    except OSError:
+        return None
+    return jsonc_loads(text)
+
+
+def droid_hooks_blocked():
+    """Why tezgah must not create ~/.factory/hooks.json, or None. Droid reads the
+    `hooks` key of settings.json only while hooks.json is absent, so creating one
+    beside such a key would switch the user's own hooks off."""
+    if os.path.exists(os.path.join(DROID, "hooks.json")):
+        return None
+    path = os.path.join(DROID, "settings.json")
+    data = read_jsonc(path)
+    if data is None:
+        return "%s does not parse, so its `hooks` key cannot be ruled out" % path
+    if "hooks" in data:
+        return ("%s carries a `hooks` key, which Droid ignores once hooks.json "
+                "exists - move those hooks into hooks.json, then re-run --install" % path)
+    return None
+
+
+def droid_statusline():
+    return tp.hook_command(os.path.join(tp.BIN_DIR, "tezgah-statusline")) + " --droid"
+
+
+def jsonc_loads(text):
+    """read_jsonc's parse of text already read: the object, or None."""
+    text = re.sub(r",(\s*[}\]])", r"\1", JSONC_TOKENS.sub(lambda m: m.group(1) or "", text))
+    try:
+        data = json.loads(text)
+    except ValueError:
+        return None
+    return data if isinstance(data, dict) else None
+
+
+# the object's opening brace, past any comment or string before it
+JSONC_OPEN = re.compile(r'("(?:\\.|[^"\\])*")|//[^\n]*|/\*.*?\*/|(\{)', re.S)
+
+
+def jsonc_put(text, key, value):
+    """`text` (JSON with comments) with the top-level `key` set to `value` and
+    every comment kept, or None when that cannot be done safely: the file does
+    not parse, the key holds an object or list, or the edit would change
+    anything else. An absent key goes in as one line under the opening brace,
+    the shape `jsonc_drop` takes back out."""
+    data = jsonc_loads(text)
+    if data is None:
+        return None
+    want = dict(data, **{key: value})
+    if key in data:
+        if data[key] == value:
+            return text
+        if isinstance(data[key], (dict, list)):
+            return None
+        new = re.sub(r'("%s"\s*:\s*)%s' % (re.escape(key), re.escape(json.dumps(data[key]))),
+                     lambda m: m.group(1) + json.dumps(value), text, count=1)
+    else:
+        brace = next((m for m in JSONC_OPEN.finditer(text) if m.group(2)), None)
+        if brace is None:
+            return None
+        line = "\n  %s: %s%s" % (json.dumps(key), json.dumps(value), "," if data else "")
+        new = text[:brace.end()] + line + text[brace.end():]
+    return new if jsonc_loads(new) == want else None
+
+
+def jsonc_drop(text, key, value):
+    """`text` without the one-line `key: value` member `jsonc_put` inserted, or
+    None when that exact line is not there or its removal changes anything else."""
+    data = jsonc_loads(text)
+    if data is None or data.get(key) != value:
+        return None
+    new = re.sub(r'\n[ \t]*%s: %s,?' % (re.escape(json.dumps(key)), re.escape(json.dumps(value))),
+                 "", text, count=1)
+    # the line's own comma may now sit before the closing brace (comments may
+    # follow it): take it out, unless the file already carried one there
+    tail = r",(\s*}(?:\s|//[^\n]*|/\*.*?\*/)*)$"
+    if not re.search(tail, text, re.S):
+        new = re.sub(tail, r"\1", new, flags=re.S)
+    rest = dict(data)
+    rest.pop(key)
+    return new if jsonc_loads(new) == rest else None
+
+
+def install_droid():
+    """Factory Droid: hook groups in `~/.factory/hooks.json`, the status line in
+    `settings.json`, skill links, and the always-on block in `AGENTS.md`.
+    hooks.json may hold the user's own groups, so only a group naming tezgah is
+    replaced. It is not created while settings.json declares hooks
+    (`droid_hooks_blocked`). settings.json is JSON with comments, so the status
+    line and `includeCoAuthoredByDroid: false` (no co-author trailer: the
+    no-attribution rule) are edited in place with every comment kept
+    (`jsonc_put`); a file that cannot be edited safely is left alone and named."""
+    print("\ndroid:")
+    path = os.path.join(DROID, "hooks.json")
+    why = droid_hooks_blocked()
+    if why:
+        print("%s %s not written: %s" % (NO, path, why))
+    else:
+        data = read_config(path, {})
+        if data is not None:
+            for ev, group in droid_hook_groups().items():
+                arr = data.setdefault(ev, [])
+                arr[:] = [e for e in arr if "tezgah" not in json.dumps(e)]
+                arr.append(group)
+            write_json(path, data)
+            print("%s %s (hooks)" % (OK, path))
+    spath = os.path.join(DROID, "settings.json")
+    try:
+        with open(spath, encoding="utf-8") as fh:
+            text = fh.read()
+    except FileNotFoundError:
+        text = "{}\n"
+    except OSError:
+        text = None
+    # the command's stdout is drawn above the input (settings reference)
+    line = {"command": droid_statusline()}
+    try:
+        plain = json.loads(text) if text is not None else None
+    except ValueError:
+        plain = None  # comments: edit in place
+    if why:
+        pass  # the install stopped at the user's own `hooks` key: settings stays as it is
+    elif isinstance(plain, dict):
+        # plain JSON (an earlier install wrote it): set both keys and rewrite, as before
+        ours = "tezgah-statusline" in json.dumps(plain.get("statusLine") or "")
+        if ours or "statusLine" not in plain:
+            plain["statusLine"] = line
+        plain["includeCoAuthoredByDroid"] = False
+        write_json(spath, plain)
+        print("%s %s (statusLine%s, includeCoAuthoredByDroid false)" % (
+            OK, spath, "" if plain["statusLine"] == line else " left as the user set it"))
+    elif text is not None:
+        old = (jsonc_loads(text) or {}).get("statusLine")
+        stale = old != line and "tezgah-statusline" in json.dumps(old or "")
+        if stale:
+            dropped = jsonc_drop(text, "statusLine", old)  # an earlier install's line
+            text, stale = (dropped, False) if dropped is not None else (text, True)
+        # each key on its own: a user's own statusLine never blocks the trailer switch
+        new = jsonc_put(text, "statusLine", line) or text
+        new = jsonc_put(new, "includeCoAuthoredByDroid", False) or new
+        if new != text:
+            write_text(spath, new)
+        done = jsonc_loads(new) or {}
+        print("%s %s (statusLine%s, includeCoAuthoredByDroid %s)" % (
+            OK if done.get("includeCoAuthoredByDroid") is False and not stale else NO, spath,
+            "" if done.get("statusLine") == line else
+            " from an earlier install could not be refreshed: set it with /statusline to `%s`"
+            % line["command"] if stale else " left as the user set it",
+            "false" if done.get("includeCoAuthoredByDroid") is False else "not set: edit by hand"))
+    else:
+        print("%s %s cannot be read: set the status line with /statusline to `%s` and "
+              "`includeCoAuthoredByDroid` to false" % (NO, spath, droid_statusline()))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(DROID, "skills", s)))
+    print("%s %s (always-on contract)" % (OK, write_rules("droid")))
+
+
+def commandcode_hook_groups():
+    """{event: the group install_commandcode writes}; `hook_entries` plans from it."""
+    cmd = tp.hook_command(os.path.join(tp.BIN_DIR, "tezgah-commandcode-hook"))
+    out = {}
+    for ev, matcher, timeout in COMMANDCODE_HOOK_EVENTS:
+        group = {"matcher": matcher} if matcher else {}
+        group["hooks"] = [{"type": "command", "command": cmd, "timeout": timeout}]
+        out[ev] = group
+    return out
+
+
+def install_commandcode():
+    """Command Code: hook groups in the `hooks` key of
+    `~/.commandcode/settings.json`, skill links, and the always-on block in
+    `AGENTS.md`. settings.json is the user's file, so only a group naming tezgah
+    is replaced and the backup is owner-only (`backup`). The same write turns
+    off the default `Co-authored-by: CommandCodeBot` commit trailer
+    (`attribution.commit` "", docs/settings) unless the user set a value."""
+    print("\ncommandcode:")
+    path = os.path.join(COMMANDCODE, "settings.json")
+    data = read_config(path, {})
+    if data is not None:
+        hooks = data.setdefault("hooks", {})
+        for ev, group in commandcode_hook_groups().items():
+            arr = hooks.setdefault(ev, [])
+            arr[:] = [e for e in arr if "tezgah" not in json.dumps(e)]
+            arr.append(group)
+        attr = data.setdefault("attribution", {})
+        if isinstance(attr, dict) and "commit" not in attr:
+            attr["commit"] = ""
+        write_json(path, data)
+        print("%s %s (hooks + attribution.commit)" % (OK, path))
+        if not isinstance(attr, dict) or attr.get("commit") != "":
+            print("%s %s keeps your attribution.commit, so commits still carry a "
+                  "co-author trailer" % (NO, path))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(COMMANDCODE, "skills", s)))
+    print("%s %s (always-on contract)" % (OK, write_rules("commandcode")))
+
+
+def copilot_hook_entries():
+    """{event: the entry install_copilot writes}; `hook_entries` plans from it."""
+    cmd = tp.hook_command(os.path.join(tp.BIN_DIR, "tezgah-copilot-hook"))
+    out = {}
+    for ev, matcher, timeout in COPILOT_HOOK_EVENTS:
+        entry = {"type": "command", "timeoutSec": timeout,
+                 # a camelCase payload names no event, so the command does
+                 "command": cmd + " " + ev if ev[0].islower() else cmd}
+        if matcher:
+            entry["matcher"] = matcher
+        out[ev] = entry
+    return out
+
+
+def copilot_statusline():
+    return tp.hook_command(os.path.join(tp.BIN_DIR, "tezgah-statusline")) + " --copilot"
+
+
+def install_copilot():
+    """GitHub Copilot CLI: `$COPILOT_HOME/hooks/tezgah.json`, a hooks file wholly
+    tezgah's (the inline `hooks` key of settings.json is never used: one bad item
+    there rejects every hook in it), the status line and `includeCoAuthoredBy`
+    in settings.json, skill links, and the always-on block in
+    `copilot-instructions.md`. settings.json is JSON with comments, so it is
+    written only while it parses as plain JSON; `includeCoAuthoredBy` (default
+    true, a `Co-authored-by` trailer on the agent's commits) is set false unless
+    the user set it."""
+    print("\ncopilot:")
+    path = os.path.join(COPILOT, "hooks", "tezgah.json")
+    write_json(path, {"version": 1, "hooks": {ev: [e] for ev, e in
+                                              copilot_hook_entries().items()}})
+    print("%s %s (hooks)" % (OK, path))
+    spath = os.path.join(COPILOT, "settings.json")
+    settings = read_json(spath, None) if os.path.exists(spath) else {}
+    if isinstance(settings, dict):
+        settings["statusLine"] = {"type": "command", "command": copilot_statusline()}
+        settings.setdefault("includeCoAuthoredBy", False)
+        write_json(spath, settings)
+        print("%s %s (statusLine + includeCoAuthoredBy)" % (OK, spath))
+        if settings["includeCoAuthoredBy"] is not False:
+            print("%s %s keeps your includeCoAuthoredBy, so commits still carry a "
+                  "co-author trailer" % (NO, spath))
+    else:
+        print("%s %s holds comments, which a rewrite would drop: set `statusLine` to "
+              "`%s` and `includeCoAuthoredBy` to false there" % (NO, spath,
+                                                                  copilot_statusline()))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(COPILOT, "skills", s)))
+    print("%s %s (always-on contract)" % (OK, write_rules("copilot")))
+
+
+def gemini_hook_groups():
+    """{event: the group install_gemini writes}; `hook_entries` plans from it."""
+    cmd = tp.hook_command(os.path.join(tp.BIN_DIR, "tezgah-gemini-hook"))
+    out = {}
+    for ev, matcher, timeout in GEMINI_HOOK_EVENTS:
+        group = {"matcher": matcher} if matcher else {}
+        group["hooks"] = [{"type": "command", "command": cmd, "timeout": timeout}]
+        out[ev] = group
+    return out
+
+
+def install_gemini():
+    """Gemini CLI: tezgah's own extension dir, `gemini-extension.json` beside
+    `hooks/hooks.json` and `skills/` links, wholly tezgah's; and the always-on
+    block in `GEMINI.md`. settings.json is never written: it is JSON with
+    comments and holds the user's keys. Gemini's default prompt adds no
+    co-author trailer and no setting names one, so there is nothing to turn off."""
+    print("\ngemini:")
+    write_json(os.path.join(GEMINI_EXT, "gemini-extension.json"),
+               {"name": "tezgah", "version": plugin_version(),
+                "description": "tezgah lifecycle hooks and skills"})
+    path = os.path.join(GEMINI_EXT, "hooks", "hooks.json")
+    write_json(path, {"hooks": {ev: [g] for ev, g in gemini_hook_groups().items()}})
+    print("%s %s (extension hooks)" % (OK, path))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(GEMINI_EXT, "skills", s)))
+    print("%s %s (always-on contract)" % (OK, write_rules("gemini")))
+
+
+def antigravity_hook_groups():
+    """{event: the item install_antigravity writes under hooks.json's `tezgah`
+    name}: a matcher group for a tool event, a bare handler for the others
+    (docs/hooks "Schema and file format"); `hook_entries` plans from it."""
+    cmd = tp.hook_command(os.path.join(tp.BIN_DIR, "tezgah-antigravity-hook"))
+    out = {}
+    for ev, matcher, timeout in ANTIGRAVITY_HOOK_EVENTS:
+        handler = {"type": "command", "command": cmd + " " + ev, "timeout": timeout}
+        out[ev] = handler if matcher is None else {"matcher": matcher, "hooks": [handler]}
+    return out
+
+
+def antigravity_statusline():
+    return tp.hook_command(os.path.join(tp.BIN_DIR, "tezgah-statusline")) + " --antigravity"
+
+
+def install_antigravity():
+    """Antigravity CLI: tezgah's hook set under the top-level `tezgah` name of
+    `~/.gemini/config/hooks.json`, beside the user's other names (hooks in
+    antigravity-cli/settings.json are never loaded, docs/hooks); the Antigravity
+    App and IDE read that file too. The status line in
+    `~/.gemini/antigravity-cli/settings.json`, written only while it is plain
+    JSON; skill links in `antigravity-cli/skills`; the always-on block in the
+    `~/.gemini/GEMINI.md` Gemini CLI shares. Antigravity adds no co-author
+    trailer of its own and no setting names one, so there is nothing to turn off."""
+    print("\nantigravity:")
+    data = read_config(AGY_HOOKS, {})
+    if data is not None:
+        data["tezgah"] = {ev: [g] for ev, g in antigravity_hook_groups().items()}
+        write_json(AGY_HOOKS, data)
+        print("%s %s (hooks; the Antigravity App and IDE load them too)" % (OK, AGY_HOOKS))
+    spath = os.path.join(ANTIGRAVITY, "settings.json")
+    settings = read_json(spath, None) if os.path.exists(spath) else {}
+    if isinstance(settings, dict):
+        settings["statusLine"] = {"type": "command", "command": antigravity_statusline()}
+        write_json(spath, settings)
+        print("%s %s (statusLine)" % (OK, spath))
+    else:
+        print("%s %s is not plain JSON, which a rewrite would lose: set `statusLine` "
+              "to {\"type\": \"command\", \"command\": \"%s\"} there"
+              % (NO, spath, antigravity_statusline()))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(ANTIGRAVITY, "skills", s)))
+    print("%s %s (always-on contract)" % (OK, write_rules("antigravity")))
+
+
+def goose_hook_groups():
+    """{event: the group install_goose writes}; `hook_entries` plans from it."""
+    cmd = tp.hook_command(os.path.join(tp.BIN_DIR, "tezgah-goose-hook"))
+    out = {}
+    for ev, matcher, timeout in GOOSE_HOOK_EVENTS:
+        group = {"matcher": matcher} if matcher else {}
+        group["hooks"] = [{"type": "command", "command": cmd, "timeout": timeout}]
+        out[ev] = group
+    return out
+
+
+def install_goose():
+    """Goose: tezgah's own plugin dir, `~/.agents/plugins/tezgah/`, wholly
+    tezgah's - `plugin.json` beside `hooks/hooks.json` and `skills/` links (Goose
+    loads them as `tezgah:<skill>`) - and the always-on block in
+    `~/.config/goose/.goosehints`. The user's other `~/.agents` content is never
+    touched. `on_failure` stays at its default `allow`, so a hook fault lets the
+    call through. Neither Goose's docs nor its system prompt add a co-author
+    trailer or name a setting for one, so there is nothing to turn off."""
+    print("\ngoose:")
+    write_json(os.path.join(GOOSE_PLUGIN, "plugin.json"),
+               {"name": "tezgah", "version": plugin_version(),
+                "description": "tezgah lifecycle hooks and skills"})
+    path = os.path.join(GOOSE_PLUGIN, "hooks", "hooks.json")
+    write_json(path, {"hooks": {ev: [g] for ev, g in goose_hook_groups().items()}})
+    print("%s %s (plugin hooks)" % (OK, path))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(GOOSE_PLUGIN, "skills", s)))
+    print("%s %s (always-on contract)" % (OK, write_rules("goose")))
+
+
+def amp_settings():
+    """(path, settings dict or None): Amp's user settings.json as tezgah may
+    rewrite it - absent reads as {}, and None stands for a file tezgah must not
+    touch: one that is not plain JSON, or a settings.jsonc beside it (which of
+    the two wins is undocumented)."""
+    path = os.path.join(AMP, "settings.json")
+    if os.path.exists(os.path.join(AMP, "settings.jsonc")):
+        return path, None
+    return path, read_json(path, None) if os.path.exists(path) else {}
+
+
+def install_amp():
+    """Amp: one system plugin file, `$XDG_CONFIG_HOME/amp/plugins/tezgah.ts`,
+    rendered from `hosts/amp/tezgah-plugin.ts.in` (Amp loads every .ts there,
+    nothing registers it); skill links in `~/.config/amp/skills`; the always-on
+    block in `~/.config/amp/AGENTS.md`; and Amp's two commit trailers set off
+    in settings.json unless the user set them."""
+    print("\namp:")
+    plugin = ta.amp_plugin(HERE)
+    if not plugin:
+        print("%s %s: this tree has no hosts/amp/tezgah-plugin.ts.in to render"
+              % (NO, AMP_PLUGIN))
+    elif write_if_changed(AMP_PLUGIN, plugin):
+        print("%s %s (plugin: gate + ledger + Stop rule)" % (OK, AMP_PLUGIN))
+        print("%s amp: run `plugins: reload` in a running Amp to load it" % OK)
+    spath, settings = amp_settings()
+    if isinstance(settings, dict):
+        for key in AMP_ATTRIBUTION:
+            settings.setdefault(key, False)
+        write_json(spath, settings)
+        print("%s %s (commit trailers off)" % (OK, spath))
+        for key in AMP_ATTRIBUTION:
+            if settings[key] is not False:
+                print("%s %s keeps your %s, so the agent's commits still carry "
+                      "that trailer" % (NO, spath, key))
+    else:
+        print("%s %s is not plain JSON (or settings.jsonc exists): set %s to false "
+              "there" % (NO, spath, " and ".join("`%s`" % k for k in AMP_ATTRIBUTION)))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(AMP, "skills", s)))
+    print("%s %s (always-on contract)" % (OK, write_rules("amp")))
+
+
+
 def dsh_app_mcp_rows():
     """One dsh-mcp-client row per MCP server tezgah writes into the block.
 
@@ -2410,7 +3057,32 @@ CLAUDE_RULES = os.path.join(CLAUDE, "CLAUDE.md")
 # and where that file is. A lambda per row, because codex_rules() answers from
 # the disk (AGENTS.override.md wins when it exists).
 STATIC_RULES = {"claude": lambda: CLAUDE_RULES, "codex": codex_rules,
-                "omp": lambda: os.path.join(OMP_AGENT, "RULES.md")}
+                "omp": lambda: os.path.join(OMP_AGENT, "RULES.md"),
+                "qwen": lambda: os.path.join(QWEN, "QWEN.md"),
+                "droid": lambda: os.path.join(DROID, "AGENTS.md"),
+                "commandcode": lambda: os.path.join(COMMANDCODE, "AGENTS.md"),
+                "copilot": lambda: os.path.join(COPILOT, "copilot-instructions.md"),
+                "gemini": lambda: os.path.join(GEMINI, "GEMINI.md"),
+                "antigravity": lambda: os.path.join(os.path.dirname(ANTIGRAVITY), "GEMINI.md"),
+                "goose": lambda: os.path.join(GOOSE, ".goosehints"),
+                "amp": lambda: os.path.join(AMP, "AGENTS.md")}
+# Gemini CLI and Antigravity both load ~/.gemini/GEMINI.md, so they share ONE
+# managed block: an uninstall strips it only while no other host of this tuple
+# that reads the same file stays armed (`gemini_md_kept`; GEMINI_CLI_HOME moves
+# Gemini's copy away), and each host's uninstall asks the same question, so the
+# last one out takes the block.
+GEMINI_MD_HOSTS = ("gemini", "antigravity")
+# the hosts the running uninstall takes out (`uninstall` sets it)
+UNINSTALLING = ()
+
+
+def gemini_md_kept(host):
+    """True while another GEMINI_MD_HOSTS host this uninstall does not touch is
+    armed and reads `host`'s GEMINI.md."""
+    armed = tp.config().get("hosts") or []
+    path = STATIC_RULES[host]()
+    return any(h in armed and h not in UNINSTALLING and STATIC_RULES[h]() == path
+               for h in GEMINI_MD_HOSTS)
 
 
 def rules_block(host):
@@ -2525,7 +3197,11 @@ def install_omp():
 
 INSTALLERS = {"claude": install_claude, "codex": install_codex,
               "opencode": install_opencode, "cursor": install_cursor,
-              "dsh": install_dsh, "omp": install_omp}
+              "dsh": install_dsh, "omp": install_omp, "qwen": install_qwen,
+              "droid": install_droid, "commandcode": install_commandcode,
+              "copilot": install_copilot, "gemini": install_gemini,
+              "antigravity": install_antigravity, "goose": install_goose,
+              "amp": install_amp}
 
 
 def install_openresearch(hosts):
@@ -2945,6 +3621,20 @@ def _run_bounded(argv, timeout):
         except OSError:
             pass
         proc.wait()
+        # a member mid-fork as the kill swept the group can come out of the
+        # fork unsignalled (macOS under load: the orphan held the caller's
+        # pipes, plan 115), so signal the group again until it is empty. Each
+        # round catches what forked since the last and a healthy group is gone
+        # within a few; the 2 s cap only bounds one that will not die (a member
+        # stuck in uninterruptible I/O, a zombie nobody reaps) so the Ctrl-C
+        # still returns.
+        deadline = time.monotonic() + 2
+        while time.monotonic() < deadline:
+            try:
+                os.killpg(proc.pid, signal.SIGKILL)
+            except OSError:  # ESRCH: nothing left in the group
+                break
+            time.sleep(0.01)
         raise
 
 
@@ -3363,9 +4053,12 @@ def verify_uninstall(hosts, full):
     if "opencode" in hosts:
         claim("opencode plugin unlinked",
               [os.path.join(OPENCODE, d, "tezgah.js") for d in ("plugins", "plugin")]
-              + [os.path.join(OPENCODE, "tui-plugins", "tezgah-tui.tsx")])
+              + [os.path.join(OPENCODE, "tui-plugins", n)
+                 for n in ("tezgah-tui.tsx", "tezgah-cli")])
         clean("opencode opencode.json unwired",
               [os.path.join(OPENCODE, "opencode.json")])
+        clean("opencode cli.json unwired", [os.path.join(OPENCODE, "cli.json")],
+              needle=OPENCODE_CLI_PLUGIN)
         claim("opencode generated routers gone", [SKILL_ROUTER, SKILL_ROUTER_FULL])
     if "cursor" in hosts:
         clean("cursor hooks.json unwired", [os.path.join(CURSOR, "hooks.json")])
@@ -3388,6 +4081,67 @@ def verify_uninstall(hosts, full):
         claim("omp skills unlinked",
               [os.path.join(OMP_AGENT, "skills", s) for s in SKILLS
                if os.path.lexists(os.path.join(OMP_AGENT, "skills", s))])
+    if "qwen" in hosts:
+        clean("qwen settings.json unwired", [os.path.join(QWEN, "settings.json")])
+        clean("qwen global QWEN.md block gone", [os.path.join(QWEN, "QWEN.md")],
+              needle="<!-- tezgah:start")
+        claim("qwen skills unlinked",
+              [os.path.join(QWEN, "skills", s) for s in SKILLS
+               if os.path.lexists(os.path.join(QWEN, "skills", s))])
+    if "droid" in hosts:
+        clean("droid hooks.json unwired", [os.path.join(DROID, "hooks.json")])
+        clean("droid settings.json statusLine gone", [os.path.join(DROID, "settings.json")],
+              needle="tezgah-statusline")
+        clean("droid global AGENTS.md block gone", [os.path.join(DROID, "AGENTS.md")],
+              needle="<!-- tezgah:start")
+        claim("droid skills unlinked",
+              [os.path.join(DROID, "skills", s) for s in SKILLS
+               if os.path.lexists(os.path.join(DROID, "skills", s))])
+    if "commandcode" in hosts:
+        clean("commandcode settings.json unwired",
+              [os.path.join(COMMANDCODE, "settings.json")])
+        clean("commandcode global AGENTS.md block gone",
+              [os.path.join(COMMANDCODE, "AGENTS.md")], needle="<!-- tezgah:start")
+        claim("commandcode skills unlinked",
+              [os.path.join(COMMANDCODE, "skills", s) for s in SKILLS
+               if os.path.lexists(os.path.join(COMMANDCODE, "skills", s))])
+    if "copilot" in hosts:
+        claim("copilot hooks/tezgah.json gone",
+              [os.path.join(COPILOT, "hooks", "tezgah.json")])
+        clean("copilot settings.json statusLine gone",
+              [os.path.join(COPILOT, "settings.json")], needle="tezgah-statusline")
+        clean("copilot copilot-instructions.md block gone",
+              [os.path.join(COPILOT, "copilot-instructions.md")], needle="<!-- tezgah:start")
+        claim("copilot skills unlinked",
+              [os.path.join(COPILOT, "skills", s) for s in SKILLS
+               if os.path.lexists(os.path.join(COPILOT, "skills", s))])
+    if "gemini" in hosts:
+        claim("gemini extension dir gone", [GEMINI_EXT])
+        if not gemini_md_kept("gemini"):
+            clean("gemini GEMINI.md block gone", [os.path.join(GEMINI, "GEMINI.md")],
+                  needle="<!-- tezgah:start")
+    if "antigravity" in hosts:
+        clean("antigravity config/hooks.json unwired", [AGY_HOOKS],
+              needle="tezgah-antigravity-hook")
+        clean("antigravity settings.json statusLine gone",
+              [os.path.join(ANTIGRAVITY, "settings.json")], needle="tezgah-statusline")
+        claim("antigravity skills unlinked",
+              [os.path.join(ANTIGRAVITY, "skills", s) for s in SKILLS
+               if os.path.lexists(os.path.join(ANTIGRAVITY, "skills", s))])
+        if not gemini_md_kept("antigravity"):
+            clean("antigravity GEMINI.md block gone", [STATIC_RULES["antigravity"]()],
+                  needle="<!-- tezgah:start")
+    if "goose" in hosts:
+        claim("goose plugin dir gone", [GOOSE_PLUGIN])
+        clean("goose .goosehints block gone", [STATIC_RULES["goose"]()],
+              needle="<!-- tezgah:start")
+    if "amp" in hosts:
+        claim("amp plugin gone", [AMP_PLUGIN] if amp_plugin_ours() else [])
+        claim("amp skills unlinked",
+              [os.path.join(AMP, "skills", s) for s in SKILLS
+               if os.path.lexists(os.path.join(AMP, "skills", s))])
+        clean("amp AGENTS.md block gone", [STATIC_RULES["amp"]()],
+              needle="<!-- tezgah:start")
     if "claude" in hosts:
         clean("claude settings.json unwired",
               [os.path.join(CLAUDE, "settings.json")])
@@ -3499,6 +4253,14 @@ def unwire_opencode_config():
                 tj.pop("plugin", None)
             write_json(t, tj)
             print("%s removed tezgah TUI plugin from %s" % (OK, t))
+    cp = os.path.join(OPENCODE, "cli.json")
+    cj = read_json(cp, None)
+    if cj and isinstance(cj.get("plugins"), list):
+        kept = [x for x in cj["plugins"] if x != "file://" + OPENCODE_CLI_PLUGIN]
+        if kept != cj["plugins"]:
+            cj["plugins"] = kept
+            write_json(cp, cj)
+            print("%s removed tezgah CLI plugin from %s" % (OK, cp))
 
 
 def uninstall_claude():
@@ -3560,7 +4322,8 @@ def uninstall_opencode():
         unlink_tezgah(os.path.join(OPENCODE, "skills", s))
     for d in ("plugins", "plugin"):
         unlink_tezgah(os.path.join(OPENCODE, d, "tezgah.js"))
-    unlink_tezgah(os.path.join(OPENCODE, "tui-plugins", "tezgah-tui.tsx"))
+    for name in ("tezgah-tui.tsx", "tezgah-cli"):
+        unlink_tezgah(os.path.join(OPENCODE, "tui-plugins", name))
     unwire_opencode_config()
     for path in (SKILL_ROUTER, SKILL_ROUTER_FULL):
         try:
@@ -3594,6 +4357,213 @@ def uninstall_cursor():
         print("%s removed tezgah statusLine from %s" % (OK, cc))
 
 
+def uninstall_qwen():
+    print("\nqwen:")
+    for s in SKILLS:
+        unlink_tezgah(os.path.join(QWEN, "skills", s))
+    path = os.path.join(QWEN, "settings.json")
+    drop_managed_hook_entries(path)
+    cfg = read_json(path, None)
+    ui = cfg.get("ui") if isinstance(cfg, dict) else None
+    if isinstance(ui, dict) and "tezgah-statusline" in json.dumps(ui.get("statusLine") or {}):
+        ui.pop("statusLine")
+        if not ui:
+            cfg.pop("ui")
+        write_json(path, cfg)
+        print("%s removed tezgah statusLine from %s" % (OK, path))
+    drop_if_empty(path)
+    strip_managed_md(os.path.join(QWEN, "QWEN.md"))
+
+
+def drop_if_empty(path):
+    """Remove a host settings file uninstall emptied: tezgah created it to hold
+    its hooks or status line, and a `{}` the user never had is left over."""
+    if read_json(path, None) == {}:
+        backup(path)
+        os.remove(path)
+        print("%s removed %s (empty once tezgah's keys left)" % (OK, path))
+
+
+def uninstall_droid():
+    print("\ndroid:")
+    for s in SKILLS:
+        unlink_tezgah(os.path.join(DROID, "skills", s))
+    path = os.path.join(DROID, "hooks.json")
+    data = read_json(path, None)
+    if isinstance(data, dict):
+        kept = {}
+        for ev, arr in data.items():
+            if isinstance(arr, list):
+                arr = [e for e in arr if "tezgah" not in json.dumps(e)]
+                if not arr:
+                    continue
+            kept[ev] = arr
+        if kept == data:
+            print("%s no tezgah hook entries in %s" % (OK, path))
+        elif kept:
+            write_json(path, kept)
+            print("%s removed tezgah hook entries from %s" % (OK, path))
+        else:
+            # an empty hooks.json would still hide the `hooks` key of settings.json
+            backup(path)
+            os.remove(path)
+            print("%s removed %s (it held only tezgah's hooks)" % (OK, path))
+    spath = os.path.join(DROID, "settings.json")
+    cfg = read_json(spath, None)
+    if isinstance(cfg, dict) and "tezgah-statusline" in json.dumps(cfg.get("statusLine") or {}):
+        cfg.pop("statusLine")
+        write_json(spath, cfg)
+        print("%s removed tezgah statusLine from %s" % (OK, spath))
+    elif cfg is None and os.path.exists(spath):
+        # JSON with comments: take out the one line install_droid put in, keep
+        # the comments; `includeCoAuthoredByDroid` stays false (the
+        # no-attribution rule is the user's, not tezgah's to undo)
+        with open(spath, encoding="utf-8") as fh:
+            text = fh.read()
+        old = (jsonc_loads(text) or {}).get("statusLine")
+        new = jsonc_drop(text, "statusLine", old) if "tezgah-statusline" in json.dumps(old or "") else None
+        if new is not None:
+            write_text(spath, new)
+            print("%s removed tezgah statusLine from %s" % (OK, spath))
+    drop_if_empty(spath)
+    strip_managed_md(os.path.join(DROID, "AGENTS.md"))
+
+
+def uninstall_commandcode():
+    print("\ncommandcode:")
+    for s in SKILLS:
+        unlink_tezgah(os.path.join(COMMANDCODE, "skills", s))
+    path = os.path.join(COMMANDCODE, "settings.json")
+    drop_managed_hook_entries(path)
+    cfg = read_json(path, None)
+    attr = cfg.get("attribution") if isinstance(cfg, dict) else None
+    # the value install wrote, beside the user's other attribution keys or
+    # alone; as with Claude's, a user's own identical value cannot be told
+    # apart from it, and dropping it only restores Command Code's default
+    if isinstance(attr, dict) and attr.get("commit") == "":
+        attr.pop("commit")
+        if not attr:
+            cfg.pop("attribution")
+        write_json(path, cfg)
+        print("%s removed tezgah's attribution.commit from %s" % (OK, path))
+    drop_if_empty(path)
+    strip_managed_md(os.path.join(COMMANDCODE, "AGENTS.md"))
+
+
+def uninstall_copilot():
+    print("\ncopilot:")
+    for s in SKILLS:
+        unlink_tezgah(os.path.join(COPILOT, "skills", s))
+    path = os.path.join(COPILOT, "hooks", "tezgah.json")
+    if os.path.exists(path):
+        backup(path)
+        os.remove(path)
+        print("%s removed %s" % (OK, path))
+    spath = os.path.join(COPILOT, "settings.json")
+    cfg = read_json(spath, None)
+    if isinstance(cfg, dict):
+        if "tezgah-statusline" in json.dumps(cfg.get("statusLine") or {}):
+            cfg.pop("statusLine")
+        # the value install wrote; a user's own false cannot be told apart from it
+        if cfg.get("includeCoAuthoredBy") is False:
+            cfg.pop("includeCoAuthoredBy")
+        if write_json(spath, cfg):
+            print("%s removed tezgah's statusLine and includeCoAuthoredBy from %s"
+                  % (OK, spath))
+    drop_if_empty(spath)
+    strip_managed_md(os.path.join(COPILOT, "copilot-instructions.md"))
+
+
+def uninstall_gemini():
+    """Delete tezgah's extension dir (its skills are links, unlinked, never
+    followed) and the GEMINI.md block unless Antigravity still reads it."""
+    print("\ngemini:")
+    if os.path.lexists(GEMINI_EXT):
+        for name in ("gemini-extension.json", os.path.join("hooks", "hooks.json")):
+            backup(os.path.join(GEMINI_EXT, name))
+        shutil.rmtree(GEMINI_EXT)
+        print("%s removed %s" % (OK, GEMINI_EXT))
+    if gemini_md_kept("gemini"):
+        print("%s %s keeps the tezgah block: another armed host reads it"
+              % (OK, os.path.join(GEMINI, "GEMINI.md")))
+    else:
+        strip_managed_md(os.path.join(GEMINI, "GEMINI.md"))
+
+
+def uninstall_antigravity():
+    """Take the `tezgah` name out of ~/.gemini/config/hooks.json (the user's
+    other names stay), the statusLine, the skill links, and the GEMINI.md block
+    unless Gemini CLI still reads it."""
+    print("\nantigravity:")
+    for s in SKILLS:
+        unlink_tezgah(os.path.join(ANTIGRAVITY, "skills", s))
+    data = read_json(AGY_HOOKS, None)
+    if isinstance(data, dict) and "tezgah" in data:
+        data.pop("tezgah")
+        write_json(AGY_HOOKS, data)
+        print("%s removed tezgah's hooks from %s" % (OK, AGY_HOOKS))
+    drop_if_empty(AGY_HOOKS)
+    spath = os.path.join(ANTIGRAVITY, "settings.json")
+    cfg = read_json(spath, None)
+    if isinstance(cfg, dict) and "tezgah-statusline" in json.dumps(cfg.get("statusLine") or {}):
+        cfg.pop("statusLine")
+        write_json(spath, cfg)
+        print("%s removed tezgah's statusLine from %s" % (OK, spath))
+    drop_if_empty(spath)
+    rules = STATIC_RULES["antigravity"]()
+    if gemini_md_kept("antigravity"):
+        print("%s %s keeps the tezgah block: another armed host reads it" % (OK, rules))
+    else:
+        strip_managed_md(rules)
+
+
+def uninstall_goose():
+    """Delete tezgah's plugin dir (its skills are links, unlinked, never
+    followed) and the .goosehints block; the rest of ~/.agents is the user's."""
+    print("\ngoose:")
+    if os.path.lexists(GOOSE_PLUGIN):
+        for name in ("plugin.json", os.path.join("hooks", "hooks.json")):
+            backup(os.path.join(GOOSE_PLUGIN, name))
+        shutil.rmtree(GOOSE_PLUGIN)
+        print("%s removed %s" % (OK, GOOSE_PLUGIN))
+    strip_managed_md(STATIC_RULES["goose"]())
+
+
+def amp_plugin_ours():
+    """True when the file at AMP_PLUGIN is tezgah's: a fresh render, or one an
+    older tree rendered (it starts with AMP_HEADER). A user's own plugin of
+    that name is never removed."""
+    try:
+        with open(AMP_PLUGIN, encoding="utf-8") as fh:
+            text = fh.read()
+    except OSError:
+        return False
+    return text == ta.amp_plugin(HERE) or text.startswith(ta.AMP_HEADER)
+
+
+def uninstall_amp():
+    """Delete tezgah's plugin file (only when it is tezgah's), the skill links,
+    the AGENTS.md block, and each commit-trailer key while it is still false."""
+    print("\namp:")
+    if amp_plugin_ours():
+        backup(AMP_PLUGIN)
+        os.remove(AMP_PLUGIN)
+        print("%s removed %s" % (OK, AMP_PLUGIN))
+    elif os.path.lexists(AMP_PLUGIN):
+        print("%s %s is not tezgah's render: left in place" % (NO, AMP_PLUGIN))
+    for s in SKILLS:
+        unlink_tezgah(os.path.join(AMP, "skills", s))
+    spath, settings = amp_settings()
+    if isinstance(settings, dict) and any(settings.get(k) is False for k in AMP_ATTRIBUTION):
+        for key in AMP_ATTRIBUTION:
+            if settings.get(key) is False:
+                settings.pop(key)
+        write_json(spath, settings)
+        print("%s removed tezgah's commit-trailer keys from %s" % (OK, spath))
+        drop_if_empty(spath)
+    strip_managed_md(STATIC_RULES["amp"]())
+
+
 def uninstall_dsh():
     print("\ndsh:")
     for s in SKILLS:
@@ -3646,7 +4616,11 @@ def uninstall_omp():
 
 UNINSTALLERS = {"claude": uninstall_claude, "codex": uninstall_codex,
                 "opencode": uninstall_opencode, "cursor": uninstall_cursor,
-                "dsh": uninstall_dsh, "omp": uninstall_omp}
+                "dsh": uninstall_dsh, "omp": uninstall_omp, "qwen": uninstall_qwen,
+                "droid": uninstall_droid, "commandcode": uninstall_commandcode,
+                "copilot": uninstall_copilot, "gemini": uninstall_gemini,
+                "antigravity": uninstall_antigravity, "goose": uninstall_goose,
+                "amp": uninstall_amp}
 
 
 def uninstall(hosts, dry_run=False):
@@ -3668,6 +4642,7 @@ def uninstall(hosts, dry_run=False):
     repository's `.tezgah/` research state. A partial run (some armed hosts
     stay) also keeps config.json and the install tree, because the hosts still
     armed read both at runtime."""
+    global UNINSTALLING
     armed = tp.config().get("hosts") or []
     full = not armed or set(hosts) >= set(armed)
     if dry_run:
@@ -3699,6 +4674,7 @@ def uninstall(hosts, dry_run=False):
         print("%s gate stays armed for the hosts this run does not touch" % OK)
     print("uninstalling for: %s (%s run)\n"
           % (", ".join(hosts) or "none detected", "full" if full else "partial"))
+    UNINSTALLING = tuple(hosts)
     uninstall_common()
     for h in hosts:
         UNINSTALLERS[h]()
@@ -3714,6 +4690,13 @@ def uninstall(hosts, dry_run=False):
         remove_install_tree()
     elif armed:
         rest = sorted(set(armed) - set(hosts))
+        # install_common only ever merges into the record, so this is the one
+        # place a host leaves it; kept, it made every later uninstall partial
+        # and `tezgah update` re-armed it from the record
+        cfg = read_config(tp.CONFIG, {})
+        if cfg is not None:
+            cfg["hosts"] = [h for h in armed if h in rest]
+            write_json(tp.CONFIG, cfg)
         print("\n%s still armed: %s keeps its config and the install tree"
               % (NO, ", ".join(rest)))
     remaining = verify_uninstall(hosts, full)
@@ -4034,12 +5017,13 @@ def context_budget_report():
 
 LIVE_TIMEOUT = 20
 LIVE_DENY_COMMAND = "git commit --no-verify -m x"
-# The JS half: loads the omp extension (`--experimental-strip-types`, the .ts as
-# omp's bun would) or the opencode plugin (an ES module, as opencode imports
-# it), registers its handlers against inert host objects and fires one handler:
-# the tool-result one, or with a command the tool-call one, printing what it
-# answered (omp) or what it threw (opencode) as JSON. argv: host, module path,
-# root, session id, command ("" for the tool result).
+# The JS half: loads the omp extension or the Amp plugin
+# (`--experimental-strip-types`, the .ts as their bun would) or the opencode
+# plugin (an ES module, as opencode imports it), registers its handlers against
+# inert host objects and fires one handler: the tool-result one, or with a
+# command the tool-call one, printing what it answered (omp, Amp) or what it
+# threw (opencode) as JSON. argv: host, module path, root, session id, command
+# ("" for the tool result).
 LIVE_DRIVER = r"""
 const [host, mod, root, sid, cmd] = process.argv.slice(1);
 const noop = new Proxy(function () {}, { get: () => noop, apply: () => noop });
@@ -4060,6 +5044,25 @@ const noop = new Proxy(function () {}, { get: () => noop, apply: () => noop });
     }
     await handlers.tool_result({ toolName: "bash", input: { command: "true" },
                                  isError: false, content: "ok" }, ctx);
+  } else if (host === "amp") {
+    // Amp's registry, its two helpers the plugin reads, and a thread context;
+    // no status item (`experimental` absent), so no status spawn either
+    const handlers = {};
+    m.default(new Proxy({ on: (n, fn) => { handlers[n] = fn; }, experimental: undefined,
+                          system: { workspaceRoot: root },
+                          helpers: { filePathFromURI: (u) => String(u),
+                                     shellCommandFromToolCall: (e) => ({ command: e.input.cmd }) } },
+                        { get: (t, k) => (k in t ? t[k] : noop) }));
+    const want = cmd ? "tool.call" : "tool.result";
+    if (!handlers[want]) throw new Error("the plugin registered no " + want + " handler");
+    const ctx = { thread: { id: sid, parentThreadID: async () => null }, ui: noop };
+    const event = { tool: "Bash", input: { cmd: cmd || "true" }, toolUseID: "live",
+                    thread: { id: sid } };
+    if (cmd) {
+      process.stdout.write(JSON.stringify((await handlers[want](event, ctx)) || {}));
+      return;
+    }
+    await handlers[want](Object.assign(event, { status: "done", output: "ok" }), ctx);
   } else {
     const hooks = await (m.Tezgah || m.default)({ directory: root, worktree: root,
                                                   client: noop, $: noop });
@@ -4222,6 +5225,123 @@ def live_plan(host, deny=False):
         if registered is None:
             return plan + ("registration unread: the omp CLI did not answer",)
         return plan
+    if host == "qwen":
+        # the hook command Qwen runs for its shell tool, fed Qwen's own payload;
+        # no qwen binary and no model call (tests/e2e_qwen.py drives the binary)
+        path = os.path.join(QWEN, "settings.json")
+        cmd = _hook_command((read_json(path, {}).get("hooks") or {}).get(event),
+                            "run_shell_command")
+        if not cmd:
+            return ("miss", "no tezgah %s command for run_shell_command in %s"
+                    % (event, path))
+        payload = {"hook_event_name": event, "tool_name": "run_shell_command",
+                   "tool_input": {"command": LIVE_DENY_COMMAND if deny else "true"}}
+        if not deny:
+            payload["tool_response"] = {"llmContent": "", "returnDisplay": ""}
+        return ("shell", cmd, payload, {})
+    if host == "droid":
+        # the hook command Droid runs for Execute, fed Droid's own payload; no
+        # droid binary and no model call (tests/e2e_droid.py drives the binary)
+        path = os.path.join(DROID, "hooks.json")
+        cmd = _hook_command(read_json(path, {}).get(event), "Execute")
+        if not cmd:
+            return ("miss", "no tezgah %s command for Execute in %s" % (event, path))
+        payload = {"hook_event_name": event, "tool_name": "Execute",
+                   "permission_mode": "auto-low",
+                   "tool_input": {"command": LIVE_DENY_COMMAND if deny else "true"}}
+        if not deny:
+            payload["tool_response"] = "\n\n[Process exited with code 0]"
+        return ("shell", cmd, payload, {})
+    if host == "commandcode":
+        # the hook command Command Code runs for its shell tool (the matcher sees
+        # the display name SHELL, case-insensitively), fed its own payload; no
+        # binary and no model call
+        path = os.path.join(COMMANDCODE, "settings.json")
+        cmd = _hook_command((read_json(path, {}).get("hooks") or {}).get(event), "shell")
+        if not cmd:
+            return ("miss", "no tezgah %s command for shell in %s" % (event, path))
+        payload = {"hook_event_name": event, "tool_name": "shell_command",
+                   "tool_display_name": "SHELL", "permission_mode": "default",
+                   "tool_input": {"command": LIVE_DENY_COMMAND if deny else "true"}}
+        if not deny:
+            payload["tool_response"] = ""
+        return ("shell", cmd, payload, {})
+    if host == "copilot":
+        # the hook command Copilot runs for its shell tool (a PascalCase
+        # PreToolUse sees the Claude name Bash), fed its own payload; no binary
+        # and no model call
+        path = os.path.join(COPILOT, "hooks", "tezgah.json")
+        cmd = _hook_command((read_json(path, {}).get("hooks") or {}).get(event), "Bash",
+                            own=True)
+        if not cmd:
+            return ("miss", "no tezgah %s command for Bash in %s" % (event, path))
+        payload = {"hook_event_name": event, "tool_name": "Bash",
+                   "tool_input": {"command": LIVE_DENY_COMMAND if deny else "true"}}
+        if not deny:
+            payload["tool_result"] = {"result_type": "success",
+                                      "text_result_for_llm": "<exited with exit code 0>"}
+        return ("shell", cmd, payload, {})
+    if host == "gemini":
+        # the hook command Gemini runs for its shell tool (BeforeTool/AfterTool),
+        # fed Gemini's own payload; no binary and no model call
+        path = os.path.join(GEMINI_EXT, "hooks", "hooks.json")
+        name = "BeforeTool" if deny else "AfterTool"
+        cmd = _hook_command((read_json(path, {}).get("hooks") or {}).get(name),
+                            "run_shell_command", own=True)
+        if not cmd:
+            return ("miss", "no tezgah %s command for run_shell_command in %s"
+                    % (name, path))
+        payload = {"hook_event_name": name, "tool_name": "run_shell_command",
+                   "tool_input": {"command": LIVE_DENY_COMMAND if deny else "true"}}
+        if not deny:
+            payload["tool_response"] = {"llmContent": "Output: (empty)",
+                                        "returnDisplay": ""}
+        return ("shell", cmd, payload, {})
+    if host == "antigravity":
+        # the hook command Antigravity runs for run_command, under the `tezgah`
+        # name of ~/.gemini/config/hooks.json; it carries the event as argv[1],
+        # since the camelCase payload names none. No binary and no model call
+        cmd = _hook_command((read_json(AGY_HOOKS, {}).get("tezgah") or {}).get(event),
+                            "run_command", own=True)
+        if not cmd:
+            return ("miss", "no tezgah %s command for run_command in %s" % (event, AGY_HOOKS))
+        payload = {"toolCall": {"name": "run_command", "args": {
+            "CommandLine": LIVE_DENY_COMMAND if deny else "true", "WaitMsBeforeAsync": 5000}},
+            "stepIdx": 0}
+        if not deny:
+            payload["error"] = ""
+        return ("shell", cmd, payload, {})
+    if host == "goose":
+        # the hook command Goose runs for its `shell` tool, from tezgah's plugin
+        # hooks.json, fed Goose's own payload (the event in `event`, the
+        # directory as `working_dir`); no binary and no model call
+        path = os.path.join(GOOSE_PLUGIN, "hooks", "hooks.json")
+        cmd = _hook_command((read_json(path, {}).get("hooks") or {}).get(event), "shell",
+                            own=True)
+        if not cmd:
+            return ("miss", "no tezgah %s command for shell in %s" % (event, path))
+        return ("shell", cmd, {"event": event, "tool_name": "shell",
+                               "matcher_context": "shell", "tool_call_id": "tezgah-live",
+                               "tool_input": {"command": LIVE_DENY_COMMAND if deny
+                                              else "true"}}, {})
+    if host == "amp":
+        # the installed plugin itself, loaded by node through LIVE_DRIVER and fed
+        # Amp's own event shape (`tool`, `input.cmd`, `thread.id`); the hook it
+        # spawns is the one Amp would spawn
+        try:
+            with open(AMP_PLUGIN, encoding="utf-8") as fh:
+                text = fh.read()
+        except OSError:
+            return ("miss", "no plugin at %s" % AMP_PLUGIN)
+        if text != ta.amp_plugin(HERE):
+            return ("miss", "%s differs from a fresh render of this tree's plugin "
+                    "- re-run `tezgah-setup --install --hosts amp`" % AMP_PLUGIN)
+        node = _node_for_ts()
+        if not node:
+            return ("unverified", "no node 22.6+ to load %s" % AMP_PLUGIN)
+        # always unverified: Amp's own Bun loader is not what ran it
+        return ("node", [node, "--experimental-strip-types", "--no-warnings"], AMP_PLUGIN,
+                "Amp's own plugin loader is not driven here")
     return ("unverified", "no live probe for this host")
 
 
@@ -4239,6 +5359,21 @@ def _denied(host, stdout):
         return got.get("block") is True
     if host == "opencode":
         return bool(got.get("threw"))
+    if host == "copilot":
+        # top level, not wrapped (hooks-reference "preToolUse decision control")
+        return got.get("permissionDecision") == "deny"
+    if host == "gemini":
+        # top level (hooks reference "BeforeTool"; `block` is its alias)
+        return got.get("decision") in ("deny", "block")
+    if host == "antigravity":
+        # top level; `decision` is required, so an allow answers too (docs/hooks)
+        return got.get("decision") == "deny"
+    if host == "goose":
+        # top level, stdout starting with `{` (hooks "Blocking a Tool Call")
+        return got.get("decision") == "block"
+    if host == "amp":
+        # ToolCallResult (plugin-api): the call is refused, the turn goes on
+        return got.get("action") == "reject-and-continue"
     return (got.get("hookSpecificOutput") or {}).get("permissionDecision") == "deny"
 
 
@@ -4271,7 +5406,13 @@ def live_probe(host, deny=False):
         if plan[0] == "shell":
             _kind, cmd, payload, extra = plan
             env.update(extra)
-            payload = dict(payload, session_id=sid, conversation_id=sid, cwd=root)
+            # Antigravity's envelope is camelCase, with no session_id or cwd;
+            # Goose names the directory `working_dir`
+            payload = (dict(payload, conversationId=sid, workspacePaths=[root])
+                       if host == "antigravity" else
+                       dict(payload, session_id=sid, working_dir=root)
+                       if host == "goose" else
+                       dict(payload, session_id=sid, conversation_id=sid, cwd=root))
             proc = subprocess.run(cmd, shell=True, input=json.dumps(payload),
                                   capture_output=True, text=True, env=env,
                                   cwd=root, timeout=LIVE_TIMEOUT)
@@ -4344,7 +5485,9 @@ ARMING_ROWS = ("hooks.json wired", "plugin wired (link or copy)",
                "carries the contract", "contract in instructions",
                "claude-code hooks bridge in cordis.patch.yml",
                "session, prompt, tool and stop hooks wired",
-               "hook registered in omp extensions", "plugin copy current")
+               "hook registered in omp extensions", "plugin copy current",
+               "settings.json hooks wired", "hooks/tezgah.json wired",
+               "plugin tezgah.ts current")
 
 
 def arming_miss(label, good):
@@ -4376,6 +5519,8 @@ def report(hosts):
         ("codegen provider key (OpenRouter, DeepSeek or Inception)",
          tp.have_provider_key()),
         ("orx on PATH (OpenResearch research routing)", bool(tp.orx_bin())),
+        ("ocr on PATH (open-code-review spec for the reviewer, opt-in)",
+         bool(tp.ocr_bin())),
         ("npx on PATH (app-analysis MCP servers)", bool(shutil.which("npx"))),
         ("app artifacts dir %s" % tezgah_apps.ARTIFACTS,
          os.path.isdir(tezgah_apps.ARTIFACTS)),
@@ -4608,14 +5753,17 @@ def claude_mcp_rows(copies):
     return rows
 
 
-def _hooks_has(path, marker, events=None):
+def _hooks_has(path, marker, events=None, bare=False, key="hooks"):
     """True when `marker` is wired under every event in `events`, or under any
-    event when `events` is None.
+    event when `events` is None. `bare`: the file is keyed by event at the top
+    (Droid's hooks.json); `key`: the top-level name the events sit under
+    (`hooks`, or Antigravity's `tezgah`).
 
     A row that one event can satisfy answers the wrong question: a manifest
     carrying tezgah's command under SessionStart and not under Stop reads as
     wired, and Stop is the integrity refusal."""
-    hooks = (read_json(path, {}) or {}).get("hooks") or {}
+    data = read_json(path, {}) or {}
+    hooks = data if bare else data.get(key) or {}
     if events is None:
         return any(marker in json.dumps(e) for arr in hooks.values() for e in arr)
     return all(any(marker in json.dumps(e) for e in (hooks.get(ev) or []))
@@ -4694,6 +5842,7 @@ def host_checks_codex():
 def host_checks_opencode():
     cfg = read_json(os.path.join(OPENCODE, "opencode.json"), {})
     tui = read_json(os.path.join(OPENCODE, "tui.json"), {})
+    cli = read_json(os.path.join(OPENCODE, "cli.json"), {})
     instr = cfg.get("instructions") or []
     specs = [p if isinstance(p, str) else p[0] for p in (tui.get("plugin") or [])]
     return [
@@ -4711,14 +5860,20 @@ def host_checks_opencode():
     ] + mcp_rows(set(cfg.get("mcp") or {}), "opencode.json") + [
         mcp_row(TEZGAH_MCP_NAME, (cfg.get("mcp") or {}).get(TEZGAH_MCP_NAME),
                 "opencode.json", tezgah_mcp_command()),
+    ] + ([
+        ("status line plugin in cli.json + linked",
+         "file://" + OPENCODE_CLI_PLUGIN in (cli.get("plugins") or [])
+         and os.path.exists(OPENCODE_CLI_PLUGIN)),
+    ] if opencode_v2() else [
         ("context pruning armed (compaction.prune)",
          (cfg.get("compaction") or {}).get("prune") is True),
-        ("watcher ignores noisy trees",
-         bool(set(OPENCODE_IGNORE)
-              & set(((cfg.get("watcher") or {}).get("ignore") or [])))),
         ("status line plugin in tui.json + linked",
          any("tezgah-tui" in s for s in specs)
          and os.path.exists(os.path.join(OPENCODE, "tui-plugins", "tezgah-tui.tsx"))),
+    ]) + [
+        ("watcher ignores noisy trees",
+         bool(set(OPENCODE_IGNORE)
+              & set(((cfg.get("watcher") or {}).get("ignore") or [])))),
         # opencode's own registry declares INCEPTION_API_KEY for the inception
         # provider, so nothing needs adding to opencode.json - but the route is
         # only usable once a key resolves, and that is what this reports.
@@ -4747,6 +5902,157 @@ def host_checks_cursor():
     ]
 
 
+def host_checks_qwen():
+    path = os.path.join(QWEN, "settings.json")
+    # a relocated home (QWEN_HOME) is named, as codex's is
+    where = " in %s" % QWEN if QWEN != os.path.join(tp.HOME, ".qwen") else ""
+    ui = read_json(path, {}).get("ui")
+    return [
+        ("settings.json hooks wired%s" % where,
+         _hooks_has(path, "tezgah-qwen-hook", [ev for ev, _m, _t in QWEN_HOOK_EVENTS])),
+        ("skills linked%s" % where, skills_linked(os.path.join(QWEN, "skills"))),
+        ("QWEN.md carries the contract (matches a fresh render)", rules_current("qwen")),
+        ("statusLine in settings.json ui",
+         "tezgah-statusline" in json.dumps((ui if isinstance(ui, dict) else {})
+                                           .get("statusLine") or {})),
+        ("qwen CLI on PATH", bool(tp.which_user("qwen"))),
+    ]
+
+
+def host_checks_droid():
+    path = os.path.join(DROID, "hooks.json")
+    why = droid_hooks_blocked()
+    settings = read_jsonc(os.path.join(DROID, "settings.json")) or {}
+    status = settings.get("statusLine")
+    return [
+        ("hooks.json wired" + (" (not written: %s)" % why if why else ""),
+         _hooks_has(path, "tezgah-droid-hook", [ev for ev, _m, _t in DROID_HOOK_EVENTS],
+                    bare=True)),
+        ("skills linked", skills_linked(os.path.join(DROID, "skills"))),
+        ("AGENTS.md carries the contract (matches a fresh render)", rules_current("droid")),
+        ("statusLine in settings.json", "tezgah-statusline" in json.dumps(status or {})),
+        ("includeCoAuthoredByDroid off in settings.json",
+         settings.get("includeCoAuthoredByDroid") is False),
+        ("droid CLI on PATH", bool(tp.which_user("droid"))),
+    ]
+
+
+def host_checks_commandcode():
+    path = os.path.join(COMMANDCODE, "settings.json")
+    attr = read_json(path, {}).get("attribution")
+    return [
+        ("settings.json hooks wired",
+         _hooks_has(path, "tezgah-commandcode-hook",
+                    [ev for ev, _m, _t in COMMANDCODE_HOOK_EVENTS])),
+        ("skills linked", skills_linked(os.path.join(COMMANDCODE, "skills"))),
+        ("AGENTS.md carries the contract (matches a fresh render)",
+         rules_current("commandcode")),
+        ("attribution.commit off in settings.json",
+         isinstance(attr, dict) and attr.get("commit") == ""),
+        ("command-code CLI on PATH", bool(tp.which_user("command-code"))),
+    ]
+
+
+def host_checks_copilot():
+    # a relocated home (COPILOT_HOME) is named, as codex's is
+    where = " in %s" % COPILOT if COPILOT != os.path.join(tp.HOME, ".copilot") else ""
+    settings = read_jsonc(os.path.join(COPILOT, "settings.json")) or {}
+    return [
+        ("hooks/tezgah.json wired%s" % where,
+         _hooks_has(os.path.join(COPILOT, "hooks", "tezgah.json"), "tezgah-copilot-hook",
+                    [ev for ev, _m, _t in COPILOT_HOOK_EVENTS])),
+        ("skills linked%s" % where, skills_linked(os.path.join(COPILOT, "skills"))),
+        ("copilot-instructions.md carries the contract (matches a fresh render)",
+         rules_current("copilot")),
+        ("statusLine in settings.json",
+         "tezgah-statusline" in json.dumps(settings.get("statusLine") or {})),
+        ("includeCoAuthoredBy off in settings.json",
+         settings.get("includeCoAuthoredBy") is False),
+        ("copilot CLI on PATH", bool(tp.which_user("copilot"))),
+    ]
+
+
+def host_checks_gemini():
+    # a relocated home (GEMINI_CLI_HOME) is named, as codex's is
+    where = " in %s" % GEMINI if GEMINI != os.path.join(tp.HOME, ".gemini") else ""
+    hooks_cfg = (read_jsonc(os.path.join(GEMINI, "settings.json")) or {}).get("hooksConfig")
+    return [
+        # the hooks load only beside a manifest naming the extension
+        ("extension hooks/hooks.json wired%s" % where,
+         _hooks_has(os.path.join(GEMINI_EXT, "hooks", "hooks.json"), "tezgah-gemini-hook",
+                    [ev for ev, _m, _t in GEMINI_HOOK_EVENTS])
+         and read_json(os.path.join(GEMINI_EXT, "gemini-extension.json"), {})
+         .get("name") == "tezgah"),
+        ("skills linked%s" % where, skills_linked(os.path.join(GEMINI_EXT, "skills"))),
+        ("GEMINI.md carries the contract (matches a fresh render)", rules_current("gemini")),
+        # `hooksConfig.enabled: false` runs no hook at all (configuration)
+        ("hooks left on in settings.json (hooksConfig.enabled)",
+         not (isinstance(hooks_cfg, dict) and hooks_cfg.get("enabled") is False)),
+        ("gemini CLI on PATH", bool(tp.which_user("gemini"))),
+    ]
+
+
+def host_checks_antigravity():
+    settings = read_json(os.path.join(ANTIGRAVITY, "settings.json"), {})
+    mine = read_json(AGY_HOOKS, {}).get("tezgah")
+    return [
+        ("config/hooks.json wired (the `tezgah` name)",
+         _hooks_has(AGY_HOOKS, "tezgah-antigravity-hook",
+                    [ev for ev, _m, _t in ANTIGRAVITY_HOOK_EVENTS], key="tezgah")),
+        # `enabled: false` on a hook name loads none of its events (docs/hooks)
+        ("tezgah hook set left enabled in config/hooks.json",
+         not (isinstance(mine, dict) and mine.get("enabled") is False)),
+        ("skills linked", skills_linked(os.path.join(ANTIGRAVITY, "skills"))),
+        ("GEMINI.md carries the contract (matches a fresh render)",
+         rules_current("antigravity")),
+        ("statusLine in antigravity-cli/settings.json",
+         "tezgah-statusline" in json.dumps(settings.get("statusLine") or {})),
+        ("agy CLI on PATH", bool(tp.which_user("agy"))),
+    ]
+
+
+def host_checks_goose():
+    disabled = read_json(os.path.join(GOOSE, "settings.json"), {}).get("disabledPlugins")
+    return [
+        # the hooks load only from a plugin dir under ~/.agents/plugins
+        ("plugin hooks/hooks.json wired (~/.agents/plugins/tezgah)",
+         _hooks_has(os.path.join(GOOSE_PLUGIN, "hooks", "hooks.json"), "tezgah-goose-hook",
+                    [ev for ev, _m, _t in GOOSE_HOOK_EVENTS])
+         and read_json(os.path.join(GOOSE_PLUGIN, "plugin.json"), {}).get("name") == "tezgah"),
+        # a plugin named in `disabledPlugins` is skipped at discovery (plugins guide)
+        ("tezgah plugin not in disabledPlugins (settings.json)",
+         not (isinstance(disabled, list) and "tezgah" in disabled)),
+        ("skills linked", skills_linked(os.path.join(GOOSE_PLUGIN, "skills"))),
+        (".goosehints carries the contract (matches a fresh render)", rules_current("goose")),
+        ("goose CLI on PATH", bool(tp.which_user("goose"))),
+    ]
+
+
+def host_checks_amp():
+    try:
+        with open(AMP_PLUGIN, encoding="utf-8") as fh:
+            plugin = fh.read()
+    except OSError:
+        plugin = ""
+    # either user settings file; the comment-tolerant reader for both
+    settings = (read_jsonc(os.path.join(AMP, "settings.json")) or {}
+                if not os.path.exists(os.path.join(AMP, "settings.jsonc"))
+                else read_jsonc(os.path.join(AMP, "settings.jsonc")) or {})
+    return [
+        # byte for byte, as omp's bridge row: a hand edit or an older tree's
+        # render is not the wiring this tree arms
+        ("plugin tezgah.ts current (matches a fresh render): %s" % AMP_PLUGIN,
+         bool(plugin) and plugin == ta.amp_plugin(HERE)),
+        ("skills linked", skills_linked(os.path.join(AMP, "skills"))),
+        ("AGENTS.md carries the contract (matches a fresh render)", rules_current("amp")),
+        ("%s off in settings.json" % AMP_ATTRIBUTION[0],
+         settings.get(AMP_ATTRIBUTION[0]) is False),
+        ("%s off in settings.json" % AMP_ATTRIBUTION[1],
+         settings.get(AMP_ATTRIBUTION[1]) is False),
+        ("amp CLI on PATH", bool(tp.which_user("amp"))),
+    ]
+
+
 def host_checks_dsh():
     try:
         with open(DSH_PATCH, encoding="utf-8") as fh:
@@ -4865,7 +6171,11 @@ def host_checks_omp():
 
 HOST_CHECKS = {"claude": host_checks_claude, "codex": host_checks_codex,
                "opencode": host_checks_opencode, "cursor": host_checks_cursor,
-               "dsh": host_checks_dsh, "omp": host_checks_omp}
+               "dsh": host_checks_dsh, "omp": host_checks_omp, "qwen": host_checks_qwen,
+               "droid": host_checks_droid, "commandcode": host_checks_commandcode,
+               "copilot": host_checks_copilot, "gemini": host_checks_gemini,
+               "antigravity": host_checks_antigravity, "goose": host_checks_goose,
+               "amp": host_checks_amp}
 
 
 def versions_agree():
@@ -5923,7 +7233,7 @@ def hosts_row():
     host's first HOST_CHECKS row), as one report row. Reported, never changed:
     `--upgrade`, `--enable`/`--disable` and a full uninstall act on the recorded
     list, so a host wired but not recorded is one they skip, and which list is
-    right is the user's call (`--install --hosts ...` records it)."""
+    right is the user's call (`--install --hosts ...` adds to it)."""
     recorded = sorted(tp.config().get("hosts") or [])
     wired = sorted(h for h in ALL_HOSTS if HOST_CHECKS[h]()[0][1])
     return ("config.json hosts (%s) match the hosts wired (%s)"