@r1z4x/tezgah 1.13.0 → 1.14.0

package/docs/skills.md

@@ -217,8 +217,8 @@ inside the repository (`hooks/tezgah_skill_pick.py::section_hint`,
 Measured on this machine on 2026-10-07: 7 502 sections and a 9.5 MB index. The
 one cold rebuild took 1.36 s, and a warm prompt takes 6-15 ms. On a turn it
 fires the line costs 196-239 bytes on omp and 245-320 elsewhere. It is not a
-judgement, so `judge-off` leaves it on. `reminder-off` drops it with the rest
-of the per-turn text (`tests/test_skill_search.py::LocalHint`,
+judgement, so `judge-off` leaves it on, and so does `reminder-off`, which drops
+only the reminder line (`tests/test_skill_search.py::LocalHint`,
 `OmpPromptPath`).
 
 
@@ -226,10 +226,31 @@ of the per-turn text (`tests/test_skill_search.py::LocalHint`,
 
 `SKILLS` in `bin/tezgah-setup::SKILLS` is the shipped list, and it is the single
 definition of "a tezgah skill": the router, the per-host linking, the uninstall
-and the context budget all read it. Each install function links those
-directories into the host's own skill directory - Codex
-(`bin/tezgah-setup::install_codex`), opencode (`bin/tezgah-setup::install_opencode`), Cursor (`bin/tezgah-setup::install_cursor`), dsh
-(`bin/tezgah-setup::install_dsh`), omp (`bin/tezgah-setup::install_omp`). Claude is the exception: it installs from a
+and the context budget all read it. Every host but Claude has an install function
+that links those directories into the host's own skill directory:
+
+| Host | Install function | Skill directory |
+|---|---|---|
+| Codex | `bin/tezgah-setup::install_codex` | `$CODEX_HOME/skills` |
+| opencode | `bin/tezgah-setup::install_opencode` | `~/.config/opencode/skills` |
+| Cursor | `bin/tezgah-setup::install_cursor` | `~/.cursor/skills`, only for a skill no other dir Cursor reads already links |
+| dsh | `bin/tezgah-setup::install_dsh` | `$DSH_HOME/skills` |
+| omp | `bin/tezgah-setup::install_omp` | `~/.omp/agent/skills` |
+| Qwen Code | `bin/tezgah-setup::install_qwen` | `$QWEN_HOME/skills` |
+| Droid | `bin/tezgah-setup::install_droid` | `~/.factory/skills` |
+| Command Code | `bin/tezgah-setup::install_commandcode` | `~/.commandcode/skills` |
+| Copilot CLI | `bin/tezgah-setup::install_copilot` | `$COPILOT_HOME/skills` |
+| Gemini CLI | `bin/tezgah-setup::install_gemini` | `~/.gemini/extensions/tezgah/skills` |
+| Antigravity | `bin/tezgah-setup::install_antigravity` | `~/.gemini/antigravity-cli/skills` |
+| Goose | `bin/tezgah-setup::install_goose` | `~/.agents/plugins/tezgah/skills` |
+| Amp | `bin/tezgah-setup::install_amp` | `~/.config/amp/skills` |
+
+Cursor reads `~/.codex/skills`, `~/.claude/skills` and `~/.agents/skills` too,
+and names no winner for a skill found twice. So a skill one of those already
+links to this tree is not linked into `~/.cursor/skills` again
+(`bin/tezgah-setup::cursor_shared_copy`, `bin/tezgah-setup::CURSOR_SHARED_SKILLS`). The install prints
+`<n> skills reach Cursor through <dir>, not linked twice`. Cursor installs after
+Codex, so it sees Codex's links. Claude is the exception: it installs from a
 plugin, so the skills arrive in the COPY at
 `~/.claude/plugins/cache/<marketplace>/tezgah/<version>/` that `--sync` refreshes
 and `--install` re-refreshes when it is stale (`bin/tezgah-setup:26-29`,
@@ -238,8 +259,10 @@ and `--install` re-refreshes when it is stale (`bin/tezgah-setup:26-29`,
 
 The install report checks the file, not the link. `skills_linked()` requires
 every name in `SKILLS` to resolve to a readable `SKILL.md` under the host
-directory (`skills_linked()`, `bin/tezgah-setup::skills_linked`), and it is used for every host row
-(`bin/tezgah-setup::host_checks_codex`, `bin/tezgah-setup::host_checks_opencode`, `bin/tezgah-setup::host_checks_cursor`, `bin/tezgah-setup::host_checks_dsh`, `bin/tezgah-setup::host_checks_omp`). It was
+directory (`skills_linked()`, `bin/tezgah-setup::skills_linked`), and the `skills linked` row of
+every host but Claude and Cursor calls it (`host_checks_<host>`, for example
+`bin/tezgah-setup::host_checks_codex`). Cursor's row accepts either a readable
+`SKILL.md` under `~/.cursor/skills` or a shared copy (`bin/tezgah-setup::host_checks_cursor`). It was
 `islink()` once, and a link to nothing is a link: a name whose `SKILL.md` was
 never written reported as linked on every host at once while no host could read
 it (`tests/test_skills.py::SkillStandards`).

package/docs/status-line.md

@@ -15,8 +15,8 @@ host-neutrally by `health_segments()` (`hooks/tezgah_context.py::health_segments
 groups (`hooks/tezgah_context.py::render_line`). The group is *data on each segment*: a renderer building its
 own line from `--json` separates on `seg.group` and matches `render_line()`
 without a second copy of the partition (`hooks/tezgah_context.py::health_segments`) — opencode and dsh do exactly
-that (hosts/opencode/tui/tezgah-tui.tsx:108-111,
-hosts/dsh/statusline/lib/client.js:86-90).
+that (`TezgahBar` in `hosts/opencode/tui/tezgah-tui.tsx`,
+`TezgahStatusLine` in `hosts/dsh/statusline/lib/client.js`).
 
 | group | members | why together |
 |---|---|---|
@@ -173,7 +173,12 @@ group separators stay identical for every extension. An extension never has to
 know the gutter. It must name `text` and `state`. tezgah fills a missing `glyph`
 from the state's own mark, so a chip reads like a built-in. The per-extension cap
 (`MAX_SEGMENTS`) and the hard timeout (`timeout_ms`, default
-`DEFAULT_TIMEOUT_MS`) bound one row.
+`DEFAULT_TIMEOUT_MS`) bound one row. The command prints one JSON object whose
+`segments` key holds that list. tezgah reads a bare list on stdout as malformed output:
+
+```json
+{"segments": [{"key": "cyber-eng", "state": "on", "text": "eng"}]}
+```
 
 It is a subprocess and not an import on purpose. The extension is the user's
 repo, in whatever language, and may be slow or broken. A bounded child keeps a
@@ -229,10 +234,13 @@ python is asked (`hooks/tezgah_context.py::skill_read_kind`). A surface that can
 was never opened", so it declares what it can see and those marks render `info`
 (dim, no glyph) instead of `ready` (`observable`, `hooks/tezgah_context.py::health_segments`; the set constant
 `TOOL_USE_MEASURES`, `hooks/tezgah_context.py::TOOL_USE_MEASURES`). The `--observable=` flag carries it on the CLI
-(`bin/tezgah-status::main`). Two callers pass the tool-use set: Cursor's
-status line (statusline.py:117-121) and Codex, which renders the line plain into
-`systemMessage` (`hosts/codex/hook.py::main`); dsh passes the literal flag
-string (hosts/dsh/statusline/lib/index.js:16-19,84,96), which names the five marks its
+(`bin/tezgah-status::main`). Every host whose line reads the store and cannot see
+a skill read passes the tool-use set: the status line for Cursor, Qwen, Droid, Copilot and Antigravity
+(`statusline.py::HOST`, `statusline.py::observable`), and Codex, Command Code
+and Gemini, which render the line plain into `systemMessage`
+(`hosts/codex/hook.py::main`, `hosts/commandcode/hook.py::status`,
+`hosts/gemini/hook.py::status`); dsh passes the literal flag
+string (`OBSERVABLE` in `hosts/dsh/statusline/lib/index.js`), which names the five marks its
 own hook can record - `judge` included, since dsh wires the same PostToolUse hook
 every other host does. The set is what a host can write, not what it happens to
 have written: a mark the literal omits reads `info` there rather than a claim.
@@ -248,15 +256,15 @@ the five kinds are ever written (`hooks/tezgah_context.py::record`).
 
 Writers: the shared PostToolUse hook `hooks/projects-posttooluse.py` — `graph` from
 an MCP tool name, else the shell tokenizer's answer, which counts a tool only when
-the command really ran it (34-38,84) and is the one writer that can earn `judge`
+the command really ran it (`hooks/projects-posttooluse.py::used_kind`) and is the one writer that can earn `judge`
 (a run of `bin/tezgah-triage` or `bin/tezgah-docs`, `shell_kind`, `hooks/tezgah_context.py::shell_kind`)
 — plus `hooks/projects-auto-init.py::main`
 (`orch` on subagent start), `hosts/codex/hook.py::main`,
-`hosts/cursor/hook.py::dispatch`, hosts/opencode/plugins/tezgah.js:2167-2174,
-hosts/opencode/plugins/tezgah.js:2725, `hosts/omp/hook.py::handle`. Both Claude (hooks/hooks.json) and dsh
+`hosts/cursor/hook.py::dispatch`, `record` in `hosts/opencode/plugins/tezgah.js`,
+`hosts/omp/hook.py::handle`. Both Claude (hooks/hooks.json) and dsh
 (hosts/dsh/hooks.json) wire PostToolUse to that one shared hook, which is how dsh
 gets any used mark at all: with no local transcript, the store is the only channel
-its line has (hooks/projects-posttooluse.py:45-49).
+its line has (`hooks/projects-posttooluse.py::used_kind`).
 
 Claude's line never reads the store: it parses `tool_use` blocks out of
 `payload["transcript_path"]` plus the subagent transcripts under it, which is how
@@ -269,15 +277,15 @@ Every other surface reads the store.
   picks the host from `--cursor` or `TEZGAH_STATUS_HOST`, renders
   `render_line(segs, color=color_default())`, and joins Orca's own status line to
   the tezgah segment with `  |  `; `TEZGAH_STATUS_LEGEND=1` appends the legend
-  (31-34,40-48,116-122). ANSI is dropped under `NO_COLOR` or
+  (`statusline.py::HOST`, `statusline.py::seg`, `statusline.py::out`). ANSI is dropped under `NO_COLOR` or
   `TEZGAH_STATUS_COLOR=0` (`color_default()`, `hooks/tezgah_context.py::color_default`).
 - **omp** — hosts/omp/tezgah-hook.ts.in: `draw()` prefers
   `ctx.ui.setWidget("tezgah", [line], {placement: "belowEditor"})`, which renders
   the colored string as-is; `setStatus` is the fallback for a build without
-  `setWidget`, and it is plain because omp strips ANSI (12-29). `status_line()`
+  `setWidget`, and it is plain because omp strips ANSI (`draw` in `hosts/omp/tezgah-hook.ts.in`). `status_line()`
   builds the line and carries `idx_override`, so a per-tool redraw forks no git
   (`hosts/omp/hook.py::status_line`); it redraws on session start, session switch, turn end
-  and each watched tool result (hosts/omp/tezgah-hook.ts.in:596-636,674-679,720-745).
+  and each watched tool result (`refresh` and `WATCHED` in `hosts/omp/tezgah-hook.ts.in`).
   **Motion:** while the agent runs (`agent_start` until an `agent_end` whose
   `isTerminal` is not `false`) the widget leads with a braille spinner, the tool
   in flight (`tool_execution_start`/`_end`, "thinking" between tools) and the
@@ -297,20 +305,20 @@ Every other surface reads the store.
   (`tui.json`'s `plugin` array, not the server plugin) registering an `app_bottom`
   slot, shelling out to `tezgah-status <dir> --json <sessionID>`, coloring each
   segment from the active theme and rebuilding the separator from `seg.group`
-  (56-88,hosts/opencode/tui/tezgah-tui.tsx:108-111). Its `tezgah: status legend` command opens a dialog running
-  `--legend` (141-147).
+  (`TezgahBar` in `hosts/opencode/tui/tezgah-tui.tsx`). Its `tezgah: status legend` command opens a dialog running
+  `--legend` (`LegendDialog` in `hosts/opencode/tui/tezgah-tui.tsx`).
   On opencode 2 the same line comes from hosts/opencode/tui/cli/tui.tsx, a
   `Plugin.define` CLI plugin listed in `cli.json`. It reuses the v1 file's `run`.
 - **dsh** — hosts/dsh/statusline/lib/index.js serves `GET /api/tezgah.status`
   behind the Web UI's own authenticated fetch fence, so the browser fetches it
-  same-origin with no extra token handling (14,34-38); it always passes
-  `--observable=consult,research,graph,orch,judge` (18,47-48) and returns `{segments,
-  legend}` for `?format=json`, plain text otherwise (49-56,63). Its client half
+  same-origin with no extra token handling (`apply` in `hosts/dsh/statusline/lib/index.js`); it always passes
+  `--observable=consult,research,graph,orch,judge` (`OBSERVABLE` in `hosts/dsh/statusline/lib/index.js`) and returns `{segments,
+  legend}` for `?format=json`, plain text otherwise (`statusText` in `hosts/dsh/statusline/lib/index.js`). Its client half
   (hosts/dsh/statusline/lib/client.js) renders the marks in the session header in
   fixed light/dark colors, polls every 10 s while the tab is visible, and shows the
-  legend on hover, pins it on click (16-19,35,47-52,63-64).
+  legend on hover, pins it on click (`TezgahStatusLine` in `hosts/dsh/statusline/lib/client.js`).
 - **Codex** — hosts/codex/hook.py puts the plain line in `systemMessage`
-  (182-184,195-198).
+  (`hosts/codex/hook.py::main`).
 - **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
@@ -336,7 +344,8 @@ tezgah-status --judge                        # what the judge used last, and why
 
 The session id is the second positional argument or `TEZGAH_SESSION`; without it
 the used marks cannot light up (`bin/tezgah-status::main`). `--color`/`--no-color` force ANSI or plain,
-`--observable=` narrows the measures as above, and an unknown flag exits 2 (`bin/tezgah-status::main`).
+`--observable=` narrows the measures as above, and an unknown flag exits 2. So does
+an `--observable=` measure outside `TOOL_USE_MEASURES` plus `pony` and `adhd` (`bin/tezgah-status::main`).
 
 `--counters` is not the marks: it prints `tezgah_integrity.counters(session)` —
 `steps`, `tool_error_rate`, `claims`, `false_completion`, `shape_blocked`,
@@ -413,7 +422,8 @@ could not be read - so the mark refuses to say either fresh or stale, and
 `index_notice()` says on the turn that the graph's age is unknown. On a host that
 sandboxes hook writes (dsh) the stamp is never written, and before that state
 existed the mark read green there for good. That is why `observable` exists (`hooks/tezgah_context.py::health_segments`),
-why the skill-read check is documented as unavailable on Codex, Cursor and dsh
+why the skill-read check is documented as unavailable on every host that passes
+the tool-use set or the dsh literal (see `--observable=` above)
 (`hooks/tezgah_context.py::skill_read_kind`), why omp ignores any `idx` value that is not one of
 its five glyphs (`hosts/omp/hook.py::status_line`) - a value outside that set re-probes
 instead of being reused, one fork and never a wrong mark - and

package/docs/testing.md

@@ -47,7 +47,7 @@ baseline on the next run. Only `--clarity --update` raises it.
 A pin is a claim about what ran, not a guarantee about what will. This repository
 has two, and both are about the language rather than about dependencies: the
 floor `py310` (`pyproject.toml:5`) and the CI matrix that proves it
-(`.github/workflows/ci.yml:114`). There is no dependency lockfile to pin
+(the `test` job's `python-version` matrix in `.github/workflows/ci.yml`). There is no dependency lockfile to pin
 because there is no package: tezgah is a set of scripts run in place, and no
 `[project]` or build system is declared (`pyproject.toml:1-2`). The only
 third-party tool the checks name is ruff, at a version in
@@ -65,10 +65,15 @@ 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
+not start it. `release.yml` calls it (its `workflow_call` trigger) as its `ci` job, so npm and
 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
+Then no job builds or uploads anything. Next, `green` looks for a finished push
+run of `ci.yml` on the same commit. It waits for a running one and counts only
+`success`, and then `ci` does not run: a release does not run the suite twice. No
+such run, or any other outcome, runs `ci` as before. `npm-publish` and
+`brew-formula` need `green` and `ci`, and publish when either answered green.
+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`).
@@ -79,33 +84,58 @@ No matrix cancels its other legs when one fails (`fail-fast: false`).
   empty diff, a base it cannot read, a release or a manual run runs everything.
 - `docs`, prose only: the citations audit, the clarity audit and
   `tests/impacted.py --ref <base>`, which maps a docs page to the docs modules.
-- `test` (`ci.yml:100`) on Python 3.10 and 3.14, the floor and the ceiling.
-  It byte-compiles, lints with ruff from `requirements-dev.txt` (pip cached),
-  audits the docs citations and clarity and runs `TEZGAH_E2E_STRICT=1 python3
-  tests/e2e_plan_flow.py`. A release passes the `release` input and runs one
-  3.10 leg.
-- `test-sharded` (`ci.yml:142`) on Python 3.10 and 3.14 with node 22 (the
+- `test` runs on Python 3.10 and 3.14, the floor and the ceiling. Its first steps
+  are "Byte-compile every script", "Install ruff" (from `requirements-dev.txt`,
+  pip cached) and "Lint". Then come "Every docs citation lands in the symbol it
+  names" and "The docs prose audit". The last two are "The plan and decision
+  rules, in a real project" (`TEZGAH_E2E_STRICT=1 python3 tests/e2e_plan_flow.py`)
+  and "The research checks against their known-truth set" (`python3
+  bin/tezgah-research release-check`). A release passes the `release` input and
+  runs one 3.10 leg.
+- `test-sharded` on Python 3.10 and 3.14 with node 22 (the
   first line that loads the omp `.ts` hook without a flag). On `main` and a
-  release it runs `python3 tests/impacted.py --all`. On a pull request it runs
-  `--ref <base>`: the modules the change maps to, and the whole suite when the
-  map does not know a path. It replaced the serial `unittest discover` step on
+  release its step "Run the suite, sharded" runs `python3 tests/impacted.py --all`.
+  On a pull request "Run the impacted modules, sharded (pull request)" runs
+  `--ref <base>` instead. That runs the modules the change maps to, or the whole
+  suite when the map does not know a path. It replaced the serial `unittest discover` step on
   2026-10-13: both caught the same failures, and the serial step took about 30
   minutes.
-- `apps-e2e` (`ci.yml:175`) on Python 3.12 and node 20: one step,
+- `apps-e2e` on Python 3.12 and node 20: one step, "App MCP handshake
+  (playwright + mobile-mcp)",
   `TEZGAH_E2E_STRICT=1 python3 tests/e2e_analyze_wiring.py`. It completes the
   app-MCP handshake only - no browser, no device - so it stays deterministic;
   strict mode makes a server that cannot start a failure rather than a skip, so
   a broken wire cannot hide behind a skip (`e2e_analyze_wiring.py:4-12`).
-- `artifact-install` (`ci.yml:200`) on Python 3.10 and 3.12: builds the
+- `artifact-install` on Python 3.10 and 3.12: builds the
   tarball, installs from it under a temp prefix, and runs the artifact smoke on
   the installed tree instead of the checkout.
-- `artifact-install-windows` (`ci.yml:243`) on `windows-latest`: the same
+- `artifact-install-windows` on `windows-latest`: the same
   build, install and smoke through `packaging/install.ps1` - the twin a Windows
   user runs - so it is the only place the Windows claim is proven. It then runs
   the opencode plugin's path tests natively, `tezgah update --dry-run`, the
   opencode live probe and `--uninstall` from the installed tree. Any residue
   under the prefix fails it.
 
+Four node harnesses run JavaScript and TypeScript the suite cannot import. Their
+Python modules drive them, so they run wherever those modules run: in
+`test-sharded`, which installs node 22, and locally under `tests/impacted.py`.
+
+- `tests/_opencode_plugin_harness.mjs` loads the opencode plugin
+  (`tests/test_opencode_plugin.py`).
+- `tests/_omp_extension_harness.mjs` loads the omp extension
+  (`tests/test_omp_extension.py`) and `tests/_amp_plugin_harness.mjs` the Amp
+  plugin (`tests/test_amp_plugin.py`). Both need a node that strips types
+  (22.18+).
+- `tests/_workflow_harness.mjs` is a stub of the Workflow runtime. It runs
+  `workflows/graph-review.js`, `workflows/graph-impact.js` and
+  `workflows/graph-map.js` as async function
+  bodies. It answers each `agent()` from a fixture, and `null` is a failed agent.
+  `python3 -m pytest tests/test_graph_workflows.py` runs it.
+
+Without node, or with a node too old for `.ts`, these modules skip rather than
+fail, so a leg with no node passes them silently. `test-sharded` is the leg
+that proves them.
+
 `.github/workflows/neuter.yml` runs two jobs weekly, on demand, and on a push to
 `main` that changes a guard, the matrix or a test module it runs. The matrix is
 CI's, not the local loop's. The first job, `neuter`, asks the question the suite
@@ -127,10 +157,11 @@ row.
 Each mutant first runs alone the test that killed it last time, read from
 `tests/neuter_killers.json`. When that test passes or is gone, the mutant runs
 every module in its own HOME and TMPDIR. The module that reads the mutated file
-goes first. The first failing test becomes its new entry. The
+goes first. With `--update-killers`, the first failing test becomes its new
+entry. Without it, the tracked cache is left as it was. The
 control runs every module, then every cached killer alone, so a killer that
 fails without a mutant voids the run. A session that adds a deny rule checks its
-one mutant with `python3 tests/neuter_matrix.py --only <name>`.
+one mutant with `python3 tests/neuter_matrix.py --only <name> --update-killers`.
 
 The second, `fuzz-shell`, runs the bash-oracle fuzzer (`tests/fuzz_shell.py`)
 under the ubuntu runner's bash 5.x. Locally, macOS ships bash 3.2. A first step

package/docs/vision.md

@@ -117,8 +117,12 @@ conflicting SWE-bench split, the agent cheated in 0 of 132 runs with tezgah and
 no headroom. Hand labels of final messages on those impossible tasks found
 false done claims in 3 of 30 runs with tezgah and 6 of 30 without. The CI of
 that difference includes 0. The Stop rule's claim reader
-flagged far more runs than that. On Turkish replies it counts `doğrulandı`
-(verified) on a partial fix as a claim, a recorded weakness not yet fixed. The
+flagged far more runs than that. On Turkish replies it counted `doğrulandı`
+(verified) on a partial fix as a claim, even beside a `doğrulanmadı`. Commit
+9cb4d1d fixed that shape. Its held-out recall is 0.857, below the 0.9 bar. A
+narrower gap remains. A Turkish partial fix with no admission word
+(`hâlâ başarısız`, `kısmen`) still reads as done and verified. Its English twin
+reads as verification only. The
 numbers, the per-task counts and the instrument flaws are in
 [the results bundle](results/paired-outcome-2026-10.md).
 

package/hooks/lang/en.json

@@ -1,13 +1,13 @@
 {
  "name": "English",
  "done": [
-  "done|complete[d]?|finished|implemented|fixed|shipped|landed|merged|wired up|wired into|all tests? pass|all checks? pass|(?:tests?|checks?|suite) (?:is |are )?(?:green|passing)|build (?:passes|is green)"
+  "done|complete[d]?|finished|implemented|fixed|(?<!\\bis )(?<!\\bare )(?<!\\bget )(?<!\\bgets )(?<!\\bbe )(?<!\\bbeing )(?<!-)updated(?!-)|shipped|landed|merged|wired up|wired into|(?:all )?(?:tests?|checks?|suite|build) passed|(?:all )?(?:tests|checks) pass|(?:suite|build) passes|(?:tests?|checks?|suite) (?:is |are )?(?:green|passing)|build is green"
  ],
  "verified": [
   "tested|verified|i ran|ran the (?:tests?|suite|build|lint|checks?)"
  ],
  "negated": [
-  "unverified|not verified|could ?n[o']t verify|verification (?:was )?skipped"
+  "unverified|not verified|could ?n[o']t verify|verification (?:was )?skipped|^\\s*(?:untested|not (?:yet )?(?:been )?(?:tested|checked))\\b|(?:^|[.!;]\\s+)(?:(?:this|the) (?:change|fix|patch)|it|i)\\b[^.\\n]{0,24}?(?:not|n't) (?:yet )?(?:been )?tested|not checked yet"
  ],
  "admitted": [
   "contradict|unsatisfiable|(?:can ?not|can't|can ?never|never) pass|impossible"
@@ -36,6 +36,9 @@
  "negation_before": [
   "\\bnot|n't|\\bnever"
  ],
+ "condition_before": [
+  "\\b(?:if|when|once|unless|until|whether)\\b"
+ ],
  "question_particle": [],
  "question_end": [],
  "clause_join": [

package/hooks/lang/tr.json

@@ -1,7 +1,7 @@
 {
  "name": "Turkish",
  "done": [
-  "yaptım|tamamladım|tamamlandı|bitirdim|bitirildi|ekledim|eklendi|düzelttim|düzeltildi|hallettim|güncellendi|kuruldu|uygulandı|yayına girdi|kapatıldı|yüklendi|tüm testler geçti|testler geçti|testler yeşil|çalışıyor"
+  "yaptım|tamamladım|tamamlandı|bitirdim|bitirildi|ekledim|eklendi|düzelttim|düzeltildi|hallettim|güncellendi|kuruldu|uygulandı|yayına girdi|kapatıldı|yüklendi|tüm testler geçti|testler geçti|testler geçiyor|testler yeşil|çalışıyor"
  ],
  "verified": [
   "doğruladım|test ettim|kontrol ettim|denetledim|doğrulandı|test edildi"
@@ -89,6 +89,7 @@
  "negation_before": [
   "\\bdeğil"
  ],
+ "condition_before": [],
  "question_particle": [
   "m[ıiuü]|değil"
  ],
@@ -200,7 +201,7 @@
    "ürün(?!\\w*_)\\w*|yol harita\\w*|kuzey yıldız\\w*|aktivasyon\\w*|dönüşüm\\w*|fiyatlandır\\w*|önceliklendir\\w*|kullanıcı araştırma\\w*|ürün keşf\\w*|müşteri geri bildirim\\w*|benimsen\\w*|konumlandır\\w*|segmentasyon\\w*|hedef kitle\\w*|(kullanıcı|müşteri) discovery|keşif (görüşme|çalışma)\\w*|fırsat\\w*|memnuniyet\\w*|anket\\w*|(kullanıcı|müşteri)[ -]?(feedback|geri bildirim)\\w*|(customer|user)[ -]?geri bildirim\\w*|şikayet\\w*|rakip\\w*|rekabet\\w*|pazar pay\\w*|terk oran\\w*|elde tutma\\w*|abonelik\\w*|gelir model\\w*|özellik\\w*|sayfa(?! numara)\\w*|ekran(?! kart)(?!a\\b[^.!?\\n]{0,40}\\b(?:yaz|bas)\\w*)\\w*|arayüz\\w*|arama kutu\\w*|filtre\\w*|tablo(?![^.!?\\n]{0,60}\\b(?:sütun|kolon|sql|index|indeks)\\w*)\\w*|adım(?! sayı)\\w*|kullanıcı liste\\w*|form(u|un|da|daki|lar|ları|unu)\\w*[^.!?\\n]{0,40}\\b(?:incele|denetle|analiz|de[ğg]erlendir|iyile[şs]tir|sadele[şs]tir|kontrol)\\w*"
   ],
   "design": [
-   "(?:(?<![\\w'’] )|(?<=\\bbu )|(?<=\\bşu ))tasar[ıi]m\\w*|(?:dashboard|pano|g[öo]sterge panel|ekran|sayfa|aray[üu]z|landing|logo|ikon)\\w* (?:\\w+ ){0,2}(?:tasarla|tasar[ıi]m|redesign)\\w*|(?:web[ -]?)?site\\w* tasar[ıi]m\\w*|(?:mobil |web )?uygulama\\w* tasar[ıi]m\\w*|(?:web|mobil) tasar[ıi]m\\w*|tasar[ıi]m (?:sistem|token|dil|rehber)\\w*|yeniden tasarla\\w*|ba[şs]tan tasarla\\w*|design [çc]al[ıi][şs]ma\\w*|aray[üu]z\\w*|(?:ui|aray[üu]z|form|buton|d[üu][ğg]me|kart|men[üu]|sayfa|ekran|react|vue)\\w* (?:\\w+ )?bile[şs]en\\w*|bile[şs]en (?:k[üu]t[üu]phane|sistem)\\w*|tipografi\\w*|renk\\w*|tema(?:s[ıi]|y[ıi]|lar\\w*)?|kullan[ıi]labilirlik\\w*|eri[şs]ilebilirli[kğg]\\w*|g[öo]rsel (?:hiyerar[şs]i|tutarl[ıi]l[ıi]k|denetim|ele[şs]tiri)\\w*",
+   "(?:(?<![\\w'’] )|(?<=\\bbu )|(?<=\\bşu ))tasar[ıi]m\\w*|(?:dashboard|pano|g[öo]sterge panel|ekran|sayfa|aray[üu]z|landing|logo|ikon)\\w* (?:\\w+ ){0,2}(?:tasarla|tasar[ıi]m|redesign)\\w*|(?:uygulama(?:y[ıi]|s[ıi]n[ıi])?|site(?:yi|sini)?) redesign\\w*|(?:web[ -]?)?site\\w* tasar[ıi]m\\w*|(?:mobil |web )?uygulama\\w* tasar[ıi]m\\w*|(?:web|mobil) tasar[ıi]m\\w*|tasar[ıi]m (?:sistem|token|dil|rehber)\\w*|yeniden tasarla\\w*|ba[şs]tan tasarla\\w*|design [çc]al[ıi][şs]ma\\w*|aray[üu]z\\w*|(?:ui|aray[üu]z|form|buton|d[üu][ğg]me|kart|men[üu]|sayfa|ekran|react|vue)\\w* (?:\\w+ )?bile[şs]en\\w*|bile[şs]en (?:k[üu]t[üu]phane|sistem)\\w*|tipografi\\w*|renk\\w*|tema(?:s[ıi]|y[ıi]|lar\\w*)?|kullan[ıi]labilirlik\\w*|eri[şs]ilebilirli[kğg]\\w*|g[öo]rsel (?:hiyerar[şs]i|tutarl[ıi]l[ıi]k|denetim|ele[şs]tiri)\\w*",
    {
     "ui_ask": "iyile[şs]tir\\w*|g[üu]zelle[şs]tir\\w*|d[üu]zenle\\w*|kar[ıi][şs][ıi]k\\w*|tutars[ıi]z\\w*|da[ğg][ıi]n[ıi]k\\w*|[çc]irkin\\w*"
    },

package/hooks/projects-posttooluse.py

@@ -69,11 +69,19 @@ def result_size(result):
     so a container is measured by its top-level length (O(1) for str, bytes,
     list, dict, set) instead of re-serializing it: `json.dumps` on every
     PostToolUse copied the whole tool response and broke the hook's cost bound
-    ("a sha1 over a short string and a few fields; nothing else"). ponytail: a
-    dict result therefore reports its field count, not its byte length - the
-    host reports no size of its own, and no reader compares the two."""
+    ("a sha1 over a short string and a few fields; nothing else"). A shell
+    result is the exception: Claude's Bash answers `{"stdout", "stderr",
+    "interrupted", ...}`, so its field count is never 0 and a check that
+    printed nothing would read as output (`passing_check`'s silent failure,
+    B-005); its stream strings (`ran_nothing`'s keys) are measured instead.
+    ponytail: any other dict reports its field count, not its byte length."""
     if result is None:
         return None
+    if isinstance(result, dict):
+        streams = [result[k] for k in ("stdout", "stderr", "output")
+                   if isinstance(result.get(k), str)]
+        if streams:
+            return sum(map(len, streams))
     if isinstance(result, (str, bytes, bytearray, list, tuple, dict, set,
                            frozenset)):
         return len(result)

package/hooks/projects-stop.py

@@ -48,7 +48,7 @@ def main():
     if not isinstance(p, dict):
         return
     session_id = p.get("session_id")
-    safe(session_id, bind_session, session_id)  # the switch latch (tezgah_paths.off)
+    safe(session_id, bind_session, session_id, p.get("parent"))  # the switch latch
     cwd = p.get("cwd") or os.getcwd()
     if p.get("hook_event_name") == "SubagentStop" and p.get("agent_id") \
             and root_for(cwd) and not off("slices-off"):

package/hooks/tezgah_context.py

@@ -335,9 +335,10 @@ def skill_read_kind(tool, inp):
 
     Only the hosts that can see a read without paying a process per read call
     this (Claude parses its transcript, opencode classifies in-process, omp's
-    embedded runner filters before it asks python). On codex, cursor and dsh a
-    read is not observable at that price, so those marks stay at their armed
-    state and the legend says so.
+    embedded runner filters before it asks python). On codex, commandcode,
+    gemini, cursor, qwen, droid, copilot, antigravity and dsh a read is not
+    observable at that price, so those marks stay at their armed state and the
+    legend says so.
 
     A read of one of the two marked skills earns its mark (`SKILL_MARKS`); a read
     of any OTHER shipped skill earns `skill:<name>`. That second kind lights
@@ -2095,7 +2096,8 @@ def context_for(event, cwd, payload=None, with_core=True):
     # The switch latch: every off() below answers for this session, and a
     # prompt's turn marker (with its `authorized` row) is written first, so a
     # switch the user's prompt names is honored from this very turn.
-    bind_session(session_of(payload))
+    bind_session(session_of(payload),
+                 payload.get("parent") if isinstance(payload, dict) else None)
     if event == "user_prompt":
         # One marker per user turn, written before the reminder check: the loop
         # guard counts an identical call's failures in the current turn only, so
@@ -2103,13 +2105,16 @@ def context_for(event, cwd, payload=None, with_core=True):
         # guard state rather than part of the reminder. Only a hash of the prompt
         # is stored - note_turn keys the row on it so one submission cannot write
         # two markers and hide the failures the guard had just counted.
-        note_turn(session_of(payload), prompt_text(payload), workspace=root_for(cwd))
+        note_turn(session_of(payload), prompt_text(payload), workspace=root_for(cwd),
+                  subagent=isinstance(payload, dict) and bool(payload.get("subagent")))
     core, disabled = core_for(cwd)
     # A disabled rule is also removed from the on-demand skill's reach, because
     # the skill is loaded separately and would otherwise re-enable it.
+    # Claude's `tezgah` output style is a static copy of the core that no switch
+    # re-renders, so the note names it beside the skill (OQ-12).
     off_note = ("Kill switches active this session: %s. Those rules are OFF; "
-                "ignore the matching section in the `tezgah-contract` skill."
-                % ", ".join(disabled)) if disabled else ""
+                "ignore the matching section in the `tezgah-contract` skill and "
+                "the `tezgah` output style." % ", ".join(disabled)) if disabled else ""
     if event == "user_prompt":
         prompt = prompt_text(payload)
         session_id = session_of(payload)
@@ -2118,24 +2123,24 @@ def context_for(event, cwd, payload=None, with_core=True):
             host = (payload or {}).get("host") if isinstance(payload, dict) else None
             tezgah_taste.note_prompt(session_id, prompt, cwd,
                                      host=host if isinstance(host, str) else None)
-        # Before the reminder switch: the status mark follows the gate's state
-        # even when the per-turn text is off. Never in DROP_ORDER, so no budget
-        # gives it up - it says the rules below are not being enforced.
+        # The gate notice: never in DROP_ORDER, so no budget gives it up, and
+        # `reminder-off` keeps it - it says the rules below are not being
+        # enforced. Reading it also writes the status mark.
         gate = gate_inactive(session_id, payload)
-        # The user's grants and lifts (`user_grants`), before the reminder
-        # switch too: the Stop rule reads them whether or not this turn's text
-        # is shown. A subagent's prompt is its parent's brief, never the
-        # user's grant (omp's bridge sends `subagent`).
+        # The user's grants and lifts (`user_grants`): the Stop rule reads them
+        # whatever this turn's text shows. A subagent's prompt is its parent's
+        # brief, never the user's grant (omp's bridge sends `subagent`).
         for clause, target in ([] if isinstance(payload, dict) and payload.get("subagent")
                                else user_grants(prompt)):
             note(session_id, GRANT_KIND, clause, target=target)
         # per-turn nudge: openers decay over long sessions. Kept short because
         # it is paid every turn, and on Claude the output style already carries
         # the same rules on every response. The conditional rules ride along
-        # only on the turn whose prompt matches their task class.
-        if off("reminder-off"):
-            return None
-        parts = [("reminder", render(prompt_reminder(dropped_switches(cwd))))]
+        # only on the turn whose prompt matches their task class. `reminder-off`
+        # mutes this one line: every other part has its own switch or none
+        # (OQ-10), and the gate notice must never be given up.
+        parts = ([] if off("reminder-off") else
+                 [("reminder", render(prompt_reminder(dropped_switches(cwd))))])
         if gate:
             parts.append(("gate", gate))
         # The previous turn's stamp, read before the armed paragraphs: they are
@@ -2258,8 +2263,8 @@ def context_for(event, cwd, payload=None, with_core=True):
         if stale:
             parts.append(("index", stale))
         if disabled:
-            parts.append(("offnote", "(off this session: %s)"
-                          % ", ".join(disabled)))
+            parts.append(("offnote", "(off this session: %s; ignore their sections "
+                          "in the `tezgah` output style)" % ", ".join(disabled)))
         text = budgeted(event, parts)
         # latched only when the budget kept it, so a dropped line comes back
         if heavy and heavy in text:
@@ -2625,7 +2630,18 @@ def shell_kind(command):
     could light from `orx` alone and the layer's own commands stayed invisible to
     it. The absolute spelling needs no case of its own - this reader keeps
     basenames, so `<bin>/tezgah-research` and the bare name arrive as the same
-    word."""
+    word.
+
+    A python or node interpreter given a script file (`python3 bin/tezgah-docs
+    q`) runs that script, so the interpreter word is dropped before the line is
+    read; `-c`, `-m` and `-` (stdin) keep it, as their next word is code or a
+    module, not a file. The match stays on one line (spaces and tabs only), and a
+    shell interpreter needs none of this: the wrapper reader already looks past
+    `bash`/`sh`. `shell_programs` itself stays as it is: the gate reads it and
+    must keep the interpreter."""
+    command = re.sub(r"(?<![\w/.$=-])(?:[\w./-]*/)?(?:python[\d.]*|node)"
+                     r"(?:[ \t]+-(?![cm]\b)\w[\w-]*)*[ \t]+(?=[^\s-])", "",
+                     str(command or ""))
     ran = shell_programs(command)
     if "consult" in ran:
         return "consult"
@@ -2930,8 +2946,9 @@ colored, and the glyph carries the state on its own where color does not):
   name\u25cb  yellow  armed, on demand - not used yet this session
   name\u2717  red     turned off by a kill switch or a per-repo .no-* mark
   pony, adhd, dim   this surface cannot report that measure (a skill read
-                    needs a process per read to observe on codex, cursor and
-                    dsh, so those two marks state nothing there instead of
+                    needs a process per read to observe on codex, commandcode,
+                    gemini, cursor, qwen, droid, copilot, antigravity and dsh,
+                    so those two marks state nothing there instead of
                     claiming the skill was never opened)
   dim               no state to report: idx n/a or uncomparable, or no blocked
                     plan