@r1z4x/tezgah 1.6.0 → 1.7.0

package/bin/tezgah-taste

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
 """tezgah-taste - mine, measure, learn and apply the coding-taste signals.
 
-  tezgah-taste mine [--host omp|claude|all] [--root DIR] [--stats] [--out FILE]
+  tezgah-taste mine [--host omp|claude|all] [--root DIR | --all-projects] [--stats]
+                    [--out FILE]
   tezgah-taste measure --samples FILE --labels FILE [--model M] [--json]
   tezgah-taste rate --in MINED [--limit N] [--json]
   tezgah-taste learn [--repo DIR] [--from-transcripts] [--host omp|claude|all]
@@ -16,7 +17,12 @@
 `mine` reads the session transcripts on this machine - omp's top-level session
 files under `~/.omp/agent/sessions/*/` (a nested file is a subagent session) and
 Claude's top-level transcripts under `~/.claude/projects/*/` - whose cwd is under
-`--root` (default `~/Projects`, a `.runs` directory excluded). A writing turn is
+`--root` (default the current repository, a `.runs` directory excluded).
+`--all-projects` reads every session under `~/Projects` instead. Each repository
+a mined session ran in, but the current one (every one under `--all-projects`),
+gets a pseudonym (`project-<sha1[:8]>`). It stands for that repository's `repo`
+and `cwd`, and for its path and its name, in any case, in every prompt. A name
+the miner never saw as a session's repository stays as written. A writing turn is
 one in which the agent wrote a file without an error (omp `edit`/`write`, Claude
 `Edit`/`Write`/`MultiEdit`/`NotebookEdit`); the prompt the user sent directly
 after one, unless it is a harness injection, is a row. The definitions are the
@@ -64,6 +70,7 @@ import hashlib
 import json
 import os
 import random
+import re
 import subprocess
 import sys
 
@@ -236,7 +243,7 @@ def sessions(host, root, nested=False):
     pattern = ("**", "*.jsonl") if nested else ("*", "*.jsonl")
     for path in sorted(glob.glob(os.path.join(base(), *pattern), recursive=nested)):
         cwd = cwd_of(path)
-        if cwd.startswith(root + os.sep) and ".runs" not in cwd.split(os.sep):
+        if (cwd == root or cwd.startswith(root + os.sep)) and ".runs" not in cwd.split(os.sep):
             yield path, cwd
 
 
@@ -258,11 +265,29 @@ def repo_of(cwd, root):
     """The nearest directory holding `.git` below the root, else the first path
     component under it - without git, since a session's cwd may be gone."""
     here = cwd
-    while here.startswith(root + os.sep):
+    while here == root or here.startswith(root + os.sep):
         if os.path.exists(os.path.join(here, ".git")):
             return here
         here = os.path.dirname(here)
-    return os.path.join(root, os.path.relpath(cwd, root).split(os.sep)[0])
+    return os.path.normpath(os.path.join(root, os.path.relpath(cwd, root).split(os.sep)[0]))
+
+
+def pseudonym(repo):
+    """`project-<sha1[:8]>` for a repository path: the same name for every row of
+    one repository, and no trace of its own name."""
+    return "project-" + hashlib.sha1(repo.encode("utf-8", "replace")).hexdigest()[:8]
+
+
+def unname(text, repos):
+    """`text` with each repository of `repos` - its path, then its name as a
+    word, in any case - replaced by its pseudonym, the longest first so a name
+    inside another is not cut."""
+    for repo in sorted(repos, key=len, reverse=True):
+        text = re.sub(re.escape(repo), pseudonym(repo), text, flags=re.I)
+    for repo in sorted(repos, key=lambda r: len(os.path.basename(r)), reverse=True):
+        text = re.sub(r"(?<![\w.-])%s(?![\w-]|\.\w)" % re.escape(os.path.basename(repo)),
+                      pseudonym(repo), text, flags=re.I)
+    return text
 
 
 def mine_session(events):
@@ -280,24 +305,35 @@ def mine_session(events):
 
 
 def cmd_mine(args):
-    root = os.path.abspath(os.path.expanduser(args.root or "~/Projects"))
+    here = (tezgah_paths.linked_main(os.getcwd()) or repo_root(os.getcwd())
+            or os.getcwd())
+    root = os.path.abspath(os.path.expanduser(
+        args.root or ("~/Projects" if args.all_projects else here)))
     out = open(args.out, "w", encoding="utf-8") if args.out and not args.stats else sys.stdout
     try:
-        for host in (("omp", "claude") if args.host == "all" else (args.host,)):
+        hosts = ("omp", "claude") if args.host == "all" else (args.host,)
+        found = {host: list(sessions(host, root)) for host in hosts}
+        hidden = {r for r in (repo_of(cwd, root) for rows in found.values()
+                              for _path, cwd in rows) if args.all_projects or r != here}
+        for host in hosts:
             count = writes = prompts = 0
-            for path, cwd in sessions(host, root):
+            for path, cwd in found[host]:
                 count += 1
                 wrote, rows = mine_session(HOSTS[host][2](path))
                 writes += wrote
                 prompts += len(rows)
                 if args.stats:
                     continue
+                repo = repo_of(cwd, root)
+                repo_out = pseudonym(repo) if repo in hidden else repo
+                cwd_out = repo_out + cwd[len(repo):] if cwd.startswith(repo) else repo_out
                 for text, turn in rows:
                     out.write(json.dumps({
                         "host": host,
                         "session": os.path.splitext(os.path.basename(path))[0],
-                        "cwd": cwd, "repo": repo_of(cwd, root),
-                        "prompt": ti.redact(text)[:CUT], "writes_in_turn": turn},
+                        "cwd": cwd_out, "repo": repo_out,
+                        "prompt": unname(ti.redact(text), hidden)[:CUT],
+                        "writes_in_turn": turn},
                         ensure_ascii=False) + "\n")
             if args.stats:
                 print("%s: sessions=%d writes=%d prompts_after_write=%d"
@@ -883,6 +919,8 @@ def main(argv):
     mine = sub.add_parser("mine")
     mine.add_argument("--host", choices=("omp", "claude", "all"), default="all")
     mine.add_argument("--root")
+    mine.add_argument("--all-projects", action="store_true",
+                      help="every session under ~/Projects, each repo and cwd pseudonymised")
     mine.add_argument("--stats", action="store_true")
     mine.add_argument("--out")
     measure = sub.add_parser("measure")

package/docs/architecture.md

@@ -114,9 +114,11 @@ One session, in order. Each step names the file that handles the event on Claude
    and the stale-index notice, which also starts the incremental re-index
    (`hooks/tezgah_context.py::index_notice`).
 3. **PreToolUse** — `hooks/projects-pretooluse.py::main` calls `decision` and emits
-   the deny envelope, or, for a code-symbol search it lets through, the graph line
-   as `additionalContext` (`hooks/tezgah_gate.py::graph_advice`). The gate is the same
-   object on every host: `hosts/omp/hook.py::handle`, `hosts/codex/hook.py::gate_reason`.
+   the deny envelope, or one `additionalContext` line beside a call it lets through.
+   That line is the graph line for a symbol search (`hooks/tezgah_gate.py::graph_advice`)
+   or, for a spawn, the shared-worktree warning (`hooks/tezgah_gate.py::spawn_advice`).
+   The gate is the same object on every host: `hosts/omp/hook.py::handle`,
+   `hosts/codex/hook.py::gate_reason`.
 4. **PostToolUse** — `hooks/projects-posttooluse.py::main` writes the evidence row
    through `note_tool` (`hooks/projects-posttooluse.py::main`), records the used
    kind for the status line (`tezgah_context.record`, `hooks/projects-posttooluse.py::main`),
@@ -158,6 +160,7 @@ lowest-value blocks are dropped in a fixed order rather than the rules
 | Session store (used marks) | the `used` rows of the cache dir's `tezgah.db`, one per session and kind (`hooks/tezgah_store.py::use`) | `record` (`hooks/tezgah_context.py::record`) from every adapter | nothing evidential: a convenience channel for a surface that has no transcript; an `orch` mark is also written to the evidence ledger (`hooks/tezgah_context.py::record`) so `fanout` can count it |
 | Snapshot store | the blobs under `<cache dir>/snapshots` (`hooks/tezgah_snapshot.py::_store`), their manifests the `snapshots` rows of `tezgah.db` (`hooks/tezgah_store.py::add_snapshot`) | `capture` on the write path (`hooks/tezgah_snapshot.py::capture`) | the pre-write bytes; the rollback source |
 | Turn stamp | the `turns` rows of the cache dir's `tezgah.db`, one per session (`hooks/tezgah_context.py::write_stamp`) | `write_stamp` (`hooks/tezgah_context.py::write_stamp`) | the comparison behind the one-line delta, nothing else |
+| Slice journal | `<repo root>/.tezgah/slices/slices.db`, one row per delegated slice (`hooks/tezgah_task.py::slice_dir`) | `note_spawn` from the hosts' spawn calls (`hooks/tezgah_task.py::note_spawn`) and `tezgah-task slice` | which slices are open or stopped, how to resume them, and the `owns` lease (`hooks/tezgah_task.py::owned_globs`) - never evidence |
 | Installed config dir | `~/.config/tezgah` (`hooks/tezgah_paths.py::CONFIG_DIR`) | the installer and the user | which roots are armed, which kill switches are on |
 | Plugin copy | `~/.claude/plugins/cache/<marketplace>/tezgah/<version>/` (`bin/tezgah-setup::plugin_copies`) | `tezgah-setup --sync` (`bin/tezgah-setup::sync`) | what Claude Code actually executes — a copy, never this checkout |
 
@@ -205,7 +208,7 @@ fork and skips an entry whose checkout is gone, as git's own `prunable` does
   `context_for` returns `None` (`hooks/tezgah_context.py::context_for`), the gate only acts
   inside one (`hooks/tezgah_gate.py::decision`), and the status line is the single
   deliberate exception, because a globally loaded rules file must still show that
-  it is armed (`hosts/omp/hook.py:40-43`).
+  it is armed (`hosts/omp/hook.py:41-44`).
 - **No cross-host drift.** A host shares the core, never a copy of it. Adding a
   rule means editing the policy; adding behaviour means editing `hooks/` and
   letting every adapter inherit it.

package/docs/clarity-baseline.json

@@ -21,7 +21,7 @@
     "long_sentences": 42,
     "passive": 25,
     "replace_words": 0,
-    "semicolons": 30
+    "semicolons": 29
   },
   "docs/environment.md": {
     "long_sentences": 3,
@@ -84,7 +84,7 @@
     "semicolons": 42
   },
   "docs/research.md": {
-    "long_sentences": 107,
+    "long_sentences": 105,
     "passive": 59,
     "replace_words": 1,
     "semicolons": 77

package/docs/contract.md

@@ -144,6 +144,26 @@ looks for each clause's object phrase, the words a paraphrasing summary keeps
 precise rather than complete. `tests/constraint-fixtures.md` lists the real
 prompts the shapes ran on, the misses and the known false positives.
 
+A grant is the positive half of the same reader (plan 086, S3). "bana sormadan
+pushla", "without asking" and "onay veriyorum" let the session take an outward
+step without asking again. The shapes live in each language pack's
+`constraint.grant` list. `user_grants` (`hooks/tezgah_context.py::user_grants`)
+reads the whole sentence for the class it names: `push`, `release`, `publish`,
+`pr`, or `all` when it names none. Each prompt's grants land as `grant` rows in
+the session's ledger. They come before the reminder switch, so `reminder-off`
+keeps them. A `constraint.lift` shape ("artık bana sor", "ask me again",
+"Don't push.", "şimdilik push yapma") lifts them. So does a later constraint that
+names the class. A grant shape grants nothing in a sentence that ends in "?" or
+that its own pack's rules take back (`hooks/tezgah_context.py::_refuses`): a
+`constraint.grant_not` word such as "don't" or a complaint ("pushladın"), or a
+`grant_not_verb` prohibition ("yapma") right after the shape or at the
+sentence's end. A negated outward step lifts only the class it names. Quoted text and a subagent's prompt grant nothing.
+`grants_in_force` (`hooks/tezgah_integrity.py::grants_in_force`) folds the rows
+oldest first. The Stop rule's `needless ask` class and the ask-tool warning read
+that fold. A grant never covers a never-default step: a force push, a delete, a
+credential, or a spend over `spend_cap` in `~/.config/tezgah/config.json`. That
+cap is a number of USD, and 0 when unset (`hooks/tezgah_paths.py::spend_cap`).
+
 One per-turn line is not a rule but a check on the turn's own evidence. When the
 ledger says every check that passed in this session ran in a scratch or stand-in
 path - `/tmp/`, `/var/folders/`, `$TMPDIR`, or a path segment naming a
@@ -167,27 +187,27 @@ change with an executable oracle - a checker, a gate rule, a parser - spends the
 same budget. Its round one is four direction-led reviewers, and each claim
 becomes a fixture that runs before it counts. That population is a tentative
 default, measured on two research lines with a written flip
-(`skills/tezgah-contract/SKILL.md:519-550`).
+(`skills/tezgah-contract/SKILL.md:532-563`).
 
 ## Composition order of the always-on core
 
 Paragraphs are concatenated in the order they appear in `CORE` and identified by
 the bold label each starts with (`CORE_RULES`, `hooks/tezgah_context.py::CORE_RULES`).
 That order, with the line each label sits on in `hooks/tezgah_policy.py`:
-`**{REPLY_LANG}, BLUF.**` :649, `**Ponytail (minimal code).**` :657, `**Output shape:
-ADHD-friendly.**` :668, `**Deliver the whole ask; never the shortcut.**` :682,
-`**Integrity: evidence, or "doğrulanmadı".**` :696, `**Loop discipline.**` :713,
-`**Spec before building.**` :722 *(conditional)*, `**Lessons ledger: stop
-repeating mistakes.**` :736, `**Code discovery: graph first.**` :744
-*(conditional)*, `**Consult before irreversible.**` :753 *(conditional)*,
-`**Research: route it to OpenResearch.**` :769 *(conditional)*, `**Product
-analysis: five axes, one evidence class per finding.**` :785 *(conditional)*,
-`**No AI attribution, ever, on any host.**` :818, `**Identifiers and messages
-stay English.**` :828, `**Session scope: the user's repo, not tezgah.**` :834,
-``**Workspace: `.tezgah/` only.**`` :843, `**Parallel by default: fan out
-independent items.**` :850 *(conditional)*,
-`**Kill switches:**` :865. The first label renders as `**Turkish, BLUF.**` under
-the default `reply_lang`.
+`**{REPLY_LANG}, BLUF.**` :713, `**Ponytail (minimal code).**` :722, `**Output shape:
+ADHD-friendly.**` :739, `**Deliver the whole ask; never the shortcut.**` :763,
+`**Integrity: evidence, or a named blocker.**` :778, `**Loop discipline.**` :811,
+`**Spec before building.**` :820 *(conditional)*, `**Lessons ledger: stop
+repeating mistakes.**` :834, `**Code discovery: graph first.**` :842
+*(conditional)*, `**Consult before irreversible.**` :851 *(conditional)*,
+`**Research: route it to OpenResearch.**` :869 *(conditional)*, `**Product
+analysis: five axes, one evidence class per finding.**` :896 *(conditional)*,
+`**No AI attribution, ever, on any host.**` :931, `**Identifiers and messages
+stay English.**` :941, `**Session scope: the user's repo, not tezgah.**` :947,
+``**Workspace: `.tezgah/` only.**`` :958, `**Parallel by default: fan out
+independent items.**` :965 *(conditional)*,
+`**Kill switches:**` :990. The first label renders as `**Turkish, BLUF.**` under
+`language` `tr`.
 
 `always_on_core()` (`hooks/tezgah_context.py::always_on_core`) drops the six
 conditional paragraphs and appends `POINTERS` (`hooks/tezgah_policy.py::POINTERS`):
@@ -211,11 +231,11 @@ applied, and it also returns the names of the switches that fired.
 
 ## What each always-on rule is for
 
-- **Turkish, BLUF.** Every user-facing reply is Turkish even when the prompt is English, outcome first; code, commits, docs and subagent prompts stay English. That is the default. `reply_lang` in `~/.config/tezgah/config.json` picks another: `tr`, `en` or `any`. `tezgah-setup --install --reply-lang` sets it, and the label follows it. The value is the switch. The Stop rule checks the language only under `tr`: under `en` and `any` it judges none.
+- **{Language}, BLUF.** Every user-facing reply is in the configured language, outcome first. Code, commits, docs and subagent prompts stay English. `language` in `~/.config/tezgah/config.json` picks it: `tr`, `en` or `any` (see [Reply language and language packs](#reply-language-and-language-packs)). The value is the switch, and the label follows it.
 - **Ponytail (minimal code).** Take the laziest rung that holds (YAGNI → reuse → stdlib → platform → installed dependency → one line), never simplify away validation, error handling or security. A non-default level rides the reminder (`hooks/tezgah_context.py::_pony_level_line`).
 - **Output shape: ADHD-friendly.** The action or answer is the first line, multi-step work is a numbered list whose position is restated, an estimate is in concrete units. Two upstream rules were rewritten rather than imported verbatim because they collided with rules already in force: the state restatement points at the todo list instead of duplicating it, and a time estimate can no longer be read as a measurement.
 - **Deliver the whole ask; never the shortcut.** The request is a floor: no cheaper stand-in, no silent scope cut, no token gesture reported as done.
-- **Integrity: evidence, or "doğrulanmadı".** A done/tested claim holds only if the check ran in this session and its output was seen; the mechanical half is enforced by [gate.md](gate.md).
+- **Integrity: evidence, or a named blocker.** A done/tested claim holds only if the check ran in this session and its output was seen; "unverified" (tr: "doğrulanmadı") follows a check that ran and failed; leftover work is done, or stays as one of four blockers (DECISION, ACCESS, IRREVERSIBLE, ENV; tr: KARAR, YETKİ, GERİ ALINAMAZ, ORTAM) with its evidence. The mechanical half is enforced by [gate.md](gate.md), the residual half by the Stop rule's `residual work` class ([evidence.md](evidence.md)). Its **Ask policy** says what is asked at all. Work and process are never asked. An outward step runs on a grant. A never-default step waits for an answer. Every other question goes in one batch with a recommended default. The Stop rule's `needless ask` class refuses a reply that ends on a question the agent can decide, and the gate warns on an ask-tool question with no default ([gate.md](gate.md#ask-an-ask-tool-question-with-no-recommended-option)).
 - **Loop discipline.** Never repeat an identical failing command; three attempts is the ceiling, then report what is still unknown.
 - **Lessons ledger: stop repeating mistakes.** `.tezgah/lessons.md` lines are standing constraints; the recent ones are injected at session start, and up to three older ones a prompt shares words with ride that turn, each once per session when the host sends a session id (a compaction resets that, because the compacted context no longer holds them; without an id every matching turn carries them). Write a line rule first, `<rule> - <incident>` (`LESSON_SEPARATOR`, `hooks/tezgah_context.py::LESSON_SEPARATOR`). The session block counts the shown lines that do not open with their rule. A line ending `|| enforced_by: <rule|test>` leaves both blocks while that gate rule or test is on (`hooks/tezgah_lessons.py::lines`). That one reader serves the context, the gate and the CLI. It cuts that clause, a `|| check: ...` clause and an `@<sha> <path>` stamp off each line (`hooks/tezgah_lessons.py::parse`). None of them changes the key, the per-turn digest, the cut or the ranking. The gate records a line written after untrusted text in the same turn as a `lesson_tainted` row ([evidence.md](evidence.md)). That line still rides both blocks, behind a per-line data label (`hooks/tezgah_context.py::LESSON_TAINTED`). ADR 010 makes it a row, never a refusal. `bin/tezgah-lessons` proposes rewrites, merges and retirements, and never writes the file.
 - **No AI attribution, ever, on any host.** Nothing persisted or published may name a model, vendor or "AI" as author, co-author, generator or helper; one already in pushed history is reported.
@@ -223,6 +243,54 @@ applied, and it also returns the names of the switches that fired.
 - **Session scope: the user's repo, not tezgah.** The session never maintains tezgah itself; a missing capability is one line plus the documented fallback.
 - **Kill switches.** The switch list itself, so a session can tell the user how to disarm a rule it is asked to ignore; pinned against the shipped skill by `tests/test_skills.py::SkillStandards`.
 
+## Reply language and language packs
+
+The reply language is `language` in `~/.config/tezgah/config.json`
+(`hooks/tezgah_paths.py::language`). A config written before the key existed
+may say `reply_lang` instead. It is still read and never rewritten. A config
+with neither key reads as `tr`.
+
+- **Install default.** `tezgah-setup --install --language <code>` stores it.
+  `--reply-lang` is the older spelling of the same flag. A first install with no
+  flag takes the environment's language. That is the first of `LANGUAGE`,
+  `LC_ALL`, `LC_MESSAGES` and `LANG` that is set, cut to its language code. A
+  code with no pack, `C` or `POSIX` gives `en`
+  (`hooks/tezgah_paths.py::env_language`). An install over a config that has
+  neither key writes `tr`. So an upgrade changes no one's reply language
+  (`bin/tezgah-setup::install_common`).
+- **Language packs.** Each language is one data file, `hooks/lang/<code>.json`.
+  `en` and `tr` ship. A pack holds that language's half of every detection
+  class. That covers claims, admissions, openers, closers, residual labels,
+  blocker spellings, prompt hints, constraint shapes, ranking stopwords and
+  reply markers. `hooks/tezgah_paths.py::packs` reads them once. Every reader
+  compiles the union of all packs (`hooks/tezgah_paths.py::alts`). So a prompt
+  or a reply in any shipped language arms the same classes, whatever `language`
+  says. A pack's `word_order` picks the shape of its word-order hints. Turkish
+  is `object_first`, because its object comes before the verb
+  (`hooks/tezgah_context.py::_ui_ask`, `hooks/tezgah_context.py::_fanout`,
+  `hooks/tezgah_context.py::user_constraints`).
+  `tests/test_lang_packs.py` holds every pack to one key set and pins the probe
+  rows the packs must keep.
+- **Contract words.** A pack's `say` map holds the words the contract asks the
+  model to write. Those are the admission (`unverified`), the blocker heading
+  (`Blockers`), the four blocker tokens and the opener examples. `render` fills
+  the placeholders with the configured language's words
+  (`hooks/tezgah_context.py::render`). The Stop refusals use the same map
+  (`hooks/tezgah_integrity.py::_said`). Under `en` and `any` the contract names
+  the canonical English tokens. Under `tr` it names the Turkish ones. There the
+  residual, ready-step and stopped-slice refusals open with a Turkish line,
+  because Claude Code shows a refusal's first line to the user. The Stop rule
+  reads every pack's spelling either way.
+- **Reply check.** The Stop rule's `reply language` class judges only a
+  language whose pack ships reply `markers`, which today is `tr`
+  (`hooks/tezgah_integrity.py::reply_share`). `en` replies are not judged,
+  because an English reply often quotes the user's other language. `any` is
+  never judged.
+
+Adding a language is one file. Copy `hooks/lang/en.json` and write the
+language's words into each class and into `say`. Leave `markers` empty unless
+its replies should be held to it.
+
 ## Which mechanism enforces each always-on rule
 
 `tezgah-status --enforcers` prints one row per always-on rule. A row names the
@@ -260,7 +328,7 @@ sentence of the rule.
 
 | rule | decision |
 |---|---|
-| exec | Only the reply language is refused, and only under `reply_lang` `tr`. Answer-first (BLUF) has no mechanism. |
+| exec | Only the reply language is refused, and only for a language whose pack ships reply markers (`tr`). Answer-first (BLUF) has no mechanism. |
 | fidelity | Only the placating opener is refused, and only while the output-shape switches are on. Delivering the whole ask has no mechanism. |
 | loop | Only an identical repeat is refused, under `verify-off`. Re-running a check that already passed is not refused. |
 | ponytail | no decision |
@@ -306,6 +374,16 @@ telling the model to load `tezgah-contract` for the deep detail
 (`hooks/tezgah_context.py::context_for`), whose two appendixes apply only on a machine
 missing the code graph or every consult option (`hooks/tezgah_policy.py::NO_GRAPH`, `hooks/tezgah_policy.py::NO_CONSULT`).
 
+The router's own context gets one line too (`hooks/tezgah_context.py::context_nudge`).
+The prompt hook reads the newest main-thread step's input-side tokens from the
+host transcript (`hooks/tezgah_context.py::context_tokens`). Claude and Codex
+hand that path to every hook. omp's bridge hands over its session file. The
+threshold is `CONTEXT_NUDGE_TOKENS` (`hooks/tezgah_paths.py::CONTEXT_NUDGE_TOKENS`),
+700 k, just under the measured p90 of 724 k. Above it, the line asks the router
+to push heavy reads through a slice, or to run `/compact`. It fires once per session. A
+compaction clears the `nudged` mark, and `orchestrate-off` silences it. A host
+with no transcript pays nothing.
+
 ## How a rule is disarmed
 
 A kill switch removes the rule's text, not just a status mark
@@ -425,16 +503,22 @@ brief carries the same caller-list floor (`hooks/tezgah_agents.py`), and
 
 ## When the injected text grows too large
 
-Each event has a byte budget: `session_start` and `post_compact` 13000,
-`user_prompt` 6000, `subagent_start` 5500, anything else 13000
+Each event has a byte budget: `session_start` and `post_compact` 15500,
+`user_prompt` 6500, `subagent_start` 5500, anything else 13000
 (`hooks/tezgah_context.py::CONTEXT_BUDGET`). The rationale and the measured
 sizes sit beside it. In an empty fixture repo, `session_start` with the core
 builds 9842 B before the ponytail and ADHD rules went inline and 10884 B after
 (+1042 B). The fan-out pointer adds 112 B and the `tezgah-skill` sentence
-113 B, so the always-on band is 10499 B (`tests/test_setup.py`). The healthy
-fixture with a lesson and a plan then built 12059 B. At the old 12000 B budget
-it lost its lessons and sibling checkouts to pay for core rules, so the budget
-moved to 13000 B. The subagent brief and the reminder stay the same size.
+113 B. The healthy fixture with a lesson and a plan then built 12059 B. At the
+old 12000 B budget it lost its lessons and sibling checkouts to pay for core
+rules, so the budget moved to 13000 B. The residual rule (plan 080) added
+1473 B to the core and 151 B to the reminder, so the always-on band is
+11972 B (`tests/test_setup.py`). At 13000 B the healthy fixture gave up its
+lessons, plans and steer blocks. At 6000 B the busiest prompt turn gave up its
+active-task line. The session budgets moved to 14500 B, the prompt budget to 6500 B.
+The Ask policy (plan 086, S3) added 913 B to the core. At 14500 B the healthy
+fixture then gave up a lessons, plans or knowledge block. The session budgets moved to 15500 B.
+The subagent brief stays the same size.
 `SkillRulesInForceAtSessionStart` (`tests/test_context.py`) pins the rules
 themselves, not the size. A
 `user_prompt` that arms all five conditional rules