@r1z4x/tezgah 1.9.2 → 1.13.0

package/hooks/tezgah_stack.py

@@ -83,6 +83,26 @@ def yaml_list(text, key):
     return out
 
 
+def yaml_keys(text, key):
+    """The direct child keys of `key:` in a block-style YAML file (Goose's
+    `extensions:` map in config.yaml)."""
+    out, indent = [], None
+    for line in text.splitlines():
+        if indent is None:
+            if re.match(r"^%s:\s*$" % re.escape(key), line):
+                indent = -1
+            continue
+        if not line.strip() or line.lstrip().startswith("#"):
+            continue
+        m = re.match(r"^(\s+)([\w.-]+):", line)
+        if not m:
+            break
+        indent = len(m.group(1)) if indent < 0 else indent
+        if len(m.group(1)) == indent:
+            out.append(m.group(2))
+    return out
+
+
 def toml_tables(text, prefix):
     """Names of `[prefix.<name>]` tables in a TOML file (Codex's MCP rows)."""
     return sorted({m.group(1) for m in re.finditer(
@@ -264,6 +284,217 @@ def host_stack(host, repo):
         return {"context": [os.path.join(c, "cordis.patch.yml")],
                 "skills": ("first", [os.path.join(c, "skills")]),
                 "hooks": {}, "mcp": [], "scan": [os.path.join(c, "skills")]}
+    if host == "qwen":
+        c = tp.HOST_DIRS["qwen"]
+        user = _json(os.path.join(c, "settings.json"))
+        project = _json(os.path.join(repo, ".qwen", "settings.json"))
+        return {
+            # Qwen 0.21.13 docs (features/memory.md): all of these load
+            "context": [os.path.join(c, "QWEN.md"), os.path.join(repo, "QWEN.md"),
+                        os.path.join(repo, "AGENTS.md"),
+                        os.path.join(repo, ".qwen", "QWEN.local.md")],
+            # features/skills.md lists personal and project dirs and names no winner
+            "skills": ("all", [os.path.join(c, "skills"),
+                               os.path.join(repo, ".qwen", "skills")]),
+            "hooks": merge_hooks(hook_rows(user, "settings.json"),
+                                 hook_rows(project, "project")),
+            "mcp": sorted(user.get("mcpServers") or {})
+            + ["%s (project)" % n for n in sorted(project.get("mcpServers") or {})],
+            "scan": [os.path.join(c, "skills")],
+        }
+    if host == "droid":
+        c, h = tp.HOST_DIRS["droid"], tp.HOME
+
+        def droid_hooks(d, source):
+            # hooks.json is keyed by event at the top; only when it is absent does
+            # Droid read the `hooks` key of settings.json (harness/hooks)
+            path = os.path.join(d, "hooks.json")
+            if os.path.exists(path):
+                return hook_rows({"hooks": _json(path)}, source)
+            return hook_rows(_json(os.path.join(d, "settings.json")), source)
+        return {
+            # harness/agents-md: cwd up to the git root and the personal dirs
+            "context": [os.path.join(c, "AGENTS.md"), os.path.join(h, ".agents", "AGENTS.md"),
+                        os.path.join(repo, "AGENTS.md"),
+                        os.path.join(repo, ".factory", "AGENTS.md"),
+                        os.path.join(repo, "CLAUDE.md")],
+            # harness/skills lists the scopes and names no winner
+            "skills": ("all", [os.path.join(c, "skills"),
+                               os.path.join(repo, ".factory", "skills"),
+                               os.path.join(h, ".agents", "skills"),
+                               os.path.join(repo, ".agents", "skills")]),
+            "hooks": merge_hooks(droid_hooks(c, "hooks.json"),
+                                 droid_hooks(os.path.join(repo, ".factory"), "project")),
+            "mcp": sorted(_json(os.path.join(c, "mcp.json")).get("mcpServers") or {}),
+            "scan": [os.path.join(c, "skills")],
+        }
+    if host == "commandcode":
+        c, h = tp.HOST_DIRS["commandcode"], tp.HOME
+        user = _json(os.path.join(c, "settings.json"))
+        project = _json(os.path.join(repo, ".commandcode", "settings.json"))
+        return {
+            # docs/memory: user, project, then subdirectory tiers; all load
+            "context": [os.path.join(c, "AGENTS.md"), os.path.join(repo, "AGENTS.md"),
+                        os.path.join(repo, ".commandcode", "AGENTS.md")],
+            # docs/skills "Selection priority": project before user, and within a
+            # level .commandcode/ before .agents/
+            "skills": ("first", [os.path.join(repo, ".commandcode", "skills"),
+                                 os.path.join(repo, ".agents", "skills"),
+                                 os.path.join(c, "skills"),
+                                 os.path.join(h, ".agents", "skills")]),
+            "hooks": merge_hooks(hook_rows(user, "settings.json"),
+                                 hook_rows(project, "project")),
+            "mcp": sorted(_json(os.path.join(c, "mcp.json")).get("mcpServers") or {})
+            + ["%s (project)" % n for n in
+               sorted(_json(os.path.join(repo, ".mcp.json")).get("mcpServers") or {})],
+            "scan": [os.path.join(c, "skills")],
+        }
+    if host == "copilot":
+        c, h = tp.HOST_DIRS["copilot"], tp.HOME
+
+        def hook_files(d, source):
+            # every *.json in a hooks dir is one `{"version": 1, "hooks": ...}` file
+            names = sorted(n for n in os.listdir(d) if n.endswith(".json")) \
+                if os.path.isdir(d) else []
+            return merge_hooks(*(hook_rows(_json(os.path.join(d, n)), "%s %s" % (source, n))
+                                 for n in names))
+        return {
+            # cli-command-reference "Custom instructions locations": all merge
+            "context": [os.path.join(c, "copilot-instructions.md"),
+                        os.path.join(repo, ".github", "copilot-instructions.md"),
+                        os.path.join(repo, "AGENTS.md"), os.path.join(repo, "CLAUDE.md"),
+                        os.path.join(repo, "GEMINI.md")],
+            # cli-command-reference "Skill locations": first found wins
+            "skills": ("first", [os.path.join(repo, ".github", "skills"),
+                                 os.path.join(repo, ".agents", "skills"),
+                                 os.path.join(repo, ".claude", "skills"),
+                                 os.path.join(c, "skills"),
+                                 os.path.join(h, ".agents", "skills")]),
+            # hooks-reference "Hooks locations": every source runs
+            "hooks": merge_hooks(hook_files(os.path.join(repo, ".github", "hooks"), "project"),
+                                 hook_files(os.path.join(c, "hooks"), "hooks"),
+                                 hook_rows(_json(os.path.join(c, "settings.json")),
+                                           "settings.json"),
+                                 hook_rows(_json(os.path.join(repo, ".claude",
+                                                              "settings.json")), "project")),
+            "mcp": sorted(_json(os.path.join(c, "mcp-config.json")).get("mcpServers") or {})
+            + ["%s (project)" % n for n in
+               sorted(_json(os.path.join(repo, ".mcp.json")).get("mcpServers") or {})],
+            "scan": [os.path.join(c, "skills")],
+        }
+    if host == "gemini":
+        g, h = tp.HOST_DIRS["gemini"], tp.HOME
+        ext = os.path.join(g, "extensions")
+        exts = sorted(n for n in os.listdir(ext) if os.path.isdir(os.path.join(ext, n))) \
+            if os.path.isdir(ext) else []
+        user = _json(os.path.join(g, "settings.json"))
+        project = _json(os.path.join(repo, ".gemini", "settings.json"))
+        return {
+            # configuration "Context Files": the global file, then the cwd up to
+            # the git root, then subdirectories; all concatenate
+            "context": [os.path.join(g, "GEMINI.md"), os.path.join(repo, "GEMINI.md")],
+            # cli/skills.md: workspace over user over extension; `.agents/skills`
+            # wins within a tier
+            "skills": ("first", [os.path.join(repo, ".agents", "skills"),
+                                 os.path.join(repo, ".gemini", "skills"),
+                                 os.path.join(h, ".agents", "skills"),
+                                 os.path.join(g, "skills")]
+                       + [os.path.join(ext, n, "skills") for n in exts]),
+            # hooks/index.md "Configuration": project, user, system, extensions
+            "hooks": merge_hooks(hook_rows(project, "project"),
+                                 hook_rows(user, "settings.json"),
+                                 *(hook_rows(_json(os.path.join(ext, n, "hooks", "hooks.json")),
+                                             "extension %s" % n) for n in exts)),
+            "mcp": sorted(user.get("mcpServers") or {})
+            + ["%s (project)" % n for n in sorted(project.get("mcpServers") or {})],
+            "scan": [os.path.join(g, "skills"), os.path.join(ext, "tezgah", "skills")],
+        }
+    if host == "antigravity":
+        a = tp.HOST_DIRS["antigravity"]
+        g = os.path.dirname(a)
+
+        def named(path, source):
+            # hooks.json maps a hook name to its events; a name set
+            # `enabled: false` loads nothing (docs/hooks "Hook definition fields")
+            data = _json(path)
+            return merge_hooks(*(hook_rows({"hooks": d}, "%s %s" % (source, n))
+                                 for n, d in sorted(data.items())
+                                 if isinstance(d, dict) and d.get("enabled") is not False))
+        return {
+            # docs/rules "Antigravity CLI": global and workspace rules all load
+            "context": [os.path.join(g, "GEMINI.md"), os.path.join(g, "AGENTS.md"),
+                        os.path.join(repo, "GEMINI.md"), os.path.join(repo, "AGENTS.md")],
+            # docs/skills "CLI skill locations" names no winner
+            "skills": ("all", [os.path.join(repo, ".agents", "skills"),
+                               os.path.join(a, "skills")]),
+            # docs/hooks "Antigravity CLI": workspace, global, plugins
+            "hooks": merge_hooks(named(os.path.join(repo, ".agents", "hooks.json"), "project"),
+                                 named(os.path.join(g, "config", "hooks.json"), "hooks.json")),
+            "mcp": sorted(_json(os.path.join(g, "config", "mcp_config.json"))
+                          .get("mcpServers") or {})
+            + ["%s (project)" % n for n in sorted(
+                _json(os.path.join(repo, ".agents", "mcp_config.json")).get("mcpServers") or {})],
+            "scan": [os.path.join(a, "skills")],
+        }
+    if host == "goose":
+        c, h = tp.HOST_DIRS["goose"], tp.HOME
+        disabled = set(_json(os.path.join(c, "settings.json")).get("disabledPlugins") or [])
+
+        def plugins(base, source):
+            # plugins guide "Plugin Locations"; `disabledPlugins` skips one
+            names = sorted(n for n in os.listdir(base)
+                           if os.path.isdir(os.path.join(base, n))) if os.path.isdir(base) else []
+            return [hook_rows(_json(os.path.join(base, n, "hooks", "hooks.json")),
+                              "%s %s" % (source, n)) for n in names if n not in disabled]
+        return {
+            # goosehints guide: CONTEXT_FILE_NAMES (default AGENTS.md, .goosehints)
+            # global in ~/.config/goose, then the project's; all load
+            "context": [os.path.join(c, "AGENTS.md"), os.path.join(c, ".goosehints"),
+                        os.path.join(repo, "AGENTS.md"), os.path.join(repo, ".goosehints")],
+            # skills guide "Skill Locations" names no winner; a plugin's skills are
+            # namespaced `<plugin>:<name>`, so they collide with none of these
+            "skills": ("all", [os.path.join(h, ".agents", "skills"),
+                               os.path.join(repo, ".agents", "skills"),
+                               os.path.join(repo, ".goose", "skills"),
+                               os.path.join(repo, ".claude", "skills"),
+                               os.path.join(h, ".claude", "skills")]),
+            # hooks guide "Where Hooks Live": user and project plugins
+            "hooks": merge_hooks(*plugins(os.path.join(h, ".agents", "plugins"), "plugin"),
+                                 *plugins(os.path.join(repo, ".agents", "plugins"),
+                                          "project plugin")),
+            # config-files guide: `extensions:` in config.yaml
+            "mcp": yaml_keys(_read(os.path.join(c, "config.yaml")), "extensions"),
+            "scan": [os.path.join(tp.GOOSE_PLUGIN, "skills")],
+        }
+    if host == "amp":
+        c, h = tp.HOST_DIRS["amp"], tp.HOME
+        system = os.path.dirname(tp.AMP_PLUGIN)
+
+        def plugins(base):
+            # plugins guide: a `.ts`/`.js` file or `<name>/index.*` in a plugin dir
+            return sorted(os.path.join(base, n) for n in (
+                os.listdir(base) if os.path.isdir(base) else []) if not n.startswith("."))
+        found = plugins(os.path.join(repo, ".amp", "plugins")) + plugins(system)
+        return {
+            # agents-md guide: the cwd and its parents, then both user files; all load
+            "context": [os.path.join(repo, "AGENTS.md"), os.path.join(c, "AGENTS.md"),
+                        os.path.join(h, ".config", "AGENTS.md")],
+            # skills guide "Skill Sources and Precedence": the first name wins
+            "skills": ("first", [os.path.join(h, ".config", "agents", "skills"),
+                                 os.path.join(h, ".agents", "skills"),
+                                 os.path.join(c, "skills"),
+                                 os.path.join(repo, ".agents", "skills"),
+                                 os.path.join(repo, ".claude", "skills"),
+                                 os.path.join(h, ".claude", "skills")]),
+            # a plugin gets every event; a project plugin wins over a system one
+            # of the same name (plugins guide "Plugin Locations and Precedence")
+            "hooks": {"plugin (every event)": [(owner(p), p, p) for p in found]},
+            # settings guide: `amp.mcpServers`, user then workspace
+            "mcp": sorted(_json(os.path.join(c, "settings.json")).get("amp.mcpServers") or {})
+            + ["%s (project)" % n for n in sorted(
+                _json(os.path.join(repo, ".amp", "settings.json")).get("amp.mcpServers") or {})],
+            "scan": [os.path.join(c, "skills"), system],
+        }
     raise ValueError(host)
 
 
@@ -280,7 +511,11 @@ def skill_copies(dirs):
 
 def tezgah_skill_dirs():
     """The dirs tezgah-setup links its skills into, plus the plugin copy's."""
-    dirs = [os.path.join(tp.HOST_DIRS[x], "skills") for x in ("codex", "cursor", "opencode", "dsh")]
+    dirs = [os.path.join(tp.HOST_DIRS[x], "skills")
+            for x in ("codex", "cursor", "opencode", "dsh", "qwen", "droid", "commandcode",
+                      "copilot", "antigravity", "amp")]
+    dirs.append(os.path.join(tp.HOST_DIRS["gemini"], "extensions", "tezgah", "skills"))
+    dirs.append(os.path.join(tp.GOOSE_PLUGIN, "skills"))
     dirs.append(os.path.join(tp.HOST_DIRS["omp"], "agent", "skills"))
     active, _ = claude_plugin()
     return dirs + ([os.path.join(active, "skills")] if active else [])

package/hooks/tezgah_stopspec.py

@@ -207,7 +207,14 @@ class Trace:
         if name == "Dc":
             return self.col("U")[i] and bool(ti.DESIGN_COMPONENT.search(self.masked(i)))
         if name == "Dk":
-            return self.col("P")[i] and bool(ti.DESIGN_CHECK.search(self.masked(i)))
+            # a `slop` verdict only counts for the repository it scanned (review
+            # of plan 133, finding 5): a scan of some other tree proves nothing
+            # about this one
+            detail = self.masked(i)
+            if not (self.col("P")[i] and ti.DESIGN_CHECK.search(detail)):
+                return False
+            return (not ti.DESIGN_SLOP.search(detail)
+                    or ti._slop_row_holds(row, None))
         if name == "X":
             return (self.external is not None
                     and kind in ("run", "verify", "verify_ok", "verify_fail")

package/hooks/tezgah_task.py

@@ -547,9 +547,12 @@ def _phased(root, ident=None):
     # and allowlist would lock writes in a cloned repo (audit L-16). Only
     # positive evidence turns the rule off - the index tracks `.tezgah` -
     # never a can't-tell, which would switch the user's own guard off in
-    # silence (review R2); the answer is cached on the index's stat.
-    from tezgah_paths import workspace_tracked
-    if out and workspace_tracked(root):
+    # silence (review R2); the answer is cached on the index's stat. A
+    # repository that carries `tezgah.owner` says it outright: `tasks: off`
+    # means its plans are its own, and `harness: excluded` makes `root_for`
+    # answer None, so no caller reaches this with a root at all.
+    from tezgah_paths import tasks_disabled, workspace_tracked
+    if out and (workspace_tracked(root) or tasks_disabled(root)):
         return []
     return out
 
@@ -706,9 +709,14 @@ def phased_record(root, rel):
     if (len(parts) != 4 or "/".join(parts[:3]).casefold() != ".tezgah/plans/open"
             or not parts[3].casefold().endswith(".md")):
         return False
+    from tezgah_paths import tasks_disabled
     for name, _, text in _plan_files(root, "open"):
         if name.casefold() == parts[3].casefold():
-            return frontmatter(text).get("phase") in TASK_PHASES
+            # Read after the name matches, so an ordinary write pays no marker
+            # read. A repository that says `tasks: off` owns its plans: holding
+            # a write to one of them is the machine running there.
+            return (frontmatter(text).get("phase") in TASK_PHASES
+                    and not tasks_disabled(root))
     return False
 
 
@@ -978,7 +986,8 @@ def set_section(path, heading, body):
 # These functions shell out to git; none of them is on the gate's write path.
 
 SLICE_KINDS = ("agent", "job")
-SLICE_HOSTS = ("omp", "claude", "codex", "cursor", "opencode", "dsh")
+SLICE_HOSTS = ("omp", "claude", "codex", "cursor", "opencode", "dsh", "qwen", "droid",
+               "commandcode", "copilot", "gemini", "antigravity", "goose", "amp")
 # `stale`: an idle background job whose result stays in its parent transcript.
 # An agent with no observed end stays owed as stopped with no failure class.
 SLICE_STATUSES = ("open", "done", "stopped", "resumed", "stale")

package/hooks/tezgah_taste_ledger.py

@@ -454,7 +454,7 @@ def block(root, day=None):
     return (("Taste (learned from this user's own corrections; follow a rule, treat a "
              "hint as the default; the narrower scope wins - path, then language, then "
              "repository, then user - and AGENTS.md/CLAUDE.md beat every learning; "
-             "`tezgah-taste reject <id>` drops one):\n"
+             "`~/.config/tezgah/bin/tezgah-taste reject <id>` drops one):\n"
              + "\n".join(_line(mode, learning) for mode, learning in picked)),
             [m[1]["id"] for m in picked])
 

package/hosts/amp/hook.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""Amp lifecycle hook: the python half of tezgah's Amp plugin.
+
+Amp's plugin API is TypeScript (ampcode.com/docs plugin-api), so
+`hosts/amp/tezgah-plugin.ts.in`, rendered to `$XDG_CONFIG_HOME/amp/plugins/
+tezgah.ts`, forwards each event here as one JSON payload on stdin and turns the
+answer into Amp's own result. The protocol is omp's (hosts/omp/hook.py); the
+session id is Amp's thread id.
+
+    {"event": "session_start", "cwd", "session_id", "subagent", "parent",
+     "ignore_guidance", "line"}
+        -> {"context": <live state, the core too when AGENTS.md lacks it>,
+            "status", "idx"}
+    {"event": "status", "cwd", "session_id"} -> {"status", "idx"}
+    {"event": "user_prompt", "cwd", "session_id", "prompt", "subagent"}
+        -> {"context": <reminder + the rules this prompt arms>}
+    {"event": "pre_tool_use", "cwd", "session_id", "tool", "input"} -> {"deny": reason}
+    {"event": "post_tool_use", "cwd", "session_id", "tool", "input", "status",
+     "exit_code", "result_len", "empty_run", "idx", "line"}
+        -> {"label": one line, "status", "idx"}
+    {"event": "stop", "cwd", "session_id", "last_assistant_message",
+     "stop_hook_active"} -> {"decision": "block", "reason": reason}
+    {"event": "subagent_stop", ..., "parent", "agent"} -> {} (record-only)
+
+Session start cannot inject in Amp, so the bridge asks `session_start` on the
+thread's next `agent.start` and sends the brief with that turn. The always-on
+core is the managed block in `~/.config/amp/AGENTS.md`; the brief repeats it
+only while that block is missing or AMP_IGNORE_GUIDANCE_FILES is set. The
+status line is plain text: Amp's status item draws no ANSI.
+"""
+import json
+import os
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+sys.path.insert(0, os.path.join(ROOT, "hooks"))
+from tezgah_guard import attest_session, import_failed, safe  # noqa: E402
+try:
+    from tezgah_context import (  # noqa: E402
+        command_text, context_for, health_segments, record, render_tiers, shell_kind,
+        skill_read_kind)
+    from tezgah_gate import cross_project_note, decision  # noqa: E402
+    from tezgah_integrity import (  # noqa: E402
+        SUBAGENT_CHANNEL, bind_session, note, note_tool, stop_reason, untrusted_label,
+        untrusted_source)
+    from tezgah_paths import HOST_DIRS, off, root_for  # noqa: E402
+    from tezgah_taste import write_note  # noqa: E402
+    from tezgah_untrusted import marks  # noqa: E402
+except Exception as exc:
+    import_failed(exc)
+
+# Amp's tool names -> the gate's vocabulary. `shell_command` is the other shell
+# tool `shellCommandFromToolCall` reads (plugin-api); `Bash`, `edit_file`,
+# `create_file`, `apply_patch` and `Task` are already the gate's names, and
+# an MCP tool already arrives as `mcp__<server>__<tool>`.
+GATE_TOOLS = {"shell_command": "Bash"}
+IDX_GLYPHS = ("\u2713", "\u21bb", "\u2717", "?", "\u2013")
+
+
+def gate_name(name):
+    """The tool name the gate denies under and the ledger row records; both
+    halves map through here so a call hashes to one id."""
+    return GATE_TOOLS.get(name, name)
+
+
+def gate_input(tool, inp):
+    """The input in the gate's fields: the gate reads a shell call's text only
+    from `command`, so Amp's `cmd` is copied there when the bridge sent none."""
+    inp = dict(inp) if isinstance(inp, dict) else {}
+    if tool == "Bash" and "command" not in inp and isinstance(inp.get("cmd"), str):
+        inp["command"] = inp["cmd"]
+    return inp
+
+
+def classify(tool, inp):
+    """The used-tool kind for a mapped call, or None."""
+    if tool.startswith("mcp__") and "codegraph" in tool:
+        return "graph"
+    kind = skill_read_kind(tool, inp)
+    if kind:
+        return kind
+    if tool.lower() == "task":
+        return "orch"
+    if tool == "Bash":
+        return shell_kind(command_text(inp))
+    return None
+
+
+def call_failed(tool, status, exit_code):
+    """`note_tool`'s `failed`, tri-state. An error or cancelled result is a
+    failure; a shell result passes or fails only on an integer exit code the
+    bridge read off the output object; anything else is None - a call that
+    ran, never a pass (a `done` shell result alone proves nothing)."""
+    if status in ("error", "cancelled"):
+        return True
+    if tool == "Bash" and isinstance(exit_code, int) and not isinstance(exit_code, bool):
+        return exit_code != 0
+    return None
+
+
+def rules_carry_core():
+    """True when Amp's user AGENTS.md holds tezgah-setup's managed block."""
+    try:
+        with open(os.path.join(HOST_DIRS["amp"], "AGENTS.md"), encoding="utf-8") as fh:
+            return "<!-- tezgah:start" in fh.read()
+    except OSError:
+        return False
+
+
+def status_line(cwd, session_id, idx=None):
+    """{status, idx}: the widest plain tier of the checklist. `idx` echoed back
+    skips the git probe behind that mark, as on omp."""
+    segs = health_segments(cwd, session_id,
+                           idx_override=idx if idx in IDX_GLYPHS else None)
+    out = {"status": render_tiers(segs, color=False)[0][0]}
+    glyph = next((s["glyph"] for s in segs if s["key"] == "idx"), None)
+    if glyph:
+        out["idx"] = glyph
+    return out
+
+
+def post_tool(payload, cwd, session_id):
+    """The ledger row for one finished call; {label} for the model."""
+    tool = gate_name(str(payload.get("tool") or ""))
+    inp = gate_input(tool, payload.get("input"))
+    failed = call_failed(tool, payload.get("status"), payload.get("exit_code"))
+    # read before this call's row lands: `source` is the taint's own mark; the
+    # body never crosses, so a non-None stand-in keeps the subagent label
+    own = untrusted_source(tool, inp)
+    if failed is True:
+        source, label = own, untrusted_label(own)
+    else:
+        source, label = safe(session_id, marks, tool, inp, session_id, "") or (None, None)
+    record(session_id, classify(tool, inp))
+    size = payload.get("result_len")
+    if own == SUBAGENT_CHANNEL or not isinstance(size, int) or size < 0:
+        size = None
+    note_tool(session_id, tool, inp, failed=failed, out_bytes=size, source=source,
+              cwd=cwd, empty_run=payload.get("empty_run") is True)
+    if failed is not True:
+        taste = safe(session_id, write_note, session_id, inp, cwd, tool)
+        cross = safe(session_id, cross_project_note, session_id, tool, inp, cwd)
+        label = "\n".join(t for t in (label, taste, cross) if t)
+    out = status_line(cwd, session_id, payload.get("idx")) if payload.get("line") else {}
+    if label:
+        out["label"] = label
+    return out
+
+
+def handle(payload):
+    event = payload.get("event") or ""
+    cwd = payload.get("cwd") or os.getcwd()
+    session_id = payload.get("session_id")
+    safe(session_id, bind_session, session_id)  # the switch latch (tezgah_paths.off)
+    if event == "status":
+        return status_line(cwd, session_id)
+    if event == "pre_tool_use":
+        tool = gate_name(str(payload.get("tool") or ""))
+        reason = decision(tool, gate_input(tool, payload.get("input")), cwd, session_id)
+        return {"deny": reason} if reason else {}
+    if not root_for(cwd):
+        return {}
+    if event == "session_start":
+        sub = bool(payload.get("subagent"))
+        if sub and payload.get("parent"):
+            # the child's ledger opens with its parent, as on omp
+            note(session_id, "spawned", "", parent=str(payload["parent"]),
+                 agent=payload.get("agent"))
+        elif not sub:
+            safe(session_id, attest_session, "amp", session_id, cwd)
+        core = not rules_carry_core() or bool(payload.get("ignore_guidance"))
+        context = context_for("subagent_start" if sub else "session_start", cwd,
+                              dict(payload, host="amp"), with_core=core)
+        out = status_line(cwd, session_id) if payload.get("line") else {}
+        if context:
+            out["context"] = context
+        return out
+    if event == "user_prompt":
+        context = context_for("user_prompt", cwd, dict(payload, host="amp"))
+        return {"context": context} if context else {}
+    if event == "post_tool_use":
+        return post_tool(payload, cwd, session_id)
+    if event == "stop":
+        if off("verify-off"):
+            return {}
+        # `stop_hook_active`: this turn was started by tezgah's own continue, so
+        # the core may refuse it once more at most (tezgah_integrity, plan 083)
+        reason = safe(session_id, stop_reason, payload.get("last_assistant_message"),
+                      session_id, cwd=cwd,
+                      after_block=bool(payload.get("stop_hook_active")),
+                      mode=payload.get("permission_mode"))
+        return {"decision": "block", "reason": reason} if reason else {}
+    if event == "subagent_stop":
+        # record-only (ADR 011): the row lands in the parent's ledger
+        if not off("verify-off") and payload.get("parent"):
+            safe(session_id, stop_reason, payload.get("last_assistant_message"),
+                 session_id, cwd=cwd, subagent=True, agent=payload.get("agent"),
+                 parent=str(payload["parent"]))
+        return {}
+    return {}
+
+
+def main():
+    try:
+        payload = json.load(sys.stdin)
+    except Exception:
+        return
+    if not isinstance(payload, dict):
+        return
+    # one guard around the dispatch: a crash answers "nothing to say", and the
+    # plugin lets every call through (hooks/tezgah_guard.safe)
+    out = safe(payload.get("session_id"), handle, payload) or {}
+    if out:
+        print(json.dumps(out))
+
+
+main()