@r1z4x/tezgah 1.11.0 → 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
@@ -223,7 +245,8 @@ 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
@@ -324,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.
@@ -468,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
@@ -679,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:
@@ -689,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
 
@@ -727,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."""
@@ -743,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)
@@ -1098,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")),
@@ -1613,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:
@@ -2087,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.
 
@@ -2471,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):
@@ -2586,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):
@@ -3466,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")])
@@ -3681,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:
@@ -3733,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):
@@ -3755,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:
@@ -3786,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]()
@@ -4128,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 });
@@ -4154,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 });
@@ -4316,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")
 
 
@@ -4333,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"
 
 
@@ -4365,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)
@@ -4438,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):
@@ -4704,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 []))
@@ -4850,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:
@@ -4968,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():