@r1z4x/tezgah 1.11.0 → 1.14.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
@@ -239,6 +262,11 @@ SKILL_ROUTER = os.path.join(tp.CONFIG_DIR, "opencode-skills.md")
 # Where `link()` records the entries it had to materialise instead of
 # symlinking; see materialised_paths() for why the fact has to be written down.
 MATERIALISED = os.path.join(tp.CONFIG_DIR, "materialised")
+# What an install found in each host file it edited, so an uninstall puts back
+# exactly that: {path: {"created": bool, "<key>": prior value | ABSENT}}, a key
+# being a "/"-joined path into the file's JSON object. See remember_prior().
+PRIOR = os.path.join(tp.CONFIG_DIR, "install-prior.json")
+ABSENT = "absent"
 # Every kill switch the code reads (`off("...")` under hooks/ and bin/;
 # `bin/tezgah-docs --citations` checks the two agree). The canonical
 # copies die with ~/.config/tezgah; the pre-multi-host setup wrote them to
@@ -257,7 +285,8 @@ OFF_SWITCH_NAMES = ("adhd-off", "agents-off", "consult-off", "design-off", "docs
 # moved aside - the only copy of them on disk.
 GENERATED_STATE = frozenset((
     "bin", "config.json", "contract.sha256", "contract.sha256.lock",
-    "contract.sha256.tmp", "install.log", "materialised",
+    "contract.sha256.tmp", "install-prior.json", "install-prior.json.tmp",
+    "install.log", "materialised",
     "opencode-contract.md", "opencode-skills.md", "opencode-skills.full.md",
     "ponytail.level", "state"))
 # The predecessor harness's marker in an AGENTS.md under a root: the block tells
@@ -324,6 +353,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.
@@ -338,7 +434,20 @@ OK, NO = "  ok  ", " MISS "
 
 
 def mkdirp(p):
+    """makedirs, recording each directory level it creates under HOME (outside
+    tezgah's own config dir) so uninstall removes it once empty (OQ-13)."""
+    made, d = [], os.path.abspath(p)
+    while not os.path.lexists(d) and d != os.path.dirname(d):
+        made.append(d)
+        d = os.path.dirname(d)
     os.makedirs(p, exist_ok=True)
+    made = [d for d in made if not UNINSTALLING and d.startswith(tp.HOME + os.sep)
+            and d != tp.CONFIG_DIR and not d.startswith(tp.CONFIG_DIR + os.sep)]
+    if made:
+        store = read_json(PRIOR, {})
+        for d in made:
+            store[d + os.sep] = {"created": True}
+        _prior_save(store)
 
 
 def expand(p):
@@ -468,14 +577,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
@@ -559,6 +676,132 @@ def record_materialised(path, add=True):
         pass
 
 
+def _prior_save(store):
+    """Write the install-prior record whole (temp file, then replace); an
+    emptied record is removed, so a finished uninstall leaves no file."""
+    try:
+        if not store:
+            if os.path.exists(PRIOR):
+                os.remove(PRIOR)
+            return
+        mkdirp(tp.CONFIG_DIR)
+        with open(PRIOR + ".tmp", "w", encoding="utf-8") as fh:
+            # no sort_keys: a recorded value comes back in its own key order
+            fh.write(json.dumps(store, indent=2, ensure_ascii=False) + "\n")
+        os.replace(PRIOR + ".tmp", PRIOR)
+    except OSError:
+        pass
+
+
+def _key_chain(key):
+    """"a/b/c" -> ["a", "a/b", "a/b/c"]: the key and every parent level."""
+    parts = key.split("/")
+    return ["/".join(parts[:i]) for i in range(1, len(parts) + 1)]
+
+
+def _prior_entry(store, path):
+    """The record of one host file, made empty when absent or not an object:
+    a hand-edited or damaged entry reads as no record, never a traceback."""
+    entry = store.get(path)
+    if not isinstance(entry, dict):
+        entry = store[path] = {}
+    return entry
+
+
+def note_created(path):
+    """Record, the first time tezgah writes a host file, whether the file was
+    there before. The first answer stands: a later write finds tezgah's own file.
+    A file already carrying tezgah's name was written by an install older than
+    the record, so it gets none: its uninstall does what it always did."""
+    real = os.path.abspath(path)
+    if UNINSTALLING or real.startswith(tp.CONFIG_DIR + os.sep) \
+            or not real.startswith(tp.HOME + os.sep):
+        return
+    store = read_json(PRIOR, {})
+    entry = _prior_entry(store, path)
+    if "created" in entry:
+        return
+    if os.path.lexists(path):
+        try:
+            with open(path, encoding="utf-8", errors="replace") as fh:
+                if "tezgah" in fh.read():
+                    return
+        except OSError:
+            pass
+    entry["created"] = not os.path.lexists(path)
+    _prior_save(store)
+
+
+def remember_prior(path, data, key):
+    """Record what `data` - the object read from `path` before tezgah edits
+    it - holds at `key`, once: a later install finds tezgah's own value there,
+    so the first answer is the user's. A missing level is recorded as ABSENT at
+    the first level that is missing, which tells restore_prior() the parents
+    tezgah created too."""
+    store = read_json(PRIOR, {})
+    entry = _prior_entry(store, path)
+    chain = _key_chain(key)
+    if any(k in entry for k in chain):
+        return
+    node = data
+    for k in chain:
+        part = k.rsplit("/", 1)[-1]
+        if not isinstance(node, dict) or part not in node:
+            entry[k] = ABSENT
+            break
+        node = node[part]
+    else:
+        entry[key] = node
+    _prior_save(store)
+
+
+def restore_prior(path, data, key, keep_unrecorded=False):
+    """Put `key` of `data` back to what the install found: the user's value, or
+    no key at all, with every parent level the install created and left empty.
+    An install older than the record left none: the key goes with its emptied
+    parents (what uninstall always did), or stays with `keep_unrecorded`.
+    Returns True when `data` changed; the record forgets the key either way."""
+    store = read_json(PRIOR, {})
+    entry = _prior_entry(store, path)
+    chain = _key_chain(key)
+    rec = next((k for k in chain if k in entry), None)
+    parts = key.split("/")
+    nodes = [data]
+    for part in parts[:-1]:
+        nodes.append(nodes[-1].get(part) if isinstance(nodes[-1], dict) else None)
+    before = json.dumps(data, sort_keys=True)
+    if isinstance(nodes[-1], dict) and not (rec is None and keep_unrecorded):
+        if rec == key and entry[rec] != ABSENT:
+            nodes[-1][parts[-1]] = entry[rec]
+        else:
+            nodes[-1].pop(parts[-1], None)
+            floor = len(rec.split("/")) if rec else 1
+            for depth in range(len(parts) - 1, 0, -1):
+                if depth < floor or nodes[depth]:
+                    break
+                nodes[depth - 1].pop(parts[depth - 1])
+    if rec is not None:
+        for k in chain:
+            entry.pop(k, None)
+        _prior_save(store)
+    return json.dumps(data, sort_keys=True) != before
+
+
+def prior_created(path):
+    """True when the record says tezgah created this host file, False when it
+    says the file was there, None with no record (an install older than it)."""
+    entry = read_json(PRIOR, {}).get(path)
+    created = entry.get("created") if isinstance(entry, dict) else None
+    return created if isinstance(created, bool) else None
+
+
+def forget_prior(path):
+    """Drop the record of one host file once its uninstall is done."""
+    store = read_json(PRIOR, {})
+    if store.pop(path, None) is not None:
+        _prior_save(store)
+
+
 def is_tezgah_copy(path):
     """True when `path` is a real entry this installer materialised where a
     symlink was refused. A same-named file tezgah never wrote is the user's."""
@@ -647,39 +890,98 @@ def read_json(path, default):
     return data
 
 
-# Every host config read_config refused this run; a non-empty list fails it.
+# Every host file this run refused to rewrite; a non-empty list fails it.
 REFUSED = []
 
 
-def read_config(path, empty):
+def read_failure(exc):
+    """The cause a host-file read failed with, in the words a refusal names."""
+    if isinstance(exc, UnicodeDecodeError):
+        return "not UTF-8 text"
+    if isinstance(exc, OSError):
+        return "cannot read it: %s" % (exc.strerror or exc)
+    return "not valid JSON: %s" % exc
+
+
+def refuse(path, why, rerun="--install"):
+    """Name a host file tezgah will not touch and why; an install records it in
+    REFUSED, which fails the run."""
+    print("%s %s (%s; left untouched - fix it, then re-run %s)" % (NO, path, why, rerun))
+    if rerun == "--install":
+        REFUSED.append(path)
+
+
+def read_config(path, empty, comments=False, rerun="--install"):
     """A host config tezgah is about to rewrite: `empty` when the file is absent,
     its object when it parses as one, None otherwise - named, recorded in
     REFUSED, and never written, because a write would replace the user's file
-    with tezgah's default (a trailing comma once cost a whole opencode.json)."""
+    with tezgah's default (a trailing comma once cost a whole opencode.json).
+    With `comments` (a host that reads JSON with comments) a file holding
+    comments is valid as it is: named and left untouched, not refused."""
     try:
         with open(path, encoding="utf-8") as fh:
-            data = json.load(fh)
+            text = fh.read()
+        data = json.loads(text)
     except FileNotFoundError:
         return empty
     except (OSError, ValueError) as exc:
-        why = "not valid JSON: %s" % exc
+        if comments and not isinstance(exc, (OSError, UnicodeDecodeError)) \
+                and jsonc_loads(text) is not None:
+            print("%s %s holds comments - left untouched" % (NO, path))
+            return None
+        why = read_failure(exc)
     else:
         if isinstance(data, dict):
             return data
         why = "not a JSON object: the top level is %s" % type(data).__name__
-    print("%s %s (%s; left untouched - fix it, then re-run --install)"
-          % (NO, path, why))
-    REFUSED.append(path)
+    refuse(path, why, rerun)
     return None
 
 
+def _json_layout(path):
+    """(indent, separators, final newline) of the JSON file at `path`, so a
+    rewrite keeps the user's own layout: a one-line file stays one line (a
+    minified one stays minified), a 4-space or tab indent stays that. A new
+    file, `{}` or an unreadable one gets 2 spaces."""
+    try:
+        with open(path, encoding="utf-8") as fh:
+            text = fh.read()
+    except (OSError, ValueError):
+        return 2, None, True
+    body = text.strip()
+    if body in ("", "{}", "[]"):
+        return 2, None, True
+    m = re.search(r"\n([ \t]*)\S", body)
+    if m:
+        return m.group(1), None, text.endswith("\n")
+    # ponytail: a string value holding ": " misreads a minified file as spaced
+    tight = not re.search(r"[:,] ", body)
+    return None, ((",", ":") if tight else None), text.endswith("\n")
+
+
 def write_json(path, data):
-    """Write JSON, skipping the write when the bytes are already there.
+    """Write JSON in the file's own layout, skipping the write when the bytes
+    are already there.
 
     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"
+    --disable) would report a change it never made. The first write of a host
+    file records whether tezgah created it (note_created). Returns True when it
+    wrote."""
+    note_created(path)
+    # ponytail: one indent for the whole file - an inline `[1, 2]` or
+    # `{"a": 1}` inside an indented file comes back expanded (same data);
+    # keeping it would need a layout-preserving JSON writer
+    indent, seps, newline = _json_layout(path)
+    return write_text(path, json.dumps(data, indent=indent, separators=seps,
+                                       ensure_ascii=False)
+                      + ("\n" if newline else ""))
+
+
+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 +991,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 +1036,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 +1053,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)
@@ -813,6 +1124,7 @@ def set_managed_block(path, block, start="# tezgah:start", end="# tezgah:end"):
         out.pop()
     if not out:
         out = ["# dsh home patch layer - tezgah-setup manages the marked block below"]
+    note_created(path)
     mkdirp(os.path.dirname(path))
     text = "\n".join(out) + "\n" + start + " (managed by tezgah-setup; do not edit)\n" \
         + block.strip() + "\n" + end + "\n"
@@ -1076,7 +1388,13 @@ def install_common(new_roots, hosts):
         # older one, so an upgrade changes no one's reply language
         cfg["language"] = tp.env_language() if first else "tr"
     if own:
-        write_json(tp.CONFIG, cfg)
+        try:
+            write_json(tp.CONFIG, cfg)
+        except OSError as exc:
+            # a HOME the install cannot write: every later step would fail the
+            # same way, so the run stops here and names the path (B-100)
+            sys.exit("%s cannot write %s: %s"
+                     % (NO, exc.filename or tp.CONFIG, exc.strerror or exc))
         print("%s %s  roots=%s" % (OK, tp.CONFIG, cfg["roots"]))
     for name, src in [
             ("consult", os.path.join(HERE, "bin", "consult")),
@@ -1089,6 +1407,9 @@ def install_common(new_roots, hosts):
             ("tezgah-rollback", os.path.join(HERE, "bin", "tezgah-rollback")),
             ("tezgah-agents", os.path.join(HERE, "bin", "tezgah-agents")),
             ("tezgah-context", os.path.join(HERE, "bin", "tezgah-context")),
+            # cited by the contract skill and the taste hook as farm paths
+            ("tezgah-optimize", os.path.join(HERE, "bin", "tezgah-optimize")),
+            ("tezgah-taste", os.path.join(HERE, "bin", "tezgah-taste")),
             ("tezgah-capture", os.path.join(HERE, "bin", "tezgah-capture")),
             ("tezgah-doctor", os.path.join(HERE, "bin", "tezgah-doctor")),
             ("tezgah-setup", os.path.join(HERE, "bin", "tezgah-setup")),
@@ -1098,6 +1419,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")),
@@ -1192,7 +1522,7 @@ def install_claude():
     # tracked project file. Claude's hook drops the core when the block is there
     # (`TEZGAH_CORE_IN_FILE`, hooks/projects-auto-init.py), so a session pays for
     # the contract once.
-    print("%s %s (always-on contract)" % (OK, write_rules("claude")))
+    write_rules("claude")
     write_user_agents("claude")
     register_claude_plugin()
 
@@ -1355,7 +1685,8 @@ def wire_claude_attribution():
 
 def wire_claude_statusline():
     """Point Claude's statusLine at tezgah's wrapper (it forwards to Orca, then
-    appends the tezgah segment). Backed up; skipped when already correct."""
+    appends the tezgah segment). The user's own statusLine is recorded first, so
+    uninstall puts it back. Backed up; skipped when already correct."""
     sp = os.path.join(CLAUDE, "settings.json")
     settings = read_json(sp, None)
     if settings is None:
@@ -1365,6 +1696,8 @@ def wire_claude_statusline():
     if (settings.get("statusLine") or {}).get("command") == cmd:
         print("%s statusLine -> tezgah" % OK)
         return
+    if "statusline.py" not in json.dumps(settings.get("statusLine") or {}):
+        remember_prior(sp, settings, "statusLine")
     settings["statusLine"] = {"type": "command", "command": cmd}
     write_json(sp, settings)
     print("%s statusLine -> tezgah (previous kept as %s.<timestamp>.tezgah-bak)" % (OK, sp))
@@ -1411,7 +1744,7 @@ def install_codex():
     # SessionStart hook's context is one message, where this file is the
     # instructions Codex keeps for the whole session. Global, like omp's
     # RULES.md, because a per-project file would be a tracked project file.
-    print("%s %s (always-on contract)" % (OK, write_rules("codex")))
+    write_rules("codex")
     write_user_agents("codex")
 
 
@@ -1536,9 +1869,11 @@ def strip_toml_mcp(path, names):
         return False
     out, skip, changed = [], False, False
     for line in lines:
-        m = re.match(r"\[mcp_servers\.([^\]]+)\]", line.strip())
-        if m:
-            skip = m.group(1) in names
+        # every table header ends the one before it: a user table after a
+        # tezgah [mcp_servers.*] one stays, and a tezgah sub-table goes with it
+        if line.strip().startswith("["):
+            m = re.match(r"\[mcp_servers\.([^\].]+)[\].]", line.strip())
+            skip = bool(m) and m.group(1) in names
             changed = changed or skip
         if not skip:
             out.append(line)
@@ -1597,8 +1932,12 @@ def write_artifact(path, text, write):
 
     The writers are idempotent (write_if_changed, set_managed_md): a re-render
     that produces the same bytes moves no mtime and lays no backup. Returns True
-    when the file changed."""
+    when the file changed, None when the writer refused it (named in REFUSED):
+    a file never written gets no sha, so it still reads as stale."""
+    refused = len(REFUSED)
     changed = write(path, text)
+    if len(REFUSED) > refused:
+        return None
     if recorded_shas().get(path) != _sha(text):
         record_contract(path, text)
     return changed
@@ -1613,7 +1952,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:
@@ -1933,7 +2272,10 @@ def install_opencode():
                       {"$schema": "https://opencode.ai/config.json"})
     if cfg is None:
         return
+    # a file that already carries tezgah's wiring holds tezgah's prune, not the
+    # user's: an install with no record must not store it as the prior value
     instr = cfg.get("instructions") or []
+    wired = any(isinstance(i, str) and "tezgah" in i for i in instr)
     for extra in (contract, SKILL_ROUTER):
         if extra not in instr:
             instr.append(extra)
@@ -1981,6 +2323,9 @@ def install_opencode():
     # "[Old tool result content cleared]" so a long session stops re-sending
     # every output on every step. setdefault keeps a user's explicit choice.
     if not v2:  # opencode 2 omits it as an unsupported legacy setting
+        comp = cfg.get("compaction")
+        if not (wired and isinstance(comp, dict) and comp.get("prune") is True):
+            remember_prior(os.path.join(OPENCODE, "opencode.json"), cfg, "compaction/prune")
         cfg.setdefault("compaction", {}).setdefault("prune", True)
     wat = cfg.setdefault("watcher", {})
     ign = wat.setdefault("ignore", [])
@@ -2052,6 +2397,12 @@ def install_cursor():
     cc = os.path.join(CURSOR, "cli-config.json")
     cfg = read_config(cc, {})
     if cfg is not None:
+        # the user's own statusLine (and a file with no `version`) come back
+        # at uninstall, from the install-prior record; a file already carrying
+        # tezgah's statusLine holds tezgah's values, not the user's
+        if "tezgah-statusline" not in json.dumps(cfg.get("statusLine") or {}):
+            remember_prior(cc, cfg, "version")
+            remember_prior(cc, cfg, "statusLine")
         cfg.setdefault("version", 1)
         cfg["statusLine"] = {
             "type": "command",
@@ -2087,6 +2438,512 @@ 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;
+        # the user's own comes back at uninstall, from the install-prior record
+        if "tezgah-statusline" not in json.dumps(data.get("ui") or {}):
+            remember_prior(path, data, "ui/statusLine")
+        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)))
+    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, ValueError):  # unreadable, or not UTF-8
+        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, ValueError):  # unreadable, or not UTF-8
+        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 "")
+        # the user's own trailer setting comes back at uninstall (OQ-15); a false
+        # beside tezgah's own status line is the one an older install wrote
+        if not (ours and plain.get("includeCoAuthoredByDroid") is False):
+            remember_prior(spath, plain, "includeCoAuthoredByDroid")
+        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:
+        found = jsonc_loads(text)
+        old = (found or {}).get("statusLine")
+        if isinstance(found, dict) and not (
+                "tezgah-statusline" in json.dumps(old or "")
+                and found.get("includeCoAuthoredByDroid") is False):
+            remember_prior(spath, found, "includeCoAuthoredByDroid")
+        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)))
+    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:
+        attr = data.get("attribution")
+        # hooks already naming tezgah: the "" commit beside them is the one an
+        # older install wrote, not the user's prior value
+        ours = "tezgah" in json.dumps(data.get("hooks") or {}) \
+            and isinstance(attr, dict) and attr.get("commit") == ""
+        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)
+        # a commit value the user already had comes back at uninstall (OQ-15)
+        if not ours:
+            remember_prior(path, data, "attribution/commit")
+        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)))
+    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_config(spath, {}, comments=True)
+    if isinstance(settings, dict):
+        wired = "tezgah-statusline" in json.dumps(settings.get("statusLine") or {})
+        if not wired:
+            remember_prior(spath, settings, "statusLine")
+        settings["statusLine"] = {"type": "command", "command": copilot_statusline()}
+        # a value the user already had comes back at uninstall (OQ-15); a false
+        # beside tezgah's own status line is the one an older install wrote
+        if not (wired and settings.get("includeCoAuthoredBy") is False):
+            remember_prior(spath, settings, "includeCoAuthoredBy")
+        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 set `statusLine` to `%s` and `includeCoAuthoredBy` to false in %s "
+              "by hand" % (NO, copilot_statusline(), spath))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(COPILOT, "skills", s)))
+    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)))
+    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_config(spath, {}, comments=True)
+    if isinstance(settings, dict):
+        if "tezgah-statusline" not in json.dumps(settings.get("statusLine") or {}):
+            remember_prior(spath, settings, "statusLine")
+        settings["statusLine"] = {"type": "command", "command": antigravity_statusline()}
+        write_json(spath, settings)
+        print("%s %s (statusLine)" % (OK, spath))
+    else:
+        print("%s set `statusLine` to {\"type\": \"command\", \"command\": \"%s\"} in "
+              "%s by hand" % (NO, antigravity_statusline(), spath))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(ANTIGRAVITY, "skills", s)))
+    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)))
+    write_rules("goose")
+
+
+def amp_settings(rerun="--install"):
+    """(path, settings dict or None): Amp's user settings file as tezgah may
+    rewrite it, the one answer for install, uninstall and the report.
+    settings.jsonc stands in for settings.json when it is the only one; with
+    both there, which Amp reads is undocumented and neither is touched. Absent
+    reads as {}; a file holding comments is named and left untouched, an
+    unreadable one refused. `rerun=None` (the report) reads without a word."""
+    path = os.path.join(AMP, "settings.json")
+    jsonc = os.path.join(AMP, "settings.jsonc")
+    if os.path.exists(jsonc):
+        if os.path.exists(path):
+            if rerun:
+                refuse(path, "%s exists beside it, and which of the two Amp reads "
+                       "is undocumented" % jsonc, rerun)
+            return path, None
+        path = jsonc
+    if rerun is None:
+        return path, read_jsonc(path)
+    return path, read_config(path, {}, comments=True, rerun=rerun)
+
+
+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:")
+    wired = amp_plugin_ours()  # an earlier install's plugin, before this one writes
+    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:
+            # a value the user already had comes back at uninstall (OQ-15); a
+            # false beside tezgah's own plugin is the one an older install wrote
+            if not (wired and settings.get(key) is False):
+                remember_prior(spath, settings, key)
+            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 set %s to false in %s by hand"
+              % (NO, " and ".join("`%s`" % k for k in AMP_ATTRIBUTION), spath))
+    for s in SKILLS:
+        print(link(os.path.join(HERE, "skills", s), os.path.join(AMP, "skills", s)))
+    write_rules("amp")
+
+
+
 def dsh_app_mcp_rows():
     """One dsh-mcp-client row per MCP server tezgah writes into the block.
 
@@ -2330,12 +3187,17 @@ def write_if_changed(path, text):
 def set_managed_md(path, block, start="<!-- tezgah:start -->",
                    end="<!-- tezgah:end -->"):
     """Replace the marked block in a markdown file, or append it, keeping any
-    user text around it. Markdown gets HTML-comment markers, not `#`."""
+    user text around it. Markdown gets HTML-comment markers, not `#`. A file
+    that is there but cannot be read (no read bit, not UTF-8) is refused, never
+    replaced by the block alone. Returns True when the file changed."""
     try:
         with open(path, encoding="utf-8") as fh:
             lines = fh.read().splitlines()
-    except OSError:
+    except FileNotFoundError:
         lines = []
+    except (OSError, ValueError) as exc:
+        refuse(path, read_failure(exc))
+        return False
     out, skip = [], False
     for ln in lines:
         if ln.strip().startswith(start):
@@ -2432,7 +3294,10 @@ def strip_managed_md(path):
     try:
         with open(path, encoding="utf-8") as fh:
             text = fh.read()
-    except OSError:
+    except FileNotFoundError:
+        return
+    except (OSError, ValueError) as exc:
+        refuse(path, read_failure(exc), "--uninstall")
         return
     kept = re.sub(r"<!-- tezgah:start -->.*?<!-- tezgah:end -->\n?",
                   "", text, flags=re.S).strip()
@@ -2471,7 +3336,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):
@@ -2481,10 +3371,11 @@ def rules_block(host):
 
 
 def write_rules(host):
-    """Render the host's block into its rules file and record its sha."""
+    """Render the host's block into its rules file, record its sha and print
+    its line; a refused file is named once, by the refusal, with no `ok`."""
     path = STATIC_RULES[host]()
-    write_artifact(path, rules_block(host), set_managed_md)
-    return path
+    if write_artifact(path, rules_block(host), set_managed_md) is not None:
+        print("%s %s (always-on contract)" % (OK, path))
 
 
 def rules_current(host):
@@ -2496,7 +3387,7 @@ def rules_current(host):
     try:
         with open(STATIC_RULES[host](), encoding="utf-8") as fh:
             lines = fh.read().splitlines()
-    except OSError:
+    except (OSError, ValueError):  # unreadable, or not UTF-8: not current
         return False
     starts = [i for i, ln in enumerate(lines)
               if ln.strip().startswith("<!-- tezgah:start -->")]
@@ -2517,7 +3408,7 @@ def omp_bridge():
 def install_omp():
     print("\nomp:")
     mkdirp(OMP_AGENT)
-    print("%s %s (always-on contract)" % (OK, write_rules("omp")))
+    write_rules("omp")
     for s in SKILLS:
         print(link(os.path.join(HERE, "skills", s),
                    os.path.join(OMP_AGENT, "skills", s)))
@@ -2586,7 +3477,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):
@@ -3041,9 +3936,11 @@ def is_tezgah_link(path):
     wiring the user's."""
     if not os.path.islink(path):
         return False
+    # every root resolved like the target: a HOME reached through a symlink
+    # (macOS /tmp, Fedora's /home) otherwise reads tezgah's own hop as a stranger
     target = os.path.realpath(path)
     return any(target == root or target.startswith(root + os.sep)
-               for root in (os.path.realpath(HERE), INSTALL_PREFIX, tp.BIN_DIR))
+               for root in map(os.path.realpath, (HERE, INSTALL_PREFIX, tp.BIN_DIR)))
 
 
 def is_tezgah_entry(path):
@@ -3083,6 +3980,9 @@ def unlink_dir(d):
 def drop_managed_hook_entries(path):
     """Remove only tezgah's own entries from a host hooks.json."""
     data = read_json(path, None)
+    if data is not None and not isinstance(data, dict):
+        print("%s %s left untouched (not a JSON object)" % (NO, path))
+        return
     if not data:
         print("%s no %s" % (OK, path))
         return
@@ -3109,9 +4009,12 @@ def remove_managed_block(path, start="# tezgah:start", end="# tezgah:end"):
     try:
         with open(path, encoding="utf-8") as fh:
             lines = fh.read().splitlines()
-    except OSError:
+    except FileNotFoundError:
         print("%s no %s" % (OK, path))
         return
+    except (OSError, ValueError) as exc:
+        refuse(path, read_failure(exc), "--uninstall")
+        return
     out, skip, changed = [], False, False
     for ln in lines:
         stripped = ln.strip()
@@ -3134,8 +4037,17 @@ def remove_managed_block(path, start="# tezgah:start", end="# tezgah:end"):
         return
     while out and not out[-1].strip():
         out.pop()
-    # A dsh patch layer must stay a top-level YAML array; a file left holding
-    # only comments parses to null and the next dsh boot fails on it.
+    # A dsh patch layer the install created goes whole once nothing but
+    # tezgah's block was in it (OQ-13); one the user had must stay a top-level
+    # YAML array: a file left holding only comments parses to null and the
+    # next dsh boot fails on it.
+    if not out and prior_created(path):
+        backup(path)
+        os.remove(path)
+        forget_prior(path)
+        print("%s removed %s (it held only tezgah's block)" % (OK, path))
+        return
+    forget_prior(path)
     if not any(ln.strip() and not ln.strip().startswith("#") for ln in out):
         out.append("[]")
     with open(path, "w", encoding="utf-8") as fh:
@@ -3144,8 +4056,6 @@ def remove_managed_block(path, start="# tezgah:start", end="# tezgah:end"):
 
 
 def uninstall_common():
-    print("\ncommon:")
-    unlink_dir(tp.BIN_DIR)
     removed = tezgah_agents.cleanup()
     if removed:
         print("%s removed %d generated repo agent file(s)" % (OK, removed))
@@ -3255,20 +4165,21 @@ def _drop_state_entry(path):
 
 
 def remove_generated_state(full):
-    """Take tezgah's state back: the cache dirs always, the config dir's
-    generated contents when the uninstall is full.
+    """Take tezgah's state back when the uninstall is full: the cache dirs and
+    the config dir's generated contents.
 
     `full` means the run covers every host config.json records - the armed set.
-    A partial uninstall keeps the config: the hosts still armed read their roots
-    and feature selection from it at runtime, and deleting it would degrade
+    A partial uninstall keeps both: the hosts still armed read their roots and
+    feature selection from the config and write their session state and app
+    artifacts into the cache at runtime, and deleting either would degrade
     wiring this run did not touch. `adopted/` and any entry that is not one of
     tezgah's generated names survive in both cases."""
+    if not full:
+        return
     for d in (tp.CACHE, tp.fallback_cache()):
         if os.path.isdir(d):
             shutil.rmtree(d, ignore_errors=True)
             print("%s removed %s" % (OK, d))
-    if not full:
-        return
     try:
         names = sorted(os.listdir(tp.CONFIG_DIR))
     except OSError as exc:
@@ -3354,14 +4265,22 @@ def remove_install_tree():
         print("%s kept %s (holds %s)" % (NO, INSTALL_PREFIX, ", ".join(sorted(rest))))
 
 
-def _text_clean(path, needle="tezgah"):
-    """(True, "") when `path` is gone or carries no `needle`; else the leftover."""
+def text_marks(path):
+    """`path` as a host file can hold it: raw (TOML, markdown, a POSIX JSON
+    string) and JSON-escaped, where a Windows path's backslashes are doubled."""
+    return tuple(sorted({path, json.dumps(path)[1:-1]}))
+
+
+def _text_clean(path, needle):
+    """(True, "") when `path` is gone or carries none of `needle` (one marker,
+    or a tuple of them); else the leftover."""
     try:
         with open(path, encoding="utf-8", errors="replace") as fh:
             body = fh.read()
     except OSError:
         return True, ""
-    return needle not in body, path
+    needles = (needle,) if isinstance(needle, str) else needle
+    return not any(n in body for n in needles), path
 
 
 def verify_uninstall(hosts, full):
@@ -3381,7 +4300,21 @@ def verify_uninstall(hosts, full):
         else:
             print("%s %s" % (OK, label))
 
-    def clean(label, paths, needle="tezgah"):
+    # the markers only tezgah writes, so a user's own text naming tezgah (a
+    # Codex `[projects."…/tezgah"]` table, a note) is never a leftover: every
+    # hook and status-line command runs from the farm under CONFIG_DIR, and an
+    # MCP row is one of tezgah's server names (B-123)
+    farm_mark = text_marks(tp.CONFIG_DIR + os.sep)
+    names = [TEZGAH_MCP_NAME] + app_mcp_names()
+    json_mcp = tuple('"%s":' % n for n in names)
+    toml_mcp = tuple("[mcp_servers.%s]" % n for n in names)
+
+    def skills(root):
+        """tezgah's own skill links under root; a user's same-named dir is theirs."""
+        return [p for p in (os.path.join(root, "skills", s) for s in SKILLS)
+                if is_tezgah_entry(p)]
+
+    def clean(label, paths, needle=farm_mark):
         left = []
         for p in paths:
             ok, leftover = _text_clean(p, needle)
@@ -3393,13 +4326,17 @@ def verify_uninstall(hosts, full):
         else:
             print("%s %s" % (OK, label))
 
-    # common state
+    # common state: a partial run keeps the farm the armed hosts still run
+    # from, and takes only the hook links of the hosts it removed
     farm = [os.path.join(tp.BIN_DIR, n)
             for n in (os.listdir(tp.BIN_DIR) if os.path.isdir(tp.BIN_DIR) else [])]
-    claim("config/bin farm holds no tezgah entry",
-          [p for p in farm if is_tezgah_entry(p)])
+    gone = {"tezgah-%s-hook" % h for h in hosts}
+    claim("config/bin farm holds no tezgah entry" if full
+          else "config/bin farm holds no hook of these hosts",
+          [p for p in farm if is_tezgah_entry(p)
+           and (full or os.path.basename(p) in gone)])
     claim("materialised ledger gone", [MATERIALISED] if full else [])
-    claim("state caches gone", [tp.CACHE, tp.fallback_cache()])
+    claim("state caches gone", [tp.CACHE, tp.fallback_cache()] if full else [])
     if full:
         try:
             has_tree = os.path.isdir(INSTALL_PREFIX) and any(
@@ -3423,11 +4360,11 @@ def verify_uninstall(hosts, full):
                for n in user_agent_files("claude")])
     if "codex" in hosts:
         clean("codex hooks.json unwired", [os.path.join(CODEX, "hooks.json")])
-        claim("codex skills unlinked",
-              [os.path.join(CODEX, "skills", s) for s in SKILLS
-               if os.path.lexists(os.path.join(CODEX, "skills", s))])
-        clean("codex config.toml unwired", [os.path.join(CODEX, "config.toml")])
-        claim("codex consult link gone", [os.path.join(CODEX, "bin", "consult")])
+        claim("codex skills unlinked", skills(CODEX))
+        clean("codex config.toml unwired", [os.path.join(CODEX, "config.toml")],
+              needle=toml_mcp)
+        consult = os.path.join(CODEX, "bin", "consult")
+        claim("codex consult link gone", [consult] if is_tezgah_entry(consult) else [])
         # the user's own AGENTS.md may name tezgah; only the block is ours
         clean("codex global AGENTS.md block gone",
               [os.path.join(CODEX, n) for n in CODEX_RULES],
@@ -3441,20 +4378,24 @@ def verify_uninstall(hosts, full):
               + [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")])
+              [os.path.join(OPENCODE, "opencode.json")],
+              needle=farm_mark + text_marks(os.path.join(HERE, "skills", "**")) + json_mcp)
         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")])
-        clean("cursor mcp.json unwired", [os.path.join(CURSOR, "mcp.json")])
+        clean("cursor mcp.json unwired", [os.path.join(CURSOR, "mcp.json")],
+              needle=json_mcp)
         clean("cursor cli-config.json unwired",
               [os.path.join(CURSOR, "cli-config.json")])
     if "dsh" in hosts:
-        clean("dsh patch layers unwired", [DSH_PATCH, DSH_WEB_PATCH])
+        clean("dsh patch layers unwired", [DSH_PATCH, DSH_WEB_PATCH],
+              needle="# tezgah:start")
         claim("dsh launcher gone", [dsh_launcher()[1]])
     if "omp" in hosts:
-        clean("omp RULES.md unwired", [os.path.join(OMP_AGENT, "RULES.md")])
+        clean("omp RULES.md unwired", [os.path.join(OMP_AGENT, "RULES.md")],
+              needle="<!-- tezgah:start")
         claim("omp hook script gone",
               [os.path.join(OMP_AGENT, "hooks", "pre", "tezgah-hook.ts")])
         agents = os.path.join(OMP_AGENT, "agents")
@@ -3462,13 +4403,61 @@ def verify_uninstall(hosts, full):
               [os.path.join(agents, n) for n in
                (os.listdir(agents) if os.path.isdir(agents) else [])
                if n[:-len(".md")] in tezgah_agents.OWNED_NAMES and n.endswith(".md")])
-        clean("omp mcp.json unwired", [os.path.join(OMP_AGENT, "mcp.json")])
-        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))])
+        clean("omp mcp.json unwired", [os.path.join(OMP_AGENT, "mcp.json")],
+              needle=json_mcp)
+        claim("omp skills unlinked", skills(OMP_AGENT))
+    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", skills(QWEN))
+    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", skills(DROID))
+    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", skills(COMMANDCODE))
+    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", skills(COPILOT))
+    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", skills(ANTIGRAVITY))
+        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", skills(AMP))
+        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")])
+              [os.path.join(CLAUDE, "settings.json")], needle=farm_mark + ('"tezgah@',))
     claim("legacy kill switches gone",
           [os.path.join(HOME, ".claude", n) for n in OFF_SWITCH_NAMES
            if os.path.exists(os.path.join(HOME, ".claude", n))])
@@ -3482,16 +4471,16 @@ def verify_uninstall(hosts, full):
 
 
 def unwire_claude_settings():
-    """Remove tezgah's statusLine, attribution and enabledPlugins keys, leaving
-    everything else."""
+    """Take back tezgah's statusLine (the user's own comes back from the
+    install-prior record), attribution and enabledPlugins rows, leaving
+    everything else; an `enabledPlugins` left empty goes too."""
     sp = os.path.join(CLAUDE, "settings.json")
     s = read_json(sp, None)
-    if not s:
+    if not s or not isinstance(s, dict):
         return
     changed = False
     if "statusline.py" in json.dumps(s.get("statusLine") or {}):
-        s.pop("statusLine", None)
-        changed = True
+        changed = restore_prior(sp, s, "statusLine")
     if s.get("attribution") == {"commit": "", "pr": "", "sessionUrl": False}:
         s.pop("attribution", None)
         changed = True
@@ -3500,9 +4489,12 @@ def unwire_claude_settings():
             if isinstance(enabled, dict) else []:
         del enabled[key]
         changed = True
+        if not enabled:
+            s.pop("enabledPlugins")
     if changed:
         write_json(sp, s)
         print("%s removed tezgah statusLine/attribution/enabledPlugins from %s (restore from its .tezgah-bak copies under %s if wanted)" % (OK, sp, BACKUP_DIR))
+    forget_prior(sp)
 
 
 def unwire_opencode_config():
@@ -3541,8 +4533,9 @@ def unwire_opencode_config():
                 changed = True
         comp = c.get("compaction")
         if isinstance(comp, dict) and comp.get("prune") is True:
-            c.pop("compaction", None)
-            changed = True
+            # only the `prune` install added, and `compaction` only when the
+            # install created it and nothing else is left in it
+            changed = restore_prior(p, c, "compaction/prune") or changed
         wat = c.get("watcher")
         if isinstance(wat, dict) and isinstance(wat.get("ignore"), list):
             kept = [p for p in wat["ignore"] if p not in OPENCODE_IGNORE]
@@ -3565,6 +4558,7 @@ def unwire_opencode_config():
         if changed:
             write_json(p, c)
             print("%s removed tezgah instructions/skill-deny from %s" % (OK, p))
+    forget_prior(p)
     t = os.path.join(OPENCODE, "tui.json")
     tj = read_json(t, None)
     if tj and tj.get("plugin"):
@@ -3577,6 +4571,7 @@ def unwire_opencode_config():
                 tj.pop("plugin", None)
             write_json(t, tj)
             print("%s removed tezgah TUI plugin from %s" % (OK, t))
+    drop_if_empty(t, {"$schema": "https://opencode.ai/tui.json"})
     cp = os.path.join(OPENCODE, "cli.json")
     cj = read_json(cp, None)
     if cj and isinstance(cj.get("plugins"), list):
@@ -3585,6 +4580,7 @@ def unwire_opencode_config():
             cj["plugins"] = kept
             write_json(cp, cj)
             print("%s removed tezgah CLI plugin from %s" % (OK, cp))
+    forget_prior(cp)
 
 
 def uninstall_claude():
@@ -3631,6 +4627,7 @@ def uninstall_codex():
     for s in SKILLS:
         unlink_tezgah(os.path.join(CODEX, "skills", s))
     drop_managed_hook_entries(os.path.join(CODEX, "hooks.json"))
+    drop_if_empty(os.path.join(CODEX, "hooks.json"))
     strip_toml_mcp(os.path.join(CODEX, "config.toml"),
                    app_mcp_names() + [TEZGAH_MCP_NAME])
     unlink_tezgah(os.path.join(CODEX, "bin", "consult"))
@@ -3662,6 +4659,7 @@ def uninstall_cursor():
     for s in SKILLS:
         unlink_tezgah(os.path.join(CURSOR, "skills", s))
     drop_managed_hook_entries(os.path.join(CURSOR, "hooks.json"))
+    drop_if_empty(os.path.join(CURSOR, "hooks.json"), {"version": 1})
     mpath = os.path.join(CURSOR, "mcp.json")
     mcfg = read_json(mpath, None)
     if mcfg and isinstance(mcfg.get("mcpServers"), dict):
@@ -3676,9 +4674,255 @@ def uninstall_cursor():
     cfg = read_json(cc, None)
     if isinstance(cfg, dict) and "tezgah-statusline" in json.dumps(
             cfg.get("statusLine") or {}):
-        cfg.pop("statusLine", None)
+        # the user's own statusLine comes back, and `version` goes when the
+        # install added it to a file that had none
+        restore_prior(cc, cfg, "statusLine")
+        restore_prior(cc, cfg, "version", keep_unrecorded=True)
         write_json(cc, cfg)
         print("%s removed tezgah statusLine from %s" % (OK, cc))
+    drop_if_empty(cc, {"version": 1})
+
+
+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 {}):
+        restore_prior(path, cfg, "ui/statusLine")
+        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, shell=None):
+    """Remove a host file tezgah created (the install-prior record says so)
+    once uninstall emptied it: `{}`, or the bare `shell` its installer seeds a
+    new file with. A file the user had before the install stays, `{}` or not;
+    one an install older than the record wrote goes when emptied, as it always
+    did. The record of the file goes once its uninstall is done - not while
+    the file cannot be read: the refusal asks for a re-run, which still needs
+    the user's prior values."""
+    try:
+        with open(path, encoding="utf-8") as fh:
+            fh.read()
+    except FileNotFoundError:
+        pass
+    except (OSError, ValueError):  # unreadable, or not UTF-8
+        return
+    data = read_json(path, None)
+    if (data == {} or (shell is not None and data == shell)) \
+            and prior_created(path) is not False:
+        backup(path)
+        os.remove(path)
+        print("%s removed %s (empty once tezgah's keys left)" % (OK, path))
+    forget_prior(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)
+    key = "includeCoAuthoredByDroid"
+    if isinstance(cfg, dict):
+        changed = False
+        if "tezgah-statusline" in json.dumps(cfg.get("statusLine") or {}):
+            cfg.pop("statusLine")
+            changed = True
+        # the trailer switch goes back to what the install found (OQ-15); an
+        # install older than the record leaves it false, as it always did
+        if cfg.get(key) is False:
+            changed = restore_prior(spath, cfg, key, keep_unrecorded=True) or changed
+        if changed:
+            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 lines install_droid put in, keep
+        # the comments
+        try:
+            with open(spath, encoding="utf-8") as fh:
+                text = fh.read()
+        except (OSError, ValueError) as exc:  # unreadable, or not UTF-8
+            refuse(spath, read_failure(exc), "--uninstall")
+            text = ""
+        found = jsonc_loads(text) or {}
+        old = found.get("statusLine")
+        new = jsonc_drop(text, "statusLine", old) if "tezgah-statusline" in json.dumps(old or "") else None
+        if found.get(key) is False:
+            want = dict(found)
+            restore_prior(spath, want, key, keep_unrecorded=True)
+            cur = text if new is None else new
+            back = (jsonc_drop(cur, key, False) if key not in want
+                    else jsonc_put(cur, key, want[key]) if want[key] is not False else None)
+            new = back if back is not None else new
+        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 goes; a value the user had before the install is
+    # put back from the install-prior record (OQ-15)
+    if isinstance(attr, dict) and attr.get("commit") == "":
+        restore_prior(path, cfg, "attribution/commit")
+        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 {}):
+            restore_prior(spath, cfg, "statusLine")
+        # the value install wrote goes; one the user had before the install
+        # comes back from the install-prior record (OQ-15)
+        if cfg.get("includeCoAuthoredBy") is False:
+            restore_prior(spath, cfg, "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 {}):
+        restore_prior(spath, cfg, "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("--uninstall")
+    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:
+                # a value the user had before the install comes back (OQ-15)
+                restore_prior(spath, settings, key)
+        write_json(spath, settings)
+        print("%s removed tezgah's commit-trailer keys from %s" % (OK, spath))
+    # the record goes on every uninstall that read the file: one left behind
+    # would hand a later install's false back as the user's prior value
+    if settings is not None:
+        drop_if_empty(spath)
+    strip_managed_md(STATIC_RULES["amp"]())
 
 
 def uninstall_dsh():
@@ -3714,8 +4958,15 @@ def uninstall_omp():
     if isinstance(cfg, dict):
         servers = cfg.get("mcpServers")
         if isinstance(servers, dict):
-            for name in ["codegraph", TEZGAH_MCP_NAME] + app_mcp_names():
+            for name in [TEZGAH_MCP_NAME] + app_mcp_names():
                 servers.pop(name, None)
+            # codegraph goes only as the row install_omp writes: a row of the
+            # user's own (another binary, other args) is theirs, as on the
+            # other hosts
+            argv = graph_command()
+            if servers.get("codegraph") == {"type": "stdio", "command": argv[0],
+                                            "args": argv[1:], "env": dict(GRAPH_ENV)}:
+                servers.pop("codegraph")
             if not servers:
                 cfg.pop("mcpServers", None)
         # $schema was written by install_omp and nothing else: a file left
@@ -3731,9 +4982,41 @@ def uninstall_omp():
     strip_managed_md(os.path.join(OMP_AGENT, "RULES.md"))
 
 
+def _under(key, hosts):
+    """True when the recorded dir `key` ("<dir>/") lies in one of `hosts`'
+    own directories."""
+    roots = [tp.HOST_DIRS[h] for h in hosts if h in tp.HOST_DIRS]
+    roots += [os.path.dirname(AGY_HOOKS)] if "antigravity" in hosts else []
+    roots += [os.path.dirname(GOOSE_PLUGIN)] if "goose" in hosts else []
+    return any(key.startswith(r + os.sep) for r in roots)
+
+
+def remove_created_dirs(created):
+    """Remove each directory in `created` (the record's dirs the install made,
+    deepest first) that uninstall left empty. A directory the user made, or one
+    holding anything, stays; the record forgets each dir that is gone (OQ-13)."""
+    gone = []
+    for key in created:
+        d = key[:-1]
+        if os.path.isdir(d) and not os.path.islink(d) and not os.listdir(d):
+            os.rmdir(d)
+            print("%s removed %s (empty)" % (OK, d))
+        if not os.path.lexists(d):
+            gone.append(key)
+    if gone and os.path.exists(PRIOR):  # a full run already took the record
+        store = read_json(PRIOR, {})
+        for key in gone:
+            store.pop(key, None)
+        _prior_save(store)
+
+
 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 +5038,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,12 +5070,33 @@ 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)
+    print("\ncommon:")
+    if full:
+        unlink_dir(tp.BIN_DIR)
+    else:
+        # the farm is shared: every host still armed runs its hook, the gate and
+        # the status line from it, so a partial run takes only the hook links of
+        # the hosts it removes (B-007: emptying it disarmed the hosts that stay)
+        for h in hosts:
+            unlink_tezgah(os.path.join(tp.BIN_DIR, "tezgah-%s-hook" % h))
     uninstall_common()
     for h in hosts:
         UNINSTALLERS[h]()
     if "codex" in hosts and "cursor" in (armed or []) and "cursor" not in hosts:
         print("\ncursor (its skills came through ~/.codex/skills):")
         link_cursor_skills()
+    # every directory the install created goes once empty, deepest first; the
+    # list is read now, because a full run takes the record with the config
+    created = sorted((k for k, v in read_json(PRIOR, {}).items()
+                      if k.endswith(os.sep) and isinstance(v, dict)
+                      and v.get("created") is True), key=len, reverse=True)
+    if not full:
+        # a partial run takes only dirs under the removed hosts' own roots; a
+        # shared one (the caches, ~/.config) or an armed host's stays recorded
+        # until the full run
+        rest = set(armed) - set(hosts)
+        created = [k for k in created if _under(k, hosts) and not _under(k, rest)]
     if "claude" in hosts:
         print("\nclaude plugin copy:")
         remove_plugin_copies()
@@ -3810,6 +5115,7 @@ def uninstall(hosts, dry_run=False):
             write_json(tp.CONFIG, cfg)
         print("\n%s still armed: %s keeps its config and the install tree"
               % (NO, ", ".join(rest)))
+    remove_created_dirs(created)
     remaining = verify_uninstall(hosts, full)
     print("\nrestart each host so in-memory wiring unloads.")
     pred = predecessors()
@@ -4128,12 +5434,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 +5461,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 +5642,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 +5776,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 +5823,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 +5902,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 +6170,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 +6319,156 @@ 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 = ""
+    # the file install and uninstall resolve, read with comments tolerated
+    spath, settings = amp_settings(None)
+    settings, name = settings or {}, os.path.basename(spath)
+    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 %s" % (AMP_ATTRIBUTION[0], name),
+         settings.get(AMP_ATTRIBUTION[0]) is False),
+        ("%s off in %s" % (AMP_ATTRIBUTION[1], name),
+         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 +6587,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():
@@ -5682,6 +7305,9 @@ def upgrade(version, dry_run):
         return 127
     import tezgah_update
     old = tezgah_update.installed_entries(hosts)
+    # flushed first: through a pipe the plan sat in the buffer and printed after
+    # the children's own output (B-099)
+    sys.stdout.flush()
     proc = subprocess.run(cmd)
     if proc.returncode != 0:
         print("%s %s exited %d; tezgah was not re-armed"
@@ -5705,6 +7331,7 @@ def upgrade(version, dry_run):
         print("%s fetched, not re-armed: %s. Re-arm later with `%s`"
               % (NO, tezgah_update.NOT_REARMED["prefix"], " ".join(argv)))
         return 1
+    sys.stdout.flush()
     return subprocess.run(argv).returncode
 
 
@@ -5774,10 +7401,27 @@ def install_all(hosts, new_roots, deps_off, dry_run, redetect):
     return 1 if missed or REFUSED else 0
 
 
+def python_floor(version):
+    """The refusal for an interpreter below the Python 3.10 floor the README
+    states (OQ-16: CI tests nothing older), or None. `version` is a
+    sys.version_info-shaped tuple, so the check runs without that interpreter."""
+    if tuple(version[:2]) >= (3, 10):
+        return None
+    return ("tezgah needs Python 3.10 or newer; %s is %s"
+            % (sys.executable, ".".join(str(p) for p in version[:3])))
+
+
 def main(argv):
+    why = python_floor(sys.version_info)
+    if why:
+        sys.stderr.write("tezgah-setup: %s\n" % why)
+        return 1
+    # no prefix matching: `--upgrade V --vers` read `--vers` as `--version`,
+    # printed it and moved nothing, past the refusal below (B-023)
     ap = argparse.ArgumentParser(description="arm tezgah in every installed host; "
                                  "`tezgah update [--dry-run]` moves this install "
-                                 "to the newest release and re-arms it")
+                                 "to the newest release and re-arms it",
+                                 allow_abbrev=False)
     ap.add_argument("--install", action="store_true")
     ap.add_argument("--wizard", action="store_true",
                     help="ask the install questions (a bare run on a terminal does this)")
@@ -5910,6 +7554,8 @@ def main(argv):
         paths = refresh_contract()
         for path in paths:
             print("%s refreshed %s" % (OK, path))
+        if REFUSED:
+            return 1  # each refused file was named above; it is not current
         if not paths:
             print("contract is current")
         return 0
@@ -5954,8 +7600,8 @@ def main(argv):
     wizard_mode = (args.wizard or bare_tty) and not args.report
 
     if args.uninstall:
-        uninstall(hosts, dry_run=args.dry_run)
-        return 0
+        # 1 while anything tezgah wrote survives: the verify pass counts it
+        return uninstall(hosts, dry_run=args.dry_run)
 
     # A selection change is its own command: it persists the choice and brings
     # every host the install recorded along, so `--enable`/`--disable` reach the