@r1z4x/tezgah 1.0.0 → 1.1.0

package/hooks/tezgah_context.py

@@ -15,6 +15,7 @@ import sys
 import time
 
 import tezgah_embed
+import tezgah_orca
 import tezgah_research
 from tezgah_guard import import_crash_mark
 from tezgah_integrity import (STEP_KINDS, _heredocs, _path as _ledger_path,
@@ -333,6 +334,15 @@ PROMPT_HINTS = (
             r"nerede (kullanıl|çağrıl)\w*|tanım\w* nerede|kullanım yerleri|"
             r"çağrı (zinciri|grafiği)|bağımlılık (grafiği|ağacı)|"
             r"yeniden adlandır\w*)\b"),
+    # Two or more independent items: a numbered or bulleted list of at least
+    # two entries on their own lines, or the explicit delegation ask. The owner
+    # had to say "do everything with subagents and in parallel" on every task
+    # because nothing armed the fan-out rule from the shape of the request.
+    # `parallelize` alone is code work, so only the delegation phrasings count.
+    ("fanout", r"(?ms:^[ \t]*\d+[.)][ \t]+\S.*?^[ \t]*\d+[.)][ \t]+\S)|"
+               r"(?ms:^[ \t]*[-*•][ \t]+\S.*?^[ \t]*[-*•][ \t]+\S)|"
+               r"\b(?:in parallel|paralel\w*|sub-?agents?|alt ?ajan\w*|"
+               r"worktrees?|fan[- ]?out|orchestrat\w*|orkestra\w*)\b"),
 )
 
 # the detached auto-index worker (lock-guarded, retrying); same dir as this file
@@ -363,6 +373,7 @@ CORE_RULES = (
     ("attribution", "**No AI attribution, ever, on any host.**"),
     ("lang", "**Identifiers and messages stay English.**"),
     ("workspace", "**Workspace: `.tezgah/` only.**"),
+    ("fanout", "**Parallel by default: fan out independent items.**"),
 )
 
 # The per-turn reminder's clause for each switchable rule, matched against
@@ -1226,6 +1237,7 @@ def switches(cwd):
         drop.add("product")
         disabled.append("research-off")
     if off("orchestrate-off"):
+        drop.add("fanout")
         disabled.append("orchestrate-off")
     if off("lang-off"):
         drop.add("lang")
@@ -1368,12 +1380,17 @@ def session_of(payload):
 # 4000 B this rule's own 282 B dropped `consult`, held at 4400 B a 111 B core
 # growth dropped it again, and at 5000 B the brief's operative clauses (the
 # inter-agent language and the lessons instruction, plan 056) would have - bloat
-# paid for with a rule, which is the failure this bound exists to prevent. A
+# paid for with a rule, which is the failure this bound exists to prevent. The
+# same reasoning moved the two session budgets on 2026-10-07: the ponytail and
+# ADHD rules inline from the first turn (+1042 B), the fan-out pointer (+112 B)
+# and the `tezgah-skill` line (+113 B) took the healthy fixture's session_start
+# from 10579 B to 12059 B, so at 12000 B a healthy repo gave up its lessons
+# and sibling checkouts to pay for core rules; 13000 B restores the headroom. 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": 12000, "post_compact": 12000,
+CONTEXT_BUDGET = {"session_start": 13000, "post_compact": 13000,
                   "subagent_start": 5500, "user_prompt": 6000}
-DEFAULT_BUDGET = 12000
+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
 # plan-status skill, the sibling checkouts in `tezgah-research --all`, the
@@ -1395,7 +1412,7 @@ DEFAULT_BUDGET = 12000
 # spend them would turn bloat into rule loss - which is the failure the budget
 # exists to prevent, not one it may cause.
 DROP_ORDER = ("knowledge", "worktrees", "lessons", "skill", "lessons_turn",
-              "plans", "subagents", "steer", "consult", "research",
+              "plans", "subagents", "steer", "orca", "consult", "research",
               "research_broken", "graph", "offnote", "orchestrate", "index",
               "resume", "scratch", "task", "delta", "pointer")
 
@@ -1987,9 +2004,14 @@ def context_for(event, cwd, payload=None, with_core=True):
         # model as truncated one-liners, so which entry to look at first is the one
         # thing this turn cannot work out for itself. One call, one line, cached per
         # prompt - and nothing is appended when the judge is gone, the answer is
-        # `none`, or the arming file is absent (hooks/tezgah_skill_pick).
+        # `none`, or the arming file is absent (hooks/tezgah_skill_pick). When
+        # it gives no line, the model-free section search may: default on, one
+        # line at most, each section once per session (`section_hint`).
         if prompt and tezgah_skill_pick:
             hint = tezgah_skill_pick.suggest(prompt, session_id)
+            if not hint:
+                host = (payload or {}).get("host") if isinstance(payload, dict) else None
+                hint = tezgah_skill_pick.section_hint(prompt, session_id, host=host)
             if hint:
                 parts.append(("skill", hint))
         # C1 and C3 ride this turn because it is the only channel a live state
@@ -2074,8 +2096,18 @@ def context_for(event, cwd, payload=None, with_core=True):
         # indexers on the same repo, so only the parent session triggers one.
         status = (autoindex(root) if event != "subagent_start"
                   else "index handled by the parent session")
-        parts.append(("graph", "Graph index: %s (project %s)."
-                      % (status, slug(root))))
+        # The tool by the name this host calls it: a session whose prompt arms
+        # no graph rule otherwise never learns which tool the graph is, and
+        # omp's own prompt sends code discovery to `find`. A subagent gets the
+        # CLI (omp's MCP device refuses concurrent writes, see tezgah_agents).
+        from tezgah_gate import graph_tool  # lazy: keep hook import cost minimal
+        how = ("`codegraph explore|callers|impact <symbol>` in a shell"
+               if event == "subagent_start"
+               else graph_tool((payload or {}).get("host")))
+        parts.append(("graph", "Graph index: %s (project %s). Definitions, "
+                      "callers and blast radius: %s first; grep only for "
+                      "literal text, configs and docs."
+                      % (status, slug(root), how)))
     else:
         parts.append(("graph", "Graph: codegraph is not installed, so use "
                                "grep/find and say the answer came from text "
@@ -2131,6 +2163,11 @@ def context_for(event, cwd, payload=None, with_core=True):
         siblings = sibling_line(root) if root not in roots() else ""
         if siblings:
             parts.append(("worktrees", siblings))
+        # Inside Orca a checkout or a long job belongs to Orca, or its sidebar
+        # never shows it; env only, so this forks nothing.
+        orca = tezgah_orca.context_line()
+        if orca:
+            parts.append(("orca", orca))
         # The project's own rule files, agents and skills (tezgah-migrate's
         # index): they stay where the project keeps them, and one line makes a
         # session read the rows its task touches instead of never seeing them.
@@ -2538,30 +2575,36 @@ def index_notice(cwd):
     says less than "↻" but still says something the turn needs: no stamp, or no
     readable HEAD, means the graph's age is unknown rather than current, and
     staying silent there is what let an unverifiable index answer with the
-    index's authority."""
+    index's authority.
+
+    The line used to stop there ("re-index before trusting one, or say the
+    answer came from text search") and start nothing: the index is stamped only
+    by the session-start worker, so every turn after a commit told the model to
+    leave the graph for grep. A stale or unknown stamp now starts the same
+    lock-guarded incremental worker the session start runs (`autoindex`), and
+    the line says so."""
     base, _marks = repo_marks(cwd)
     mark = index_mark(cwd, base) if base else ""
-    if mark == "?":
-        return ("Graph index: this session cannot compare the graph to HEAD (no "
-                "readable index stamp), so the graph's age is unknown - it may "
-                "describe code that has moved since. Re-index before trusting a "
-                "graph answer, or say the answer came from text search.")
-    if mark != "\u21bb":
+    if mark not in ("?", "\u21bb"):
         return ""
+    status = autoindex(repo_root(cwd))
+    keep = ("Keep using the graph for code discovery; a file changed since the "
+            "last index may still show its older source there, so read that "
+            "file itself before editing it.")
+    if mark == "?":
+        return ("Graph index: the graph's age is unknown (no readable index "
+                "stamp); %s. %s" % (status, keep))
     from tezgah_gate import index_slug  # lazy: keep hook import cost minimal
     slug = index_slug(cwd, base)
     try:
         with open(os.path.join(cache_dir(), slug), encoding="utf-8") as fh:
             stamped = fh.read().strip()
     except OSError:
-        return ""
-    head = git(repo_root(cwd), "rev-parse", "HEAD")
-    if not head or not stamped:
-        return ""
-    return ("Graph index: the graph is indexed at %s, HEAD is %s - the index is "
-            "behind, so a graph answer may describe code that has moved since. "
-            "Re-index before trusting one, or say the answer came from text "
-            "search." % (stamped[:7], head[:7]))
+        stamped = ""
+    head = git(repo_root(cwd), "rev-parse", "HEAD") or ""
+    return ("Graph index: the graph is indexed at %s, HEAD is %s; %s "
+            "(`codegraph sync`, incremental). %s"
+            % (stamped[:7] or "?", head[:7] or "?", status, keep))
 
 
 def plan_mark(cwd, base):

package/hooks/tezgah_gate.py

@@ -4,9 +4,11 @@
 Rules, all only inside a tezgah root:
   1. a grep-only explorer subagent is refused, with the graph tools named as the
      replacement;
-  2. the FIRST identifier-shaped search of a session (Grep tool, or grep/rg run
-     through a shell) in a repo whose own codegraph index exists is nudged
-     toward the graph once, then every later search passes.
+  2. the FIRST code-symbol search of a session (grep/search/find tool, or
+     grep/rg run through a shell; a plain word is literal text and passes) in a
+     repo whose own codegraph index exists is nudged toward the graph once;
+     every later one passes, with graph_advice's line beside it while the index
+     is current.
   3. a git/gh command that writes an artifact carrying an AI/model credit
      (Co-Authored-By, "Generated with", a robot emoji, ...) is refused.
   4. an identical call that already failed LOOP_ATTEMPTS times in the current
@@ -170,7 +172,16 @@ try:  # The language rule's detector: the letter set and the word list, in their
 except ImportError:  # pragma: no cover - only where the module has not landed
     tezgah_lang = None
 
-IDENT = re.compile(r"^[A-Za-z_][A-Za-z0-9_]{2,}$")
+# A search for a code symbol, the shape the graph answers: an identifier with an
+# inner underscore or a lower-to-upper step (snake_case, camelCase), or any
+# identifier inside a definition or call pattern (`def run`, `run\(`). A plain
+# word (`TODO`, `error`) is literal text, so it is never nudged or advised.
+SEARCH_SYMBOL = re.compile(
+    r"(?:\\b)?(?:(def|class|function|func|fn|interface|struct|type)\s+)?"
+    r"([A-Za-z_][A-Za-z0-9_]{2,})(\\?\()?(?:\\b)?")
+# omp's discovery tools: `find` takes a described behavior plus likely terms,
+# `search` and `ast_grep` a pattern; `grep` is every host's regex tool.
+PATTERN_SEARCH_TOOLS = ("grep", "search", "ast_grep")
 # ponytail: flags with a separate value (grep -A 3 foo) shift the token and the
 # search passes unnudged; not worth a real argv parser for a once-a-session hint.
 BASH_SEARCH = re.compile(r"(?:^|[|;&(]\s*|\s)(?:grep|rg)\s+((?:-\S+\s+)*)(\S+)")
@@ -481,18 +492,35 @@ def explored(subagent_type):
     return str(subagent_type or "").lower() in ("explore", "explorer")
 
 
-def searched_identifier(tool, inp):
-    """The bare identifier this call searches for, or None. Host tool names
-    differ in case (Claude `Grep`/`Bash`, Codex/dsh `bash`), so match lowercased."""
+def symbol_in(text):
+    """The code symbol a search string names, or None for literal text."""
+    m = SEARCH_SYMBOL.fullmatch(str(text or "").strip().strip("'\""))
+    if not m:
+        return None
+    tok = m.group(2)
+    if (m.group(1) or m.group(3) or "_" in tok.strip("_")
+            or re.search(r"[a-z][A-Z]", tok)):
+        return tok
+    return None
+
+
+def searched_symbol(tool, inp):
+    """The code symbol this call searches for, or None. Host tool names differ
+    in case (Claude `Grep`/`Bash`, Codex/dsh/omp `bash`), so match lowercased.
+    omp's `find` is read too: its own prompt sends code discovery there first,
+    so a rule that read only grep never met an omp session."""
     t = str(tool or "").lower()
-    if t == "grep":
-        pat = str(inp.get("pattern", ""))
-        return pat if IDENT.match(pat) else None
+    if t in PATTERN_SEARCH_TOOLS:
+        return symbol_in(inp.get("pattern", ""))
+    if t == "find" and "query" in inp:
+        words = list(inp.get("grep_keywords") or [])
+        words += re.findall(r"[A-Za-z_][A-Za-z0-9_]{2,}\(?", str(inp["query"]))
+        return next(filter(None, map(symbol_in, words)), None)
     if t in ("bash", "shell"):
         for m in BASH_SEARCH.finditer(str(inp.get("command", ""))):
-            tok = m.group(2).strip("'\"")
-            if IDENT.match(tok):
-                return tok
+            symbol = symbol_in(m.group(2))
+            if symbol:
+                return symbol
     return None
 
 
@@ -509,15 +537,56 @@ def index_slug(cwd, base):
     one, so its own `.codegraph` is read) - and the name returned is still the
     key the index worker stamps HEAD under, so index_mark and index_notice keep
     reading the same file."""
+    d = index_dir(cwd, base)
+    return re.sub(r"[^A-Za-z0-9]+", "-", d).strip("-") if d else None
+
+
+def index_dir(cwd, base):
+    """The directory index_slug names: the closest repo up to `base` that holds
+    its own codegraph index, or None (none, or a `.no-graph` met first)."""
     d = os.path.realpath(cwd)
     base, rs = os.path.realpath(base), roots()
     while d.startswith(base) and (d != base or base not in rs):
+        if os.path.exists(os.path.join(d, ".no-graph")):
+            return None  # the repo's own switch: no graph rule here at all
         if os.path.isfile(os.path.join(d, ".codegraph", "codegraph.db")):
-            return re.sub(r"[^A-Za-z0-9]+", "-", d).strip("-")
+            return d
         d = os.path.dirname(d)
     return None
 
 
+def _read(path):
+    with open(path, encoding="utf-8") as fh:
+        return fh.read().strip()
+
+
+def git_head(repo):
+    """HEAD's commit read from `repo`'s git files, or None - no `git` fork,
+    because the gate pays it on a tool call. Covers a plain checkout, a linked
+    worktree (`.git` file plus `commondir`) and a packed ref."""
+    try:
+        gd = os.path.join(repo, ".git")
+        if os.path.isfile(gd):
+            gd = os.path.join(repo, _read(gd).split("gitdir:", 1)[1].strip())
+        head = _read(os.path.join(gd, "HEAD"))
+        if not head.startswith("ref: "):
+            return head or None
+        ref = head[5:]
+        common = gd
+        if os.path.isfile(os.path.join(gd, "commondir")):
+            common = os.path.join(gd, _read(os.path.join(gd, "commondir")))
+        for top in (gd, common):
+            if os.path.isfile(os.path.join(top, ref)):
+                return _read(os.path.join(top, ref))
+        with open(os.path.join(common, "packed-refs"), encoding="utf-8") as fh:
+            for line in fh:
+                if line.rstrip("\n").endswith(" " + ref):
+                    return line.split()[0]
+    except (OSError, IndexError):
+        pass
+    return None
+
+
 def nudge_mark(session_id):
     """The once-per-session mark: sha1(id)[:16], the key opencode's oncePerSession writes."""
     return os.path.join(cache_dir(), "nudged", hashlib.sha1(
@@ -540,12 +609,59 @@ def first_nudge(session_id):
         return False
 
 
+def graph_tool(host=None):
+    """The code-graph tool by the name this host's model calls it: omp mounts an
+    MCP server's tools as `xd://` devices, Claude and Codex as `mcp__<server>__`
+    (`mcp__plugin_tezgah_codegraph__` on a Claude plugin install), Cursor by
+    the bare tool name. Unknown host: the two prefixed spellings, so the line is
+    right wherever it lands."""
+    if host == "omp":
+        return "`xd://mcp__codegraph_explore`"
+    if host == "cursor":
+        return "the codegraph MCP server's `codegraph_explore`"
+    claude = ("`mcp__codegraph__codegraph_explore` (plugin install: "
+              "`mcp__plugin_tezgah_codegraph__codegraph_explore`)")
+    return claude if host else "%s, on omp `xd://mcp__codegraph_explore`" % claude
+
+
 def nudge_reason(symbol):
-    return ("Code graph index is ready for this repo. Run `codegraph explore %s` (source, callers, "
+    return ("Code graph index is ready for this repo. Call the MCP tool %s with "
+            "the query `%s`, or run `codegraph explore %s` (source, callers, "
             "blast radius in one call) or `codegraph callers %s` / `codegraph impact %s` from a shell; "
             "an omp subagent must use this CLI, not the MCP device, because omp's MCP device refuses "
             "concurrent writes. If you need literal text, re-run this search unchanged; it will pass - "
-            "this nudge fires once per session." % (symbol, symbol, symbol))
+            "this nudge fires once per session."
+            % (graph_tool(), symbol, symbol, symbol, symbol))
+
+
+def graph_advice(tool, inp, cwd, host=None):
+    """One non-blocking line for a symbol search the current graph answers, or
+    None. The refusal above is spent once per session; every later symbol
+    search gets this line beside its result instead, so the graph is named at
+    the moment the session reaches for grep. Fresh only: the stamp the index
+    worker writes must equal HEAD, because pointing at a graph that lags the
+    tree would send the session to a stale answer. A literal search, a repo
+    without its own index, `.no-graph` and `pretooluse-off` get nothing."""
+    symbol = searched_symbol(tool, inp)  # first: a regex, and most calls end here
+    if not symbol or off("pretooluse-off"):
+        return None
+    base = root_for(cwd)
+    repo = index_dir(cwd, base) if base else None
+    if not repo:
+        return None
+    try:
+        stamped = _read(os.path.join(cache_dir(), index_slug(cwd, base)))
+    except OSError:
+        return None
+    head = git_head(repo)
+    if not head or stamped != head:
+        return None
+    return ("Graph: `%s` is a code symbol and this repo's code graph is current "
+            "(HEAD %s). For its definition, callers or blast radius call %s "
+            "with the query `%s` (or `codegraph callers %s` / `codegraph impact "
+            "%s` in a shell): one call returns the source and the call path "
+            "that this text search cannot."
+            % (symbol, head[:7], graph_tool(host), symbol, symbol, symbol))
 
 
 # The identical attempts a call gets before the loop guard refuses it, whatever
@@ -2637,7 +2753,7 @@ def decision(tool, inp, cwd, session_id=None, record=True, agent=None):
         reason = retry_reason(tool, inp, session_id, agent)
         if reason:
             return _deny(session_id, "retry", reason, tool, inp, base)
-    if symbol := searched_identifier(tool, inp):
+    if symbol := searched_symbol(tool, inp):
         slug = index_slug(cwd, base)
         if slug and first_nudge(session_id):
             note(session_id, "nudge", slug, id=call_id(tool, inp),

package/hooks/tezgah_integrity.py

@@ -276,6 +276,9 @@ VERIFIED = re.compile(
     r"\b(tested|verified|i ran|ran the (?:tests?|suite|build|lint|checks?)|"
     r"doğruladım|test ettim|kontrol ettim|denetledim|doğrulandı|test edildi)\b",
     re.I)
+# The DONE forms that say a check passed ("all tests pass", "testler yeşil"):
+# such a claim rests on a pass even when the turn only edited prose.
+TESTED_WORD = re.compile(r"test|check|suite", re.I)
 # an explicit admission that removes the lie: an unverified claim is allowed
 NEGATED = re.compile(
     r"doğrulanmadı|doğrulamadım|unverified|not verified|could ?n[o']t verify|"
@@ -3587,6 +3590,43 @@ def _changed_write(row):
     return "hash" in row and "changed" not in row
 
 
+# Prose a person reads and no program runs: a write tool's edit to one owes no
+# check and does not stale a pass (`_prose_edit`). The owner's rule (2026-10-07)
+# is "a non-code change needs no suite", and the stale branch on a NOTES.md
+# written after green moved no outcome (PREREGISTRATION-E8 F3: 17/25 against
+# 18/25). `.txt` is not here: requirements.txt is code by another name.
+PROSE_EXT = (".md", ".markdown", ".rst", ".adoc")
+# Markdown an agent loads as instructions is the product, not prose: these names
+# and anything under these directories stay a change like any code file.
+INSTRUCTION_NAMES = frozenset(("skill.md", "agents.md", "claude.md", "gemini.md",
+                               "copilot-instructions.md", "rules.md"))
+INSTRUCTION_DIRS = frozenset(("skills", "prompts", "templates", "agents",
+                              "commands", "output-styles", "hooks", ".claude",
+                              ".cursor", ".codex", ".omp", ".github"))
+
+
+def _prose_edit(row):
+    """True for a write tool's `edit` row whose real target is prose
+    (`PROSE_EXT`) and not an agent instruction file (`INSTRUCTION_NAMES`,
+    `INSTRUCTION_DIRS`). The target is the realpath `note_tool` stored, so a
+    `.md` link over a code file is judged by the file it writes; a row with no
+    target is never prose. ponytail: a comment-only edit to a code file is
+    still a change - telling it apart needs the file's text before and after,
+    which the row does not carry."""
+    target = row.get("target")
+    if row.get("kind") != "edit" or not target:
+        return False
+    parts = str(target).replace("\\", "/").lower().split("/")
+    return (parts[-1].endswith(PROSE_EXT) and parts[-1] not in INSTRUCTION_NAMES
+            and not INSTRUCTION_DIRS.intersection(parts[:-1]))
+
+
+def _work_row(row):
+    """True when the row is one step of work a check is owed for: a `WORK_KINDS`
+    row that is not a prose edit (`_prose_edit`)."""
+    return str(row.get("kind")) in WORK_KINDS and not _prose_edit(row)
+
+
 def _change_row(row):
     """True when this row is one the freshness fold counts as a change to the
     tree: a write tool's `edit` row, a shell call that wrote a file (`run`), or
@@ -3602,9 +3642,9 @@ def _change_row(row):
     check in one call (`sed -i ... && pytest`, `ruff format . && pytest`) records
     as the check, so it is not read as a change; a write whose target is not a
     redirect carries no captured state either (tezgah_gate.write_paths names
-    both ceilings)."""
+    both ceilings). A prose edit (`_prose_edit`) is never one either."""
     kind = str(row.get("kind"))
-    return kind in ("edit", "run") and (
+    return kind in ("edit", "run") and not _prose_edit(row) and (
         _changed_write(row)
         or (kind == "run" and format_write(str(row.get("detail") or ""))))
 
@@ -3663,7 +3703,7 @@ def _stale_paths(rows):
     with no file named at all."""
     names = []
     for row in rows[_last_pass(rows) + 1:]:
-        if row.get("kind") == "edit" and _changed_write(row):
+        if row.get("kind") == "edit" and _change_row(row):
             name = str(row.get("detail") or "").strip()
             if len(name) > 80:
                 name = "..." + name[-77:]
@@ -4441,7 +4481,7 @@ def _bookkeeping_turn(rows):
     cut it there, and the command after the cut is unread (review F1). Nor is
     one that holds a redaction marker: the marker can swallow the rest of a
     word and what was glued to it (`echo token=x;./regen.sh`, review N3)."""
-    steps = [r for r in rows if str(r.get("kind")) in WORK_KINDS]
+    steps = [r for r in rows if _work_row(r)]
     return bool(steps) and all(
         r.get("kind") == "run" and not _change_row(r)
         and len(str(r.get("detail") or "")) < DETAIL_MAX
@@ -4456,7 +4496,7 @@ def _settled(rows):
     last = _last_pass(rows)
     if last < 0:
         return False
-    after = [r for r in rows[last + 1:] if str(r.get("kind")) in WORK_KINDS]
+    after = [r for r in rows[last + 1:] if _work_row(r)]
     return not after or _bookkeeping_turn(after)
 
 
@@ -4528,7 +4568,6 @@ def _stop_block(text, session_id, rows=None, cwd=None, shape=True, fold=None):
         return ("evidence tampered", TAMPERED)
     if (done or verified) and any(r.get(ORPHAN) for r in rows):
         return ("evidence tampered", ORPHANED)
-    ev = {str(entry.get("kind")) for entry in rows}
     # The trigger is the turn's own evidence, not its words. The claim vocabulary
     # below catches a claim-shaped reply; it missed the same unfounded state
     # stated as a description ("the parser is wired up now"), which is what E2
@@ -4541,7 +4580,12 @@ def _stop_block(text, session_id, rows=None, cwd=None, shape=True, fold=None):
     # owes the check it never got - which is the `no verify_ok` floor below and
     # not the partial-failure branch above it, because an interruption is no
     # failure at all (the row carries no `exit`).
-    worked = ev & WORK_KINDS
+    # A prose edit (`_prose_edit`) is no step a check is owed for - unless the
+    # reply says something was tested or checked, a claim that rests on a pass.
+    worked = {str(r.get("kind")) for r in rows if _work_row(r)}
+    if not worked and any(_prose_edit(r) for r in rows) and (
+            verified or any(TESTED_WORD.search(m.group(0)) for m in DONE.finditer(t))):
+        worked = {"edit"}
     if not worked:
         # With no work, the words are the whole trigger, so a question or a
         # negation is not read as the claim it names (`asserted_claims`).
@@ -4599,7 +4643,7 @@ def _stop_block(text, session_id, rows=None, cwd=None, shape=True, fold=None):
             # allowed on all five Stop hosts (audit INT-01 / M-2).
             prior = _before_turn(events(session_id))
             refused = fold(
-                prior, {str(r.get("kind")) for r in prior} & WORK_KINDS, None,
+                prior, {str(r.get("kind")) for r in prior if _work_row(r)}, None,
                 "this session")
             if refused[0]:
                 return refused
@@ -4624,7 +4668,7 @@ def _before_turn(rows):
         if row.get("kind") == TURN_KIND:
             pending = row
             continue
-        if pending is not None and str(row.get("kind")) in WORK_KINDS:
+        if pending is not None and _work_row(row):
             out.append(pending)
             pending = None
         out.append(row)
@@ -4732,8 +4776,9 @@ def _evidence_block(rows, worked, external, where="this turn"):
         return ("stale evidence",
                 "Stale evidence: the newest check that passed ran before %s %s "
                 "written, so it verified an earlier revision of the tree than the "
-                "one this reply is about. Re-run the check over what is on disk "
-                "now and report its output, or mark the claim \"doğrulanmadı\". "
+                "one this reply is about. Re-run the smallest check that covers "
+                "the files written since (their own tests, not the whole suite) "
+                "and report its output, or mark the claim \"doğrulanmadı\". "
                 "A green run over the previous revision does not cover this one."
                 % (shown or "a file this session wrote",
                    "was" if len(names) <= 1 else "were"))
@@ -4753,8 +4798,10 @@ def _evidence_block(rows, worked, external, where="this turn"):
                 "%s did work (edits or commands) and no check ran "
                 "successfully in it (nothing recorded as verify_ok with a "
                 "real result and an unmasked command), so nothing here supports "
-                "calling it done, complete or verified. Run the real check and "
-                "report its output, or mark the claim \"doğrulanmadı\". Do not "
+                "calling it done, complete or verified. Run the smallest check "
+                "that proves the change (the tests of what changed, not the "
+                "whole suite) and report its output, or mark the claim "
+                "\"doğrulanmadı\". Do not "
                 "describe a check you did not run as if it ran."
                 % where.capitalize())
     # Last, so none of the classes above loses its turn to it: every shape this