@r1z4x/tezgah 1.11.0 → 1.13.0

package/docs/research.md

@@ -69,13 +69,15 @@ sections below. Rules 5 add the scope lock. Rules 6 add the selection warnings
 ("Held-out set, repeats and noise band" below). Rules 7 add the `exploratory`
 method ("Rules 7: exploratory lines" below). A bump never weakens an older set.
 Rules 8 (`EVIDENCE_RULES`) add captured evidence and a computed certainty per
-claim ("Rules 8: captured evidence and computed certainty" below). `init` writes 8
-now: `RULES` is `EVIDENCE_RULES` (`hooks/tezgah_research.py::EVIDENCE_RULES`).
+claim ("Rules 8: captured evidence and computed certainty" below). Rules 9
+(`OWNER_CHOICE_RULES`) split a decision's pick: the line writes `recommended:`,
+and `chosen:` is the owner's ("Variants of the deliverable" below). `init` writes 9
+now: `RULES` is `OWNER_CHOICE_RULES` (`hooks/tezgah_research.py::OWNER_CHOICE_RULES`).
 
-A `rules` above `EVIDENCE_RULES` means a later tezgah wrote the line. `check` then reports
+A `rules` above `RULES` means a later tezgah wrote the line. `check` then reports
 one error that names both numbers and reads nothing else. The writers refuse the
 line too: `claim`, `predict`, `compare`, `source --run`, `verdict`, `conclude`,
-`close` and `migrate` (`newer_rules`). Upgrade tezgah to work on such a line.
+`close`, `choose` and `migrate` (`newer_rules`). Upgrade tezgah to work on such a line.
 
 ## Protocol sections (rules 4)
 
@@ -170,7 +172,7 @@ One comparison lives in `decisions/<id>/`, and one loader reads its files
 | `criteria.json` | `criteria`: a list of `{id, kind, direction}`, with `kind` `measured` or `judged` and `direction` `max`, `min` or `pass`. `baseline_variant`: the id of the status-quo variant in `variants.jsonl` |
 | `variants.jsonl` | one `{id, status}` row per variant. A `produced` variant names its `artifact`: a file in the line or the repository, `git:<rev>` or `orx:<id>`. A `dropped` one gives `drop_reason` |
 | `comparison.jsonl` | one cell per variant and criterion, written by `compare` |
-| `decision.md` | the choice and why the others lost |
+| `decision.md` | the line's pick (`recommended:`), the owner's (`chosen:` with `owner:`) and why the others lost |
 
 Write and commit `criteria.json` and `variants.jsonl` before the first cell. Then
 record each cell with `tezgah-research compare <slug> <decision>`, one JSON object
@@ -190,12 +192,27 @@ this same rule.
 - A judged cell with fewer than two distinct raters warns.
 - The criteria have to enter the history before the first cell, and
   `comparison.jsonl` only grows.
-- `decision.md` names a produced variant on a `chosen: <id>` line.
+- `decision.md` names a produced variant on a `chosen: <id>` line, else on a
+  `recommended: <id>` line (`hooks/tezgah_research.py::decision_pick`).
+- On a rules-9 line the line writes its own pick as `recommended:`. A `chosen:`
+  line with no `owner:` line fails with `names no owner choice`. Choosing a
+  variant or option a research, analysis or review recommends is the owner's
+  call. `tezgah-research choose <slug> <decision> <variant> --ack
+  "<the owner's words>"` writes `chosen:` and `owner: <date> "<words>"` and one
+  `log.md` line (`hooks/tezgah_research.py::choose_line`). It works on a done
+  line too: the order seal hashes the experiments alone. It keeps the line's
+  own pick. A pick a rules-8 line wrote as `chosen:` becomes `recommended:`. A
+  rules-8 line's `chosen:` is read as before.
+- `conclude` prints `report to the owner: <id> is recommended, not chosen` for
+  each decision still waiting (`hooks/tezgah_research.py::owner_waits`).
+- The three rules below judge the line's own pick, never the owner's
+  (`hooks/tezgah_research.py::line_pick`). An owner may take a dominated
+  variant, and that is no error of the line.
 - Each other produced variant shares a line of `decision.md` with a criterion id
   that ruled it out. Else: `rejects <id> on no criterion`.
 - `decision.md` has a `flip:` line, the result that would reverse the choice.
 - When every criterion is `max` or `min` and scored, no produced variant may
-  dominate the chosen one. A dominating variant is at least as good on every
+  dominate the picked one. A dominating variant is at least as good on every
   criterion and better on one (`hooks/tezgah_research.py::dominated_by`).
 
 ## One line, one directory
@@ -263,7 +280,15 @@ rule names the open lines with their reason counts on every research turn
 "<reason>"`, which writes the reason into the new line's `log.md` - an explicit
 decision on the record instead of a silent second line - and which is itself
 refused while any open line has `check` errors (`broken_open_lines`): a hatch past
-broken lines is how they stayed broken. What is left of a line that will not be
+broken lines is how they stayed broken. A success criterion whose verdict is
+still `pending` is a line in flight, not a broken one. That error alone does not
+block the hatch, and any other error does. A line another session is running is
+not this session's to fix or close. Both refusals say so
+(`hooks/tezgah_research.py::OWNER_ASK`). The session stops and asks the owner,
+never a way around a tezgah refusal (another folder, a hidden dir). A hidden dir
+under `research/`, `research/open/` or `research/done/` holds no line `check` can
+see. The no-slug `check` and `status` fail it by its path
+(`hooks/tezgah_research.py::stray_dirs`). What is left of a line that will not be
 finished is recorded with `tezgah-research close <slug> --limit "<reason>"`
 (`close_line`), which concludes it and writes the reasons it was still open into
 `state.json` `closed` and `log.md` and seals it ("the order seal", below). Such
@@ -292,7 +317,7 @@ through its seal.
 | `tezgah-research init <slug> [--question "..."] [--class R1..R12] [--allow-open "<reason>"] [--supersedes <slug>]` | scaffolds the line and makes sure `.tezgah/` is ignored by the project and has its own git repository (`tezgah_paths.ensure_workspace`). It refuses while another line is still open (see below), names each open line and its reasons one per line, and `--allow-open "<reason>"` is the way past unless an open line has `check` errors: the reason lands in the new line's `log.md` as its first entry, and an empty reason is misuse. A `--question` another line already asks is refused unless `--supersedes <that line>` says the new line is its next version (`serial_twins`). `--class` writes `state.question_class` and prints `obligations: <step>, ...` (`obligations`), the tier's `budget <slug>: sources a/b searches c/d runs e/f` (`budget`) and `overlap: <line>/<claim> <status> <similarity>` for each done claim close to the question (`overlaps`); `--class R0` exits 1 (`R0 gets no line`) before any other argument is read. Its next-step message names the commit loop: `tezgah-research commit` for the protocol, then again for the results in a later commit (`cmd_init`, `bin/tezgah-research`) | 0, 1 refused, 2 misuse |
 | `tezgah-research commit <slug> "<message>"` | stages and commits only that line's path in `.tezgah`'s private repository - the commit the order rule reads (`cmd_commit`, `bin/tezgah-research`). With nothing left to commit it prints `nothing to commit: <paths> is already committed in <workspace>` and exits 0 | 0 (also with nothing to commit), 1 not a work tree or git failed, 2 misuse |
 | `tezgah-research check [<slug>] [--json] [--strict] [--orx] [--online] [--all-lines] [-- <slug>]` | the discipline checks below. With no slug it checks the open lines in full and a line under `done/` by its order seal alone (`done_seal`, `hooks/tezgah_research.py::done_seal`), naming it only when the seal fails or its `state.json` or seal cannot be read, then prints `research: <n> done line(s): <s> checked by their seal, <u> unsealed (not checked); ...`; `--all-lines` checks every line in full, and `check <slug>` always checks that line in full (ADR 015). `--json` prints the report (no-slug default: the open lines and any done line whose seal read fails), `--strict` turns the unverifiable class into a refusal, `--orx` adds the registry check that asks `orx project view` for this repository (`check_orx`, `hooks/tezgah_research.py::check_orx`) and, on a rules-8 line, the run census; `--online` re-fetches a rules-8 line's citation receipts; a slug after `--` is never read as a flag, which is how the MCP tool `tezgah_research_check` passes its validated `slug`. A rules-8 line (`_check_rules8`) also prints report lines that are never counted - `certainty`, `stats`, `effect`, `instrument`, `ppi`, `stopping`, `online`, `budget` - and `--json` adds its per-claim `certainty` | 0 clean, 1 a line failed a rule or names no line |
-| `tezgah-research status` | one line per line: an open line `ok` or a problem count, a line under `done/` read by its seal like the no-slug `check` - `done, seal ok`, `done, <n> seal problem(s)` or `done, unsealed (not checked)` (`summary`, `hooks/tezgah_research.py::summary`, plan 058 part 4) | 0 |
+| `tezgah-research status` | one line per line: an open line `ok` or a problem count, a line under `done/` read by its seal like the no-slug `check` - `done, seal ok`, `done, <n> seal problem(s)` or `done, unsealed (not checked)` (`summary`, `hooks/tezgah_research.py::summary`, plan 058 part 4); then one `FAIL` line per hidden dir under `research/` (`stray_dirs`) | 0 |
 | `tezgah-research --all` | every checkout of this repository (the main checkout and each linked `git worktree`, `tezgah_paths.worktrees`), one header per checkout, then `  <slug>: <phase>` per line with the reasons it is still open; a checkout with none says `no research line`. Read-only: each checkout keeps its own `.tezgah`, locks and private repository, and nothing here writes to any of them (`across`, `hooks/tezgah_research.py::across`) | 0, 2 misuse |
 | `tezgah-research claim <slug>` | reads one claim from stdin and either appends it under an exclusive lock or refuses it, printing one reason per problem | 0, 1 refused, 2 misuse |
 | `tezgah-research predict <slug>` | reads one prediction row from stdin and either appends it under the same lock or refuses it with one reason per problem; a row whose `commit` git cannot place is appended with the warning printed, which is the fail-open `check` uses, and a row written now has to name at least one component the manifest defines (`append_prediction`, `hooks/tezgah_research.py::append_prediction`) | 0, 1 refused, 2 misuse |
@@ -302,7 +327,8 @@ through its seal.
 | `tezgah-research compare <slug> <decision>` | reads one variants x criteria cell from stdin and appends it to `decisions/<decision>/comparison.jsonl` under the lock, or refuses it by the rule `check` applies (`append_comparison` and `comparison_problems`, `hooks/tezgah_research.py`); it notes when `criteria.json` is not committed yet | 0, 1 refused, 2 misuse |
 | `tezgah-research close <slug> --limit "<reason>"` | concludes the line as a deliberate limit, writing the reasons it was still open into `state.json` `closed` and `log.md`, and seals it (`close_line`) | 0, 1 unreadable state, 2 misuse |
 | `tezgah-research verdict <slug> <id> met\|not-met\|unanswerable --evidence "<ref>"` | records one success criterion's verdict and the evidence it rests on in the line's `state.json`, or refuses it with one `FAIL verdict:` line per problem (`verdict_problems`, `hooks/tezgah_research.py::verdict_problems`) | 0, 1 refused or unreadable state, 2 misuse |
-| `tezgah-research conclude <slug>` | concludes a line once every success criterion carries a verdict, seals it and moves it to `done/` (`conclude_line`, `hooks/tezgah_research.py::conclude_line`) | 0, 1 refused, 2 misuse |
+| `tezgah-research conclude <slug>` | concludes a line once every success criterion carries a verdict, seals it and moves it to `done/` (`conclude_line`, `hooks/tezgah_research.py::conclude_line`); then prints `report to the owner: <id> is recommended, not chosen; ...` for each decision with no owner choice (`owner_waits`) | 0, 1 refused, 2 misuse |
+| `tezgah-research choose <slug> <decision> <variant> --ack "<the owner's words>"` | records the owner's pick: `chosen:` and `owner: <date> "<words>"` in the decision's `decision.md`, one `log.md` line; refuses empty `--ack`, a missing decision and a variant the decision did not produce, on an open or a done line (`choose_line`, `hooks/tezgah_research.py::choose_line`) | 0, 1 refused, 2 misuse |
 | `tezgah-research migrate-layout` | moves flat `research/<slug>` directories into `open/` or `done/` by each line's state, and is idempotent (`migrate_layout`, `hooks/tezgah_research.py::migrate_layout`) | 0, 2 misuse |
 | `tezgah-research seal <slug> [--history-lost] --ack "<owner decision>"` | seals a line under `done/` that was concluded before seals existed: plainly, as `conclude` would, when every experiment's order still checks; with `--history-lost`, with that verdict for every experiment whose order the lost history left undecidable. Refuses a line with a real order violation, a plain seal on any order finding, and a `history-lost` seal with nothing lost (`retro_seal`, `hooks/tezgah_research.py::retro_seal`) | 0, 1 refused, 2 misuse |
 | `tezgah-research import <checkout> [<slug>] [--allow-open "<reason>"]` | brings a line - or every line this checkout lacks - from another checkout's `.tezgah` repository with its history; an open line arrives beside open ones only with `--allow-open` (`import_line`, `hooks/tezgah_research.py::import_line`) | 0, 1 refused, 2 misuse |

package/docs/status-line.md

@@ -311,6 +311,12 @@ Every other surface reads the store.
   legend on hover, pins it on click (16-19,35,47-52,63-64).
 - **Codex** — hosts/codex/hook.py puts the plain line in `systemMessage`
   (182-184,195-198).
+- **Amp** — the plugin draws the widest plain tier
+  (`hosts/amp/hook.py::status_line`) on Amp's experimental status item
+  (`createStatusItem`, TUI only, plain text). It draws only for the thread the
+  user is looking at. It redraws on `session.start`, `agent.end` and each
+  watched tool result, and shows `hook✗` while the hook fails. A build without
+  the API has no status surface (`hosts/amp/tezgah-plugin.ts.in`).
 
 ## Seeing and debugging the line
 

package/docs/testing.md

@@ -66,7 +66,9 @@ conclude from either.
 `.github/workflows/ci.yml` runs on a push to `main` and on a pull request, so
 a branch commit runs once, through its pull request, not twice. A tag push does
 not start it. `release.yml` calls it (`ci.yml:13`) as its `ci` job, so npm and
-brew publish only after CI passed on the release commit. A newer push to the
+brew publish only after CI passed on the release commit. Its first job,
+`on-main`, fails the release when the tag's commit is not on `origin/main`.
+Then no job builds or uploads anything. A newer push to the
 same ref cancels the run it replaces, except on a release (`concurrency`). Every
 job has a `timeout-minutes`, so a hung test cannot hold a runner for six hours.
 No matrix cancels its other legs when one fails (`fail-fast: false`).

package/hooks/hooks.json

@@ -13,7 +13,7 @@
       { "hooks": [ { "type": "command", "command": "TEZGAH_HOST=claude \"${TEZGAH_PYTHON:-python3}\" \"${CLAUDE_PLUGIN_ROOT}/hooks/projects-auto-init.py\"", "timeout": 10 } ] }
     ],
     "PreToolUse": [
-      { "matcher": "Agent|agent|Task|task|Grep|grep|Bash|bash|PowerShell|pwsh|Shell|shell|subagent|Edit|Write|MultiEdit|NotebookEdit|AskUserQuestion", "hooks": [ { "type": "command", "command": "\"${TEZGAH_PYTHON:-python3}\" \"${CLAUDE_PLUGIN_ROOT}/hooks/projects-pretooluse.py\"", "timeout": 5 } ] },
+      { "matcher": "Agent|agent|Task|task|Grep|grep|Bash|bash|PowerShell|pwsh|Shell|shell|Monitor|monitor|subagent|Edit|Write|MultiEdit|NotebookEdit|AskUserQuestion", "hooks": [ { "type": "command", "command": "\"${TEZGAH_PYTHON:-python3}\" \"${CLAUDE_PLUGIN_ROOT}/hooks/projects-pretooluse.py\"", "timeout": 5 } ] },
       { "matcher": "^mcp__(?:.*[^A-Za-z0-9])?(?:append|cancel|clear|click|close|comment|commit|copy|create|delete|deploy|drag|edit|email|evaluate|exec|execute|fill|insert|install|kill|launch|merge|message|mkdir|move|navigate|notify|patch|pause|post|press|print|publish|push|put|release|remove|rename|replace|reply|resume|review|run|save|send|set|share|skip|start|stop|submit|swipe|tag|tap|terminate|type|uninstall|update|upload|write)(?:[^A-Za-z0-9].*)?$", "hooks": [ { "type": "command", "command": "\"${TEZGAH_PYTHON:-python3}\" \"${CLAUDE_PLUGIN_ROOT}/hooks/projects-pretooluse.py\"", "timeout": 5 } ] }
     ],
     "PostToolUse": [

package/hooks/lang/en.json

@@ -224,6 +224,9 @@
   "plan_build": [
    "\\bplans?\\b[^.?!\\n]{0,40}\\b(?:is ready|ready|written|drafted)\\b|\\b(?:wrote|opened|drafted|added|created) (?:the |a |this )?plans?\\b|\\b(?:build|implement|execute|start on|start) (?:the |this |that )?plans?\\b"
   ],
+  "owner_choice": [
+   "\\bwhich (?:variant|option|approach|design)s?\\b|\\b(?:v\\d+|option [a-h1-9]|variant [a-z0-9]+),? or (?:v\\d+|option [a-h1-9]|variant [a-z0-9]+)\\b|\\b(?:another|other|the other) session\\w*|\\bsession'?s (?:line|plan|branch)\\b|\\bclos\\w*\\b[^?\\n]{0,40}\\bline\\b|--allow-open|--limit\\b|\\.staging\\b|\\bhidden (?:dir|directory|folder)\\b|\\b(?:another|a different) (?:folder|dir|directory)\\b|\\b(?:work ?)?around\\b[^?\\n]{0,40}\\brefusal\\b"
+  ],
   "spend": [
    "spend\\w*|\\bpaid\\b|billing|\\bcost\\w*|\\bbudget\\w*|\\busd\\b|\\$\\s?\\d"
   ],
@@ -236,6 +239,12 @@
   "cheap_answer": [
    "yes|yep|yeah|ok(?:ay)?|sure|go(?: on| ahead)?|continue|proceed|do it|carry on|keep going|approved"
   ],
+  "hand_over": [
+   "\\bplease\\s+(?:run|execute)\\b|\\byour\\s+(?:step|turn|move)\\b(?=\\s*[:.;,!]|\\s*$)|\\bover to you\\b"
+  ],
+  "ran_it": [
+   "\\bi (?:ran|tested|verified|checked|executed)\\b|\\bran the (?:tests?|suite|build|lint|checks?)\\b|\\bwe ran\\b"
+  ],
   "outward": {
    "push": "\\bpush\\w*",
    "release": "\\brelease\\w*|\\btag(?:s|ged|ging)?\\b|version bump|bump the version",
@@ -329,6 +338,8 @@
   "slice_lead": "",
   "ready_lead": "",
   "ask_lead": "",
+  "handed_lead": "",
+  "plan_lead": "",
   "approval_heading": "Approval questions",
   "recommended": "Recommended",
   "grant_examples": "\"push without asking\", \"I approve\""

package/hooks/lang/tr.json

@@ -268,6 +268,9 @@
   "plan_build": [
    "\\bplan\\w*[^.?!\\n]{0,40}(?:hazır|yazıldı|yazdım|oluşturdum|oluşturuldu|açtım|açıldı|eklendi|uygula\\w*|başla\\w*|kur\\w*)|(?:yazdığım|açtığım|hazırladığım|oluşturduğum) plan\\w*"
   ],
+  "owner_choice": [
+   "\\b(?:v\\d+|seçenek \\w+|varyant \\w+)(?:'\\w+)? m[ıiuü]\\b,? (?:v\\d+|(?:seçenek |varyant )?\\w+)(?:'\\w+)? m[ıiuü]\\b|\\bhangi (?:varyant|seçenek|opsiyon|yaklaşım|tasarım)\\w*|\\bhangisini seç\\w*|\\b(?:başka|diğer) (?:bir )?oturum\\w*|\\bhatt[ıi]\\w* kapat\\w*|--allow-open|--limit\\b|\\.staging\\b|\\bgizli (?:dizin|klasör)\\w*|\\b(?:başka|farklı) (?:bir )?(?:klasör|dizin)\\w*|\\bred\\w* (?:aş|etrafından)\\w*|\\bengel\\w* (?:aş|etrafından)\\w*"
+  ],
   "spend": [
    "ücret\\w*|ödeme\\w*|harca\\w*|bütçe\\w*|maliyet\\w*|\\bpara\\b|dolar\\w*|\\$\\s?\\d"
   ],
@@ -280,6 +283,12 @@
   "cheap_answer": [
    "evet|tamam|olur|devam(?: et)?|yap|başla|ilerle|okey|onay(?:lıyorum)?"
   ],
+  "hand_over": [
+   "\\b(?:sen|siz)\\b[^.!?\\n]{0,32}?\\bçalıştır(?:ın|ınız)?\\b|\\bsenin adımın\\b|\\badım(?:ı)? sende\\b|\\bsıradaki adım(?:ı)? sen\\b"
+  ],
+  "ran_it": [
+   "\\b(?:test(?:ler)?i|suite'?i|komutu|kontrolü|denetimi)?\\s*(?:çalıştırdım|koştum|çalıştırdık)\\b|\\btest ettim\\b|\\bdoğruladım\\b|\\bkontrol ettim\\b|\\bdenetledim\\b"
+  ],
   "outward": {
    "push": "\\bpush\\w*",
    "release": "versiyon\\w*|sürüm\\w*|\\brelease\\w*|etiket\\w*",
@@ -350,6 +359,8 @@
   "slice_lead": "Durmuş bir dilim var. ",
   "ready_lead": "Hazır adımlar bekliyor. ",
   "ask_lead": "Bu soruyu sorma: kararı ver ya da önerili onay sorusuna çevir. ",
+  "handed_lead": "Bu adımı sen çalıştır, kullanıcıya bırakma. ",
+  "plan_lead": "Plan modunda hiçbir şey koşmadı. ",
   "approval_heading": "Onay için sorular",
   "recommended": "Öneri",
   "grant_examples": "\"bana sormadan pushla\", \"onay veriyorum\""

package/hooks/projects-stop.py

@@ -64,7 +64,8 @@ def main():
     # a core that cannot answer has refused nothing, so the turn ends: the rule
     # never traps a session, and that holds for its own failure too
     reason = safe(session_id, stop_reason, p.get("last_assistant_message"),
-                  session_id, cwd=cwd, after_block=bool(p.get("stop_hook_active")))
+                  session_id, cwd=cwd, after_block=bool(p.get("stop_hook_active")),
+                  mode=p.get("permission_mode"))
     if reason:
         json.dump({"decision": "block", "reason": reason}, sys.stdout)
 

package/hooks/tezgah_agents.py

@@ -245,6 +245,15 @@ def _reviewer_body(host):
         "for those files: account for every listed file as reviewed or skipped\n"
         "with a reason, and still apply everything above - OCR output is input,\n"
         "never a verdict.\n\n"
+        "Plan readiness. When the target is a plan file\n"
+        "(`.tezgah/plans/open/NNN-*.md`) rather than a diff, review whether it\n"
+        "can be built without a question. First restate each section's intent\n"
+        "in one sentence of your own; a section you cannot restate lacks\n"
+        "context, which is a major finding. Then check that every choice the\n"
+        "build needs is made in the plan - schema, API path, dependency,\n"
+        "edge-case handling, the files to change; a choice left to the\n"
+        "implementer is a major finding. A file the plan will create is not a\n"
+        "missing reference. Classify and report exactly as for a diff.\n\n"
         "%s" % (_graph_howto(host), _blast_radius(host), EMPTY_IS_NOT_PROOF,
                 decision, decision, _may_use(host)))
 
@@ -265,14 +274,26 @@ def _worker_body(tier):
                 "report what changed and what each check printed, verbatim. Report\n"
                 "progress, but never redefine the work. Never widen or narrow the brief's\n"
                 "scope, budget or question. If the brief cannot be met as written, say\n"
-                "so and stop rather than answering a different question.\n%s\n"
+                "so and stop rather than answering a different question.\n%s\n%s"
                 "A brief that builds or changes UI: read the `design-contract` skill\n"
                 "(and `design-library` for critique) and derive/check with\n"
                 "`~/.config/tezgah/bin/tezgah-design` before editing.\n"
-                "Never spawn subagents.\n%s" % (tier, tier, scope, WORKER_OUTPUT))
+                "Never spawn subagents.\n%s" % (tier, tier, scope, OWNER_ESCALATE,
+                                                WORKER_OUTPUT))
     return body
 
 
+# A question only the owner can answer climbs past every tier to the user: a
+# worker that settles it itself, frontier included, decided for the owner
+# (plan 136: a line ran under a hidden dir and wrote `chosen:` with no owner
+# choice). One text on every tier.
+OWNER_ESCALATE = ("A question only the owner can answer - choosing a variant or option a\n"
+                  "research, analysis or review recommends; a way around a tezgah\n"
+                  "refusal; deciding about another session's work (its line, plan or\n"
+                  "branch) - is never yours to decide, on any tier: stop and answer\n"
+                  "`ESCALATE: owner` with the options and a recommended default.\n")
+
+
 # The report a consumer reads: the orchestrator re-briefs a report missing one
 # of these fields (_orch_body), so only a role with a reader gets them. One
 # text on every host, since a worker body ignores its host.
@@ -282,7 +303,8 @@ WORKER_OUTPUT = ("End the report, after any other shape asked for, with `Output
                  "- commit: the sha\n"
                  "- checks: each command, its exit code and the last lines of its\n"
                  "  output file, verbatim\n"
-                 "- escalate: the `ESCALATE:` reason (always `none` on tezgah-frontier)")
+                 "- escalate: the `ESCALATE:` reason (on tezgah-frontier only\n"
+                 "  `ESCALATE: owner`, else `none`)")
 
 
 # The specialists beside the tier workers: name -> (what it does, the skills it
@@ -483,6 +505,8 @@ def _orch_body(names):
         "or an ESCALATE, gets one narrower re-brief of the same role naming the\n"
         "missing field or the escalated judgement; only a second miss is\n"
         "restarted on tezgah-frontier with the original brief, never continued.\n"
+        "An `ESCALATE: owner` is neither: its options and default go to the user\n"
+        "in the approval batch, and the orchestrator never answers it itself.\n"
         "Never delegate a task a specialist is not\n"
         "listed for, and never let a subagent spawn its own subagents. Verify each\n"
         "returned claim against the code before acting." % (listed, say()["blocker_tokens"]))

package/hooks/tezgah_attest.py

@@ -11,8 +11,9 @@ One store, not two: the install record is the per-artifact sha file the contract
 artifacts already use (`contract.sha256`, `bin/tezgah-setup::record_contract`),
 one line per entry under a `hook:<host>:<entry>` key. An entry is one hook event's
 tezgah-owned groups (Claude, dsh, Codex, Cursor - so a removed PreToolUse is named
-while PostToolUse stays), opencode's plugin links, and nothing for omp: its bridge
-is compared to a fresh render, the way `rules_current` compares a rules file. The
+while PostToolUse stays), opencode's plugin links, and nothing for omp and Amp:
+their bridge or plugin is compared to a fresh render, the way `rules_current`
+compares a rules file. The
 code an entry runs is hashed only on a packaged install (a tree with no `.git`):
 a checkout install points into a tree its owner edits on purpose. A hook file
 any user can write (0666) is drift too; group write is left alone, because a
@@ -43,10 +44,22 @@ CODE_TARGETS = {
     "cursor": (os.path.join("hosts", "cursor", "hook.py"),),
     "opencode": (os.path.join("hosts", "opencode", "plugins", "tezgah.js"),),
     "omp": (os.path.join("hosts", "omp", "hook.py"),),
+    "qwen": (os.path.join("hosts", "qwen", "hook.py"),),
+    "droid": (os.path.join("hosts", "droid", "hook.py"),),
+    "commandcode": (os.path.join("hosts", "commandcode", "hook.py"),),
+    "copilot": (os.path.join("hosts", "copilot", "hook.py"),),
+    "gemini": (os.path.join("hosts", "gemini", "hook.py"),),
+    "antigravity": (os.path.join("hosts", "antigravity", "hook.py"),),
+    "goose": (os.path.join("hosts", "goose", "hook.py"),),
+    "amp": (os.path.join("hosts", "amp", "hook.py"),
+            os.path.join("hosts", "amp", "tezgah-plugin.ts.in")),
 }
 OPENCODE_DIRS = ("plugins", "plugin")
 OMP_BRIDGE = os.path.join(tp.HOST_DIRS["omp"], "agent", "hooks", "pre",
                           "tezgah-hook.ts")
+# The first line of every Amp plugin tezgah renders: an uninstall removes a
+# file at AMP_PLUGIN only when it equals a fresh render or starts with this.
+AMP_HEADER = "// tezgah: Amp plugin rendered by tezgah-setup"
 
 
 def sha(text):
@@ -82,10 +95,15 @@ def own_groups(data, own=False):
     return out
 
 
-def _manifest(path, own):
+def _manifest(path, own, bare=False, key=None):
+    """`bare`: the file is keyed by event at the top, as Droid's hooks.json is;
+    `key`: the events sit under that top-level name, as Antigravity's do."""
     try:
         with open(path, encoding="utf-8") as fh:
-            return own_groups(json.load(fh), own)
+            data = json.load(fh)
+        if key:
+            data, bare = (data.get(key) if isinstance(data, dict) else None) or {}, True
+        return own_groups({"hooks": data} if bare else data, own)
     except (OSError, ValueError):
         return None
 
@@ -97,11 +115,31 @@ def omp_bridge(root=ROOT):
         with open(os.path.join(root, "hosts", "omp", "tezgah-hook.ts.in"),
                   encoding="utf-8") as fh:
             return fh.read().replace(
-                "@HOOK@", os.path.join(root, "hosts", "omp", "hook.py"))
+                "@HOOK@", js_string(os.path.join(root, "hosts", "omp", "hook.py")))
     except OSError:
         return ""
 
 
+def amp_plugin(root=ROOT):
+    """The Amp plugin as an install writes it: the template with this tree's
+    hook path, or "" when the template is unreadable. The install, the report
+    row, the live probe and the attestation all compare against this."""
+    try:
+        with open(os.path.join(root, "hosts", "amp", "tezgah-plugin.ts.in"),
+                  encoding="utf-8") as fh:
+            return fh.read().replace(
+                "@HOOK@", js_string(os.path.join(root, "hosts", "amp", "hook.py")))
+    except OSError:
+        return ""
+
+
+def js_string(path):
+    """`path` as the inside of a JS double-quoted string: a Windows checkout's
+    `\\t`, `\\u` or `\\x` would otherwise become a control character or a
+    SyntaxError, and the bridge would not load (review of plan 140)."""
+    return json.dumps(path)[1:-1]
+
+
 def registration(host, root=ROOT):
     """({entry: text}, [files]) for the tezgah-owned hook entries this host has
     on disk; the dict is None when the host's file cannot be read."""
@@ -109,9 +147,30 @@ def registration(host, root=ROOT):
         path = os.path.join(root, *(("hooks",) if host == "claude"
                                     else ("hosts", "dsh")), "hooks.json")
         return _manifest(path, own=True), [path]
-    if host in ("codex", "cursor"):
-        path = os.path.join(tp.HOST_DIRS[host], "hooks.json")
-        return _manifest(path, own=False), [path]
+    if host in ("codex", "cursor", "qwen", "droid", "commandcode"):
+        # Qwen's and Command Code's hooks live in a shared settings.json
+        path = os.path.join(tp.HOST_DIRS[host], "settings.json"
+                            if host in ("qwen", "commandcode") else "hooks.json")
+        return _manifest(path, own=False, bare=host == "droid"), [path]
+    if host == "copilot":
+        # tezgah's own file in Copilot's user hooks dir: every entry is ours
+        path = os.path.join(tp.HOST_DIRS["copilot"], "hooks", "tezgah.json")
+        return _manifest(path, own=True), [path]
+    if host == "gemini":
+        # tezgah's own extension: every entry in its hooks.json is ours
+        path = os.path.join(tp.HOST_DIRS["gemini"], "extensions", "tezgah", "hooks",
+                            "hooks.json")
+        return _manifest(path, own=True), [path]
+    if host == "antigravity":
+        # the shared ~/.gemini/config/hooks.json: every entry under its
+        # top-level `tezgah` name is ours
+        path = os.path.join(os.path.dirname(tp.HOST_DIRS["antigravity"]), "config",
+                            "hooks.json")
+        return _manifest(path, own=True, key="tezgah"), [path]
+    if host == "goose":
+        # tezgah's own plugin: every entry in its hooks.json is ours
+        path = os.path.join(tp.GOOSE_PLUGIN, "hooks", "hooks.json")
+        return _manifest(path, own=True), [path]
     if host == "opencode":
         links = (os.path.join(tp.HOST_DIRS["opencode"], d, "tezgah.js")
                  for d in OPENCODE_DIRS)
@@ -124,6 +183,12 @@ def registration(host, root=ROOT):
                 return {"bridge": fh.read()}, [OMP_BRIDGE]
         except OSError:
             return None, [OMP_BRIDGE]
+    if host == "amp":
+        try:
+            with open(tp.AMP_PLUGIN, encoding="utf-8") as fh:
+                return {"plugin": fh.read()}, [tp.AMP_PLUGIN]
+        except OSError:
+            return None, [tp.AMP_PLUGIN]
     return None, []
 
 
@@ -148,7 +213,7 @@ def record_texts(host, root=ROOT):
     """{key: text} an install records for one host (`bin/tezgah-setup::record_hooks`)."""
     entries, _files = registration(host, root)
     out = {}
-    if host != "omp":
+    if host not in ("omp", "amp"):
         out.update((KEY % (host, name), text)
                    for name, text in (entries or {}).items())
     code = code_text(host, root) if packaged(root) else None
@@ -173,10 +238,14 @@ def drift(host, root=ROOT, shas=None):
         if mode & 0o002:
             found.append("%s mode %04o" % (path, mode))
     if entries is None:
-        found.append("%s unreadable or missing" % files[0])
+        # a host `registration` does not know names no file: say so, never IndexError
+        found.append("%s unreadable or missing" % (files[0] if files else host))
     elif host == "omp":
         if entries["bridge"] != omp_bridge(root):
             found.append("omp bridge %s differs from a fresh render" % OMP_BRIDGE)
+    elif host == "amp":
+        if entries["plugin"] != amp_plugin(root):
+            found.append("amp plugin %s differs from a fresh render" % tp.AMP_PLUGIN)
     else:
         names = set(recorded) - {"code"}
         if not names:

package/hooks/tezgah_context.py

@@ -1354,11 +1354,17 @@ def session_of(payload):
 # again on 2026-10-22 (plan 126, second pass): a research ask arms the Research
 # and Product paragraphs (6239 B on Claude, S4Remeasure p08) and the skill hint
 # that names the research skill (about 330 B with its path) was the block given
-# up, so the prompt budget moves to 7000 B. A
+# up, so the prompt budget moves to 7000 B. Moved again on 2026-10-28 (plan
+# 136): the subagent pointer says an owner-only question goes back as
+# `ESCALATE: owner` (+330 B), the fixture's subagent_start reached 5958 B and
+# gave up `consult` (205 B), so subagent_start moves to 6100 B. Moved again on
+# 2026-10-29 (plan 142): the output-shape paragraph says what the host's plan
+# mode changes (+168 B), and the worktree fixture's session_start gave up its
+# worktrees line again, so the session budgets move to 16200 B. A
 # budget in bytes, not tokens: this file has no tokenizer and a wrong estimate
 # would be worse than a bound.
-CONTEXT_BUDGET = {"session_start": 16000, "post_compact": 16000,
-                  "subagent_start": 5800, "user_prompt": 7000}
+CONTEXT_BUDGET = {"session_start": 16200, "post_compact": 16200,
+                  "subagent_start": 6100, "user_prompt": 7000}
 DEFAULT_BUDGET = 13000
 # The blocks in the order they are given up when the budget is exceeded, lowest
 # value first: text another surface already carries (the plan table lives in the
@@ -1520,12 +1526,13 @@ GATE_MIN_CALLS = 3
 # The tool names whose every call leaves a PreToolUse row (`began`,
 # tezgah_gate.decision's write and shell branch) and every refused one a `deny`:
 # Claude's write and shell tools, omp's `bash`/`edit`/`write` and Codex's
-# `exec_command`/`apply_patch`. A
+# `exec_command`/`apply_patch`, Droid's `Execute`/`Create`/`ApplyPatch`. A
 # tool the gate may pass without a row (Read, Grep, Task, WebFetch, an MCP
 # call) is not counted, so its absence from the ledger is never read as a
 # disarmed gate.
 GATED_TOOLS = re.compile(r"(?i)^(?:bash|powershell|pwsh|edit|write|multiedit|"
-                         r"notebookedit|exec_command|shell|apply_patch)$")
+                         r"notebookedit|exec_command|shell|apply_patch|"
+                         r"execute|create|applypatch)$")
 GATE_INACTIVE = (
     "tezgah gate inactive on this host: %d gated tool call(s) since this "
     "session's first turn and not one row from the gate, so the shortcut "
@@ -1651,7 +1658,8 @@ def context_nudge(payload, session_id):
 # The ledger kinds a hook other than the tool hooks writes: the prompt hook's
 # turn marker, judge row, lesson rows and disarm row, the Stop hook's claim,
 # refusal, after_block and shape rows and the stop_spec rows of plan 063's shadow
-# (old ledgers only), the subagent-end hook's subagent_end row,
+# (old ledgers only), the subagent-end hook's subagent_end row, Droid's Stop
+# `reply_unread` row (a turn end whose reply the transcript did not yield),
 # compaction, the subagent mark and the `subagent_start` lineage row (both from
 # SubagentStart), the omp fork's `forked` row, the guard's crash
 # row (any hook), the damage row any reader writes and the session start's
@@ -1664,7 +1672,7 @@ NOT_TOOL_HOOK = frozenset((b"turn", b"judge", b"claim", b"refusal",
                            b"after_block", b"subagent_end", b"stop_spec",
                            b"shape", b"compact", b"orch", b"crash", b"route",
                            b"spawned", b"forked", b"lesson", b"disarm", b"ledger_damage",
-                           b"attest", b"subagent_start"))
+                           b"attest", b"subagent_start", b"reply_unread"))
 # The rows PostToolUse writes (`note_tool`): they prove the host ran the call,
 # not that the gate saw it - a PostToolUse hook keeps writing them while a
 # broken PreToolUse hook lets every call through - so they are no proof either.
@@ -2450,7 +2458,12 @@ def context_for(event, cwd, payload=None, with_core=True):
                       "(each tagged DERIVED, you concluded it, or RETRIEVED, "
                       "you read it), Evidence (the path:line or command behind "
                       "each), Confidence, Unresolved, Disconfirming, Conflicts. "
-                      "Full rules: the `tezgah-contract` skill."))
+                      "A question only the owner can answer - choosing a variant "
+                      "or option a research, analysis or review recommends; a way "
+                      "around a tezgah refusal; deciding about another session's "
+                      "work (its line, plan or branch) - is never yours: return "
+                      "`ESCALATE: owner` with the options and a recommended "
+                      "default. Full rules: the `tezgah-contract` skill."))
     else:
         parts.append(("pointer", POINTER_LINE))
     text = budgeted(event, [(key, render(text.strip())) for key, text in parts])