@r1z4x/tezgah 1.13.0 → 1.14.0

package/bin/tezgah-setup

@@ -262,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
@@ -280,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
@@ -428,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):
@@ -657,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."""
@@ -745,39 +890,92 @@ 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."""
-    return write_text(path, 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):
@@ -926,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"
@@ -1189,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")),
@@ -1202,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")),
@@ -1314,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()
 
@@ -1477,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:
@@ -1487,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))
@@ -1533,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")
 
 
@@ -1658,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)
@@ -1719,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
@@ -2055,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)
@@ -2103,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", [])
@@ -2174,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",
@@ -2235,7 +2464,10 @@ def install_qwen():
             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
+        # 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(
@@ -2246,7 +2478,7 @@ def install_qwen():
         print("%s %s (hooks + ui.statusLine)" % (OK, path))
     for s in SKILLS:
         print(link(os.path.join(HERE, "skills", s), os.path.join(QWEN, "skills", s)))
-    print("%s %s (always-on contract)" % (OK, write_rules("qwen")))
+    write_rules("qwen")
 
 
 def droid_hook_groups():
@@ -2275,7 +2507,7 @@ def read_jsonc(path):
             text = fh.read()
     except FileNotFoundError:
         return {}
-    except OSError:
+    except (OSError, ValueError):  # unreadable, or not UTF-8
         return None
     return jsonc_loads(text)
 
@@ -2387,7 +2619,7 @@ def install_droid():
             text = fh.read()
     except FileNotFoundError:
         text = "{}\n"
-    except OSError:
+    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()}
@@ -2400,6 +2632,10 @@ def install_droid():
     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
@@ -2407,7 +2643,12 @@ def install_droid():
         print("%s %s (statusLine%s, includeCoAuthoredByDroid false)" % (
             OK, spath, "" if plain["statusLine"] == line else " left as the user set it"))
     elif text is not None:
-        old = (jsonc_loads(text) or {}).get("statusLine")
+        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
@@ -2429,7 +2670,7 @@ def install_droid():
               "`includeCoAuthoredByDroid` to false" % (NO, spath, droid_statusline()))
     for s in SKILLS:
         print(link(os.path.join(HERE, "skills", s), os.path.join(DROID, "skills", s)))
-    print("%s %s (always-on contract)" % (OK, write_rules("droid")))
+    write_rules("droid")
 
 
 def commandcode_hook_groups():
@@ -2454,11 +2695,19 @@ def install_commandcode():
     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"] = ""
@@ -2469,7 +2718,7 @@ def install_commandcode():
                   "co-author trailer" % (NO, path))
     for s in SKILLS:
         print(link(os.path.join(HERE, "skills", s), os.path.join(COMMANDCODE, "skills", s)))
-    print("%s %s (always-on contract)" % (OK, write_rules("commandcode")))
+    write_rules("commandcode")
 
 
 def copilot_hook_entries():
@@ -2505,9 +2754,16 @@ def install_copilot():
                                               copilot_hook_entries().items()}})
     print("%s %s (hooks)" % (OK, path))
     spath = os.path.join(COPILOT, "settings.json")
-    settings = read_json(spath, None) if os.path.exists(spath) else {}
+    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))
@@ -2515,12 +2771,11 @@ def install_copilot():
             print("%s %s keeps your includeCoAuthoredBy, so commits still carry a "
                   "co-author trailer" % (NO, spath))
     else:
-        print("%s %s holds comments, which a rewrite would drop: set `statusLine` to "
-              "`%s` and `includeCoAuthoredBy` to false there" % (NO, spath,
-                                                                  copilot_statusline()))
+        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)))
-    print("%s %s (always-on contract)" % (OK, write_rules("copilot")))
+    write_rules("copilot")
 
 
 def gemini_hook_groups():
@@ -2549,7 +2804,7 @@ def install_gemini():
     print("%s %s (extension hooks)" % (OK, path))
     for s in SKILLS:
         print(link(os.path.join(HERE, "skills", s), os.path.join(GEMINI_EXT, "skills", s)))
-    print("%s %s (always-on contract)" % (OK, write_rules("gemini")))
+    write_rules("gemini")
 
 
 def antigravity_hook_groups():
@@ -2584,18 +2839,19 @@ def install_antigravity():
         write_json(AGY_HOOKS, data)
         print("%s %s (hooks; the Antigravity App and IDE load them too)" % (OK, AGY_HOOKS))
     spath = os.path.join(ANTIGRAVITY, "settings.json")
-    settings = read_json(spath, None) if os.path.exists(spath) else {}
+    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 %s is not plain JSON, which a rewrite would lose: set `statusLine` "
-              "to {\"type\": \"command\", \"command\": \"%s\"} there"
-              % (NO, spath, antigravity_statusline()))
+        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)))
-    print("%s %s (always-on contract)" % (OK, write_rules("antigravity")))
+    write_rules("antigravity")
 
 
 def goose_hook_groups():
@@ -2626,18 +2882,28 @@ def install_goose():
     print("%s %s (plugin hooks)" % (OK, path))
     for s in SKILLS:
         print(link(os.path.join(HERE, "skills", s), os.path.join(GOOSE_PLUGIN, "skills", s)))
-    print("%s %s (always-on contract)" % (OK, write_rules("goose")))
+    write_rules("goose")
 
 
-def amp_settings():
-    """(path, settings dict or None): Amp's user settings.json as tezgah may
-    rewrite it - absent reads as {}, and None stands for a file tezgah must not
-    touch: one that is not plain JSON, or a settings.jsonc beside it (which of
-    the two wins is undocumented)."""
+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")
-    if os.path.exists(os.path.join(AMP, "settings.jsonc")):
-        return path, None
-    return path, read_json(path, None) if os.path.exists(path) else {}
+    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():
@@ -2647,6 +2913,7 @@ def install_amp():
     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"
@@ -2657,6 +2924,10 @@ def install_amp():
     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))
@@ -2665,11 +2936,11 @@ def install_amp():
                 print("%s %s keeps your %s, so the agent's commits still carry "
                       "that trailer" % (NO, spath, key))
     else:
-        print("%s %s is not plain JSON (or settings.jsonc exists): set %s to false "
-              "there" % (NO, spath, " and ".join("`%s`" % k for k in AMP_ATTRIBUTION)))
+        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)))
-    print("%s %s (always-on contract)" % (OK, write_rules("amp")))
+    write_rules("amp")
 
 
 
@@ -2916,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):
@@ -3018,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()
@@ -3092,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):
@@ -3107,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 -->")]
@@ -3128,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)))
@@ -3656,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):
@@ -3698,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
@@ -3724,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()
@@ -3749,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:
@@ -3759,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))
@@ -3870,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:
@@ -3969,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):
@@ -3996,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)
@@ -4008,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(
@@ -4038,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],
@@ -4056,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")
@@ -4077,34 +4403,27 @@ 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",
-              [os.path.join(QWEN, "skills", s) for s in SKILLS
-               if os.path.lexists(os.path.join(QWEN, "skills", s))])
+        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",
-              [os.path.join(DROID, "skills", s) for s in SKILLS
-               if os.path.lexists(os.path.join(DROID, "skills", s))])
+        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",
-              [os.path.join(COMMANDCODE, "skills", s) for s in SKILLS
-               if os.path.lexists(os.path.join(COMMANDCODE, "skills", s))])
+        claim("commandcode skills unlinked", skills(COMMANDCODE))
     if "copilot" in hosts:
         claim("copilot hooks/tezgah.json gone",
               [os.path.join(COPILOT, "hooks", "tezgah.json")])
@@ -4112,9 +4431,7 @@ def verify_uninstall(hosts, full):
               [os.path.join(COPILOT, "settings.json")], needle="tezgah-statusline")
         clean("copilot copilot-instructions.md block gone",
               [os.path.join(COPILOT, "copilot-instructions.md")], needle="<!-- tezgah:start")
-        claim("copilot skills unlinked",
-              [os.path.join(COPILOT, "skills", s) for s in SKILLS
-               if os.path.lexists(os.path.join(COPILOT, "skills", s))])
+        claim("copilot skills unlinked", skills(COPILOT))
     if "gemini" in hosts:
         claim("gemini extension dir gone", [GEMINI_EXT])
         if not gemini_md_kept("gemini"):
@@ -4125,9 +4442,7 @@ def verify_uninstall(hosts, full):
               needle="tezgah-antigravity-hook")
         clean("antigravity settings.json statusLine gone",
               [os.path.join(ANTIGRAVITY, "settings.json")], needle="tezgah-statusline")
-        claim("antigravity skills unlinked",
-              [os.path.join(ANTIGRAVITY, "skills", s) for s in SKILLS
-               if os.path.lexists(os.path.join(ANTIGRAVITY, "skills", s))])
+        claim("antigravity skills unlinked", skills(ANTIGRAVITY))
         if not gemini_md_kept("antigravity"):
             clean("antigravity GEMINI.md block gone", [STATIC_RULES["antigravity"]()],
                   needle="<!-- tezgah:start")
@@ -4137,14 +4452,12 @@ def verify_uninstall(hosts, full):
               needle="<!-- tezgah:start")
     if "amp" in hosts:
         claim("amp plugin gone", [AMP_PLUGIN] if amp_plugin_ours() else [])
-        claim("amp skills unlinked",
-              [os.path.join(AMP, "skills", s) for s in SKILLS
-               if os.path.lexists(os.path.join(AMP, "skills", s))])
+        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))])
@@ -4158,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
@@ -4176,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():
@@ -4217,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]
@@ -4241,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"):
@@ -4253,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):
@@ -4261,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():
@@ -4307,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"))
@@ -4338,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):
@@ -4352,9 +4674,13 @@ 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():
@@ -4366,22 +4692,35 @@ def uninstall_qwen():
     cfg = read_json(path, None)
     ui = cfg.get("ui") if isinstance(cfg, dict) else None
     if isinstance(ui, dict) and "tezgah-statusline" in json.dumps(ui.get("statusLine") or {}):
-        ui.pop("statusLine")
-        if not ui:
-            cfg.pop("ui")
+        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):
-    """Remove a host settings file uninstall emptied: tezgah created it to hold
-    its hooks or status line, and a `{}` the user never had is left over."""
-    if read_json(path, None) == {}:
+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():
@@ -4410,18 +4749,38 @@ def uninstall_droid():
             print("%s removed %s (it held only tezgah's hooks)" % (OK, path))
     spath = os.path.join(DROID, "settings.json")
     cfg = read_json(spath, None)
-    if isinstance(cfg, dict) and "tezgah-statusline" in json.dumps(cfg.get("statusLine") or {}):
-        cfg.pop("statusLine")
-        write_json(spath, cfg)
-        print("%s removed tezgah statusLine from %s" % (OK, spath))
+    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 one line install_droid put in, keep
-        # the comments; `includeCoAuthoredByDroid` stays false (the
-        # no-attribution rule is the user's, not tezgah's to undo)
-        with open(spath, encoding="utf-8") as fh:
-            text = fh.read()
-        old = (jsonc_loads(text) or {}).get("statusLine")
+        # 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))
@@ -4437,13 +4796,10 @@ def uninstall_commandcode():
     drop_managed_hook_entries(path)
     cfg = read_json(path, None)
     attr = cfg.get("attribution") if isinstance(cfg, dict) else None
-    # the value install wrote, beside the user's other attribution keys or
-    # alone; as with Claude's, a user's own identical value cannot be told
-    # apart from it, and dropping it only restores Command Code's default
+    # 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") == "":
-        attr.pop("commit")
-        if not attr:
-            cfg.pop("attribution")
+        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)
@@ -4463,10 +4819,11 @@ def uninstall_copilot():
     cfg = read_json(spath, None)
     if isinstance(cfg, dict):
         if "tezgah-statusline" in json.dumps(cfg.get("statusLine") or {}):
-            cfg.pop("statusLine")
-        # the value install wrote; a user's own false cannot be told apart from it
+            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:
-            cfg.pop("includeCoAuthoredBy")
+            restore_prior(spath, cfg, "includeCoAuthoredBy")
         if write_json(spath, cfg):
             print("%s removed tezgah's statusLine and includeCoAuthoredBy from %s"
                   % (OK, spath))
@@ -4506,7 +4863,7 @@ def uninstall_antigravity():
     spath = os.path.join(ANTIGRAVITY, "settings.json")
     cfg = read_json(spath, None)
     if isinstance(cfg, dict) and "tezgah-statusline" in json.dumps(cfg.get("statusLine") or {}):
-        cfg.pop("statusLine")
+        restore_prior(spath, cfg, "statusLine")
         write_json(spath, cfg)
         print("%s removed tezgah's statusLine from %s" % (OK, spath))
     drop_if_empty(spath)
@@ -4553,13 +4910,17 @@ def uninstall_amp():
         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()
+    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:
-                settings.pop(key)
+                # 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"]())
 
@@ -4597,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
@@ -4614,6 +4982,34 @@ 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, "qwen": uninstall_qwen,
@@ -4675,12 +5071,32 @@ def uninstall(hosts, dry_run=False):
     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()
@@ -4699,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()
@@ -6034,10 +6451,9 @@ def host_checks_amp():
             plugin = fh.read()
     except OSError:
         plugin = ""
-    # either user settings file; the comment-tolerant reader for both
-    settings = (read_jsonc(os.path.join(AMP, "settings.json")) or {}
-                if not os.path.exists(os.path.join(AMP, "settings.jsonc"))
-                else read_jsonc(os.path.join(AMP, "settings.jsonc")) or {})
+    # 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
@@ -6045,9 +6461,9 @@ def host_checks_amp():
          bool(plugin) and plugin == ta.amp_plugin(HERE)),
         ("skills linked", skills_linked(os.path.join(AMP, "skills"))),
         ("AGENTS.md carries the contract (matches a fresh render)", rules_current("amp")),
-        ("%s off in settings.json" % AMP_ATTRIBUTION[0],
+        ("%s off in %s" % (AMP_ATTRIBUTION[0], name),
          settings.get(AMP_ATTRIBUTION[0]) is False),
-        ("%s off in settings.json" % AMP_ATTRIBUTION[1],
+        ("%s off in %s" % (AMP_ATTRIBUTION[1], name),
          settings.get(AMP_ATTRIBUTION[1]) is False),
         ("amp CLI on PATH", bool(tp.which_user("amp"))),
     ]
@@ -6889,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"
@@ -6912,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
 
 
@@ -6981,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)")
@@ -7117,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
@@ -7161,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