@r1z4x/tezgah 1.4.0 → 1.5.1

package/hooks/tezgah_agents.py

@@ -1,16 +1,24 @@
 #!/usr/bin/env python3
-"""Per-repo subagent definitions, generated from the detected infrastructure.
-
-When a session starts inside a tezgah root, the enclosing repo gets a small set
-of specialized agents, rendered into every host surface that actually exists:
-
-  Claude Code / Cursor  `.claude/agents/*.md`   (Cursor reads this dir natively)
-  opencode              `.opencode/agents/*.md` (fallback) + config injection
-  Codex                 `.codex/agents/*.toml`
-
-A role is only emitted when the capability it needs is present (the reviewer
-needs the code graph); the three tier workers are emitted in every root,
-because `tezgah-route` names one of them for every delegated task. The whole set is regenerated when either this manifest
+"""Subagent definitions, generated from the detected infrastructure.
+
+One role set, rendered into every host surface that actually exists, at the
+place each host loads it from:
+
+  Claude Code  `~/.claude/agents/*.md`          user-level, written at install
+  Codex        `$CODEX_HOME/agents/*.toml`      user-level, written at install
+  omp          `~/.omp/agent/agents/*.md`       user-level, written at install
+  Cursor       `.cursor/agents/*.md`            per repo, at session start
+  opencode     `.opencode/agents/*.md` (fallback) + config injection, per repo
+
+Claude and Codex miss a repo agents dir written during their first session
+(Claude does not watch a dir that was absent at start; Codex reads roles at
+config load and ignores `.codex/agents` in an untrusted repo), so their roles
+live user-level; a repo's `.claude/agents` and `.codex/agents` files an older
+tezgah wrote are swept. Cursor's CLI reads no user dir, so it keeps a per-repo
+dir. A role is only emitted when the capability it needs is present (the
+reviewer needs the code graph); the three tier workers are emitted in every root,
+because `tezgah-route` names one of them for every delegated task. The per-repo
+set is regenerated when either this manifest
 or the repo's infrastructure changes, so the definitions stay updatable instead
 of drifting. Hosts with no such surface (dsh) get nothing here; the orchestrator
 directive in the injected contract already covers them. The generated dirs are
@@ -30,16 +38,20 @@ import subprocess
 import tezgah_models as tm
 from tezgah_paths import (CONFIG_DIR, HOME, codegraph_bin, host_installed, off,
                           root_for)
+from tezgah_paths import HOST_DIRS as HOST_HOMES
 
 MARKER = "# tezgah: managed by tezgah-agents; do not edit"
 STATE = os.path.join(CONFIG_DIR, "agents.state.json")
-# hosts with a file-based custom-agent surface, and where it lives, relative to
-# the repo. Cursor reads .claude/agents/ natively, so one markdown dir serves
-# both when either is installed; the *detection* of whether a host is installed
-# lives in tezgah_paths.host_installed, not here.
+# hosts with a file-based custom-agent surface; the *detection* of whether a
+# host is installed lives in tezgah_paths.host_installed, not here.
 FILE_HOSTS = ("claude", "opencode", "codex", "cursor")
+# the file hosts whose roles live in their user dir (user_agents), written by
+# the installer; the others get a per-repo dir from sync_root
+USER_HOSTS = ("claude", "codex")
+# the repo-relative agent dirs. Claude's and Codex's are no longer written, only
+# swept: a copy an older tezgah left there would sit beside the user-level one.
 HOST_DIRS = {"claude": os.path.join(".claude", "agents"),
-             "cursor": os.path.join(".claude", "agents"),
+             "cursor": os.path.join(".cursor", "agents"),
              "opencode": os.path.join(".opencode", "agents"),
              "codex": os.path.join(".codex", "agents")}
 # Stack markers -> a short hint. Exact commands are left to the repo's own docs
@@ -61,10 +73,11 @@ MCP_PREFIXES = ("mcp__codegraph__", "mcp__plugin_tezgah_codegraph__")
 GRAPH_SELECT = ",".join(p + t for t in GRAPH_MCP for p in MCP_PREFIXES)
 GRAPH_CLI = ("callers", "callees", "impact", "node", "files")
 GRAPH_TOOLS = ", ".join("`codegraph %s`" % verb for verb in GRAPH_CLI)
-# A role with no shell (Claude `disallowedTools` Bash, opencode `bash: deny`)
+# A role with no shell (Claude `disallowedTools` Bash, opencode `bash: deny`;
+# Cursor's `readonly` documents no shell scope, so it is held to the same recipe)
 # cannot run `git diff` or the CLI, so its blast radius comes from the caller's
 # brief and the MCP impact tool; a role with a shell runs the diff itself.
-NO_SHELL = ("claude", "opencode")
+NO_SHELL = ("claude", "opencode", "cursor")
 # The floor every graph role carries (gortex edge provenance): the index holds
 # only the edges its parser saw, so an absence of callers is a coverage gap
 # until shown otherwise, never a safety verdict.
@@ -114,7 +127,7 @@ def _graph_howto(host):
                 "`codegraph status`). Do not call the `xd://mcp__codegraph_*`\n"
                 "devices: omp refuses them with \"Concurrent write refused\"\n"
                 "while the parent session holds the index." % GRAPH_TOOLS)
-    if host == "opencode":
+    if host in ("opencode", "cursor"):
         return ("codegraph is registered as an MCP server (%s). You have no\n"
                 "shell, so the codegraph CLI is out of reach: use those MCP tools."
                 % ", ".join("`%s`" % t for t in GRAPH_MCP))
@@ -206,15 +219,22 @@ def _reviewer_body(host):
         "is lowered only by evidence: a check you could not complete never\n"
         "downgrades a confirmed finding - keep its severity and mark it\n"
         "provisional. Disclose the order you read the files in.\n\n"
-        "Scope and budget. Every round that confirms a defect is followed by a\n"
-        "round over that fix's delta; the review ends when a round confirms none.\n"
-        "A later round reads only the delta since the sha the previous round\n"
-        "recorded (`tezgah-task review` prints it): re-reading the whole diff\n"
-        "re-reports what was already triaged. Test results are input, not a task\n"
-        "- read the author's output file; do not run the suite, and run at most one\n"
-        "`-k` test when a specific accusation needs it. The same defect family\n"
-        "confirmed three times is a sign the design needs a pivot, not another\n"
-        "patch.\n\n"
+        "Scope and budget. One review per plan, over its whole diff in the\n"
+        "verification phase; at most two rounds - only a confirmed critical or\n"
+        "major finding opens round two, a minor or suggestion one is recorded\n"
+        "fix-later, and after round two what is left goes to the user or is\n"
+        "recorded fix-later, never a third round. A round may be a fan-out of\n"
+        "reviewers spawned at once, one per dimension (correctness and contract,\n"
+        "security, tests and performance) or per file group: when your brief\n"
+        "names a dimension or files, review only those - a sibling owns the rest.\n"
+        "Round two reads only the delta since the sha round one recorded\n"
+        "(`tezgah-task review` prints it), plus the round-one hunks and direct\n"
+        "callers of the symbols that delta touches, and marks every round-one\n"
+        "finding closed or open: re-reading the whole diff re-reports what was\n"
+        "already triaged. Test results are input, not a task - read the author's\n"
+        "output file; do not run the suite, and run at most one `-k` test when a\n"
+        "specific accusation needs it. The same defect family confirmed in both\n"
+        "rounds is a sign the design needs a pivot, not another patch.\n\n"
         "%s" % (_graph_howto(host), _blast_radius(host), EMPTY_IS_NOT_PROOF,
                 _may_use(host)))
 
@@ -343,7 +363,8 @@ ROLES = (
     ("tezgah-reviewer",
      "Adversarial, read-only review of a diff, branch or PR: derives the blast "
      "radius, checks correctness, contract, security, tests and performance, and "
-     "classifies every finding confirmed/refuted/unverified.",
+     "classifies every finding confirmed/refuted/unverified. One review per plan, "
+     "at most two rounds; spawn one per dimension in one message for a large diff.",
      lambda infra: infra["caps"]["graph"], _reviewer_body, True),
     ("tezgah-cheap",
      "Mechanical, fully specified edits on the cheapest model tier: renames, "
@@ -389,7 +410,10 @@ def _orch_body(names):
         "verify; you delegate execution and read the evidence back. Available\n"
         "specialists: %s.\n\n"
         "Fan out by default: when the request or your todo list holds two or more\n"
-        "independent items, spawn one subagent per item in ONE message. Give\n"
+        "independent items, count them and spawn one subagent per item in ONE\n"
+        "message - at every phase: a plan's tasks, its acceptance commands and the\n"
+        "sources of a survey are items too, and checks that share no state run as\n"
+        "tool calls in one message, never a queue. Give\n"
         "every writing slice its own branch and checkout - `orca worktree create\n"
         "--name <slug> --parent-worktree active --json` when the session runs\n"
         "inside Orca, else `git worktree add -b <branch> <absolute path>` - and\n"
@@ -429,10 +453,8 @@ def _claude_model(model):
 
 def _model_lines(name, family, model_fmt, effort_fmt):
     """The model (and effort) lines the table gives this agent on a family;
-    `model: inherit` on Claude/Cursor for an agent with no slot. Cursor reads
-    this same file but wants its own ids and the effort inside the id
-    (`claude-opus-5[effort=high]`, cursor.com/docs/subagents) - unverified for
-    the ids this table names, so Cursor is documented, not guessed at."""
+    `model: inherit` on Claude for an agent with no slot. Cursor gets
+    `model: inherit` always (render_md_cursor)."""
     picked = tm.pick(name, family)
     if not picked:
         return ["model: inherit"] if family == "anthropic" else []
@@ -451,35 +473,34 @@ def _fold(desc, width=74):
 
 
 def render_md(name, description, readonly, body):
-    """Claude Code / Cursor markdown. Cursor ignores unknown keys and honours
-    `readonly`; Claude denies the write/shell tools explicitly."""
+    """Claude Code markdown (`~/.claude/agents`), which the Cursor editor also
+    reads (cursor.com/docs/subagents). The description is one line: Cursor's
+    line parser reads a folded `>` block as ">", and Claude's parser re-quotes
+    a plain value YAML rejects (a `: ` inside it). Claude denies the write/shell
+    tools explicitly; `readonly` is Cursor's key, which Claude ignores."""
     lines = ["---", MARKER + " (manifest %s)" % manifest_sha(),
-             "name: %s" % name, "description: >"]
-    lines += _fold(description)
+             "name: %s" % name, "description: %s" % " ".join(description.split())]
     lines += _model_lines(name, "anthropic", "model: %s", "effort: %s")
     if readonly:
-        # `disallowedTools` is Claude's; `readonly` is Cursor's. Both parsers
-        # ignore the other's field.
         lines.append("readonly: true")
         lines.append("disallowedTools: Write, Edit, NotebookEdit, Bash, Agent")
     lines.append("---")
     return "\n".join(lines) + "\n\n" + body.strip() + "\n"
 
 
-def plugin_agents():
-    """{filename: text} for the plugin's own tracked `agents/` dir.
-
-    The graph roles' Claude render, from the same body the per-repo files get,
-    so the shipped copy cannot drift from the generated one. The MARKER line is
-    dropped: the copy is tracked, never swept by `_remove_stale`, and its
-    manifest sha would turn every edit of this module into a stale file.
-    `tezgah-setup --write-plugin-agents` writes it; a test pins it."""
-    out = {}
-    for name, desc, _cap, body, readonly in ROLES:
-        if name in GRAPH_ROLES:
-            lines = render_md(name, desc, readonly, body("claude")).split("\n")
-            out[name + ".md"] = "\n".join(lines[:1] + lines[2:])
-    return out
+def render_md_cursor(name, description, readonly, body):
+    """Cursor `.cursor/agents/*.md`. cursor-agent splits each frontmatter line
+    at its first ':' (no YAML), passes `model` through as a raw id and has no
+    `effort` key, so: a one-line description, `model: inherit` (the only id
+    portable across Cursor accounts), `readonly`, and no `tools` line - its
+    comma split would cut a Claude `Agent(a, b)` list into broken names."""
+    lines = ["---", MARKER + " (manifest %s)" % manifest_sha(),
+             "name: %s" % name, "description: %s" % " ".join(description.split()),
+             "model: inherit"]
+    if readonly:
+        lines.append("readonly: true")
+    lines.append("---")
+    return "\n".join(lines) + "\n\n" + body.strip() + "\n"
 
 
 def render_md_opencode(name, description, readonly, body):
@@ -518,13 +539,19 @@ def render_md_omp(name, description, body, tools=("read", "grep", "glob", "bash"
     return "\n".join(lines) + "\n\n" + body.strip() + "\n"
 
 
+def _active_roles(root):
+    """The roles a user-level dir holds: none under `agents-off`, else those
+    whose capability the machine has (`~/.no-graph` counts as the repo's)."""
+    if off("agents-off"):
+        return []
+    infra = detect_infra(os.path.expanduser(root))
+    return [r for r in ROLES if r[2](infra)]
+
+
 def omp_user_agents(root="~"):
     """{filename: text} for omp's user agent dir (~/.omp/agent/agents); empty
     under `agents-off`, so the installer's sweep removes the files."""
-    if off("agents-off"):
-        return {}
-    infra = detect_infra(os.path.expanduser(root))
-    active = [r for r in ROLES if r[2](infra)]
+    active = _active_roles(root)
     names = [r[0] for r in active]
     if not names:
         return {}
@@ -539,20 +566,50 @@ def omp_user_agents(root="~"):
     return out
 
 
+def user_agent_dir(host):
+    """Where a USER_HOSTS host loads agents from in every session: Claude's
+    `~/.claude/agents`, Codex's `$CODEX_HOME/agents` (default ~/.codex)."""
+    return os.path.join(HOST_HOMES[host], "agents")
+
+
+def user_agents(host, root="~"):
+    """{filename: text} for a USER_HOSTS host's user agent dir, each file
+    carrying MARKER so the installer sweeps only tezgah's; empty under
+    `agents-off`, so that sweep removes them. Codex gets no orchestrator: the
+    main thread orchestrates there."""
+    active = _active_roles(root)
+    names = [r[0] for r in active]
+    if not names:
+        return {}
+    if host == "codex":
+        return {name + ".toml": render_toml(name, desc, readonly, body("codex"))
+                for name, desc, _cap, body, readonly in active}
+    out = {name + ".md": render_md(name, desc, readonly, body("claude"))
+           for name, desc, _cap, body, readonly in active}
+    out["tezgah-orchestrator.md"] = render_orch_md(names)
+    return out
+
+
 def steering(root, host=None):
     """One line naming the generated specialists this host can spawn, or None.
 
     Nothing else in the contract points the main agent at them, so a model
     reached for the host's generic explorer instead. Existence is read from
     disk, not from the capabilities: a specialist is named only when its file
-    is there for the host to load - omp's user agent dir on omp, the repo's
-    generated dirs everywhere else. A repo's `.no-graph` turns the graph off
-    there, so a graph role is not named in it even when omp's user-level file
+    is there for the host to load - the user agent dir on omp, Claude and
+    Codex, the repo's own dir on Cursor and opencode, and all of them for a
+    host that does not say which it is. A repo's `.no-graph` turns the graph
+    off there, so a graph role is not named in it even when a user-level file
     exists."""
     if host == "omp":
         dirs = [os.path.join(HOME, ".omp", "agent", "agents")]
+    elif host in USER_HOSTS:
+        dirs = [user_agent_dir(host)]
+    elif host in HOST_DIRS:
+        dirs = [os.path.join(root, HOST_DIRS[host])]
     else:
-        dirs = [os.path.join(root, d) for d in set(HOST_DIRS.values())]
+        dirs = ([user_agent_dir(h) for h in USER_HOSTS]
+                + [os.path.join(root, HOST_DIRS[h]) for h in ("cursor", "opencode")])
     have = {os.path.splitext(os.path.basename(p))[0]
             for d in dirs for p in glob.glob(os.path.join(d, "tezgah-*.*"))}
     if os.path.exists(os.path.join(root, ".no-graph")):
@@ -645,14 +702,18 @@ def _write_if_changed(path, text):
     return True
 
 
-def _remove_stale(directory, wanted):
-    """Delete only tezgah-managed files no longer in the wanted set."""
+def remove_stale(directory, wanted):
+    """Delete only tezgah-managed files no longer in the wanted set; returns
+    the paths removed."""
+    removed = []
     for path in glob.glob(os.path.join(directory, "tezgah-*.*")):
         if os.path.basename(path) not in wanted and _is_managed(_read(path)):
             try:
                 os.remove(path)
+                removed.append(path)
             except OSError:
                 pass
+    return removed
 
 
 BLOCK_BEGIN = ("# tezgah: generated agents (managed; removed by "
@@ -785,66 +846,49 @@ def sync_root(root, report_steady=False):
         return None
     disabled = off("agents-off")
     infra = detect_infra(root)
-    hosts = set() if disabled else set(infra["hosts"])
+    # Claude's and Codex's roles are user-level (user_agents): only Cursor and
+    # opencode get a dir here
+    hosts = set() if disabled else set(infra["hosts"]) - set(USER_HOSTS)
     active = [] if disabled else [r for r in ROLES if r[2](infra)]
     names = [r[0] for r in active]
 
-    # markdown: one dir serves Claude and Cursor (Cursor reads .claude/agents/)
-    md_dir = os.path.join(root, HOST_DIRS["claude"]) if hosts & {"claude", "cursor"} else None
+    cursor_dir = os.path.join(root, HOST_DIRS["cursor"]) if "cursor" in hosts else None
     oc_dir = os.path.join(root, HOST_DIRS["opencode"]) if "opencode" in hosts else None
-    codex_dir = os.path.join(root, HOST_DIRS["codex"]) if "codex" in hosts else None
 
     written, removed = 0, 0
     paths = []
+    wanted = {h: set() for h in HOST_DIRS}
 
-    def emit(directory, wanted, name, text):
+    def emit(host, name, text):
         nonlocal written
-        wanted.add(name)
-        path = os.path.join(directory, name)
+        wanted[host].add(name)
+        path = os.path.join(root, HOST_DIRS[host], name)
         if _write_if_changed(path, text):
             written += 1
         paths.append(path)
 
-    wanted_md, wanted_oc, wanted_codex = set(), set(), set()
-
-    def sweep(directory, wanted):
-        nonlocal removed
-        before = set(os.path.basename(p) for p in glob.glob(os.path.join(directory, "tezgah-*.*")))
-        _remove_stale(directory, wanted)
-        after = set(os.path.basename(p) for p in glob.glob(os.path.join(directory, "tezgah-*.*")))
-        removed += len(before - after)
-
-    if md_dir and names:  # Claude Code + Cursor
+    # Cursor gets no orchestrator: its files are subagents the main thread
+    # delegates to, and the orchestrator is a primary agent
+    if cursor_dir and names:
         for name, desc, _cap, body, readonly in active:
-            emit(md_dir, wanted_md, name + ".md", render_md(name, desc, readonly, body("claude")))
-        emit(md_dir, wanted_md, "tezgah-orchestrator.md", render_orch_md(names))
+            emit("cursor", name + ".md",
+                 render_md_cursor(name, desc, readonly, body("cursor")))
 
     if oc_dir and names:  # opencode
         for name, desc, _cap, body, readonly in active:
-            emit(oc_dir, wanted_oc, name + ".md",
+            emit("opencode", name + ".md",
                  render_md_opencode(name, desc, readonly, body("opencode")))
-        emit(oc_dir, wanted_oc, "tezgah-orchestrator.md", render_orch_md_opencode(names))
-
-    if codex_dir and names:  # Codex (no orchestrator agent; the main thread orchestrates)
-        for name, desc, _cap, body, readonly in active:
-            emit(codex_dir, wanted_codex, name + ".toml",
-                 render_toml(name, desc, readonly, body("codex")))
+        emit("opencode", "tezgah-orchestrator.md", render_orch_md_opencode(names))
 
-    # The sweep runs over every dir this module can write, not only the selected
-    # ones: a host dropped from the config, or a capability that disappeared,
-    # must not leave tezgah agents behind for the host to keep loading.
-    sweep(os.path.join(root, HOST_DIRS["claude"]), wanted_md)
-    sweep(os.path.join(root, HOST_DIRS["opencode"]), wanted_oc)
-    sweep(os.path.join(root, HOST_DIRS["codex"]), wanted_codex)
+    # The sweep runs over every dir this module ever wrote, not only the
+    # selected ones: a host dropped from the config, a capability that
+    # disappeared, or a `.claude`/`.codex` copy from before the roles moved
+    # user-level must not stay behind for a host to keep loading.
+    for host, directory in HOST_DIRS.items():
+        removed += len(remove_stale(os.path.join(root, directory), wanted[host]))
 
     if paths:
-        dirs = set()
-        if md_dir:
-            dirs.add(HOST_DIRS["claude"])
-        if oc_dir:
-            dirs.add(HOST_DIRS["opencode"])
-        if codex_dir:
-            dirs.add(HOST_DIRS["codex"])
+        dirs = {HOST_DIRS[h] for h in ("cursor", "opencode") if wanted[h]}
         ex = ensure_exclude(root, dirs)
         if ex:
             paths.append(ex)
@@ -857,7 +901,7 @@ def sync_root(root, report_steady=False):
                 % (len(names), ", %d removed" % removed if removed else ""))
     if removed:
         return "%d stale agent file(s) removed" % removed
-    if report_steady and names and (md_dir or oc_dir or codex_dir):
+    if report_steady and names and (cursor_dir or oc_dir):
         return "%d agent(s) current" % len(names)
     return None
 

package/hooks/tezgah_context.py

@@ -26,8 +26,9 @@ from tezgah_integrity import (STEP_KINDS, _heredocs, _path as _ledger_path,
                               UNTRUSTED_CHANNEL)
 from tezgah_lessons import (lesson_key, lines as lesson_lines,
                             tainted as tainted_lessons)
-from tezgah_policy import (CONDITIONAL_KEYS, CORE, POINTERS, PROMPT_REMINDER,
-                           REPLY_LANG_TEXT, open_lines_note, pony_level_line)
+from tezgah_policy import (CONDITIONAL_KEYS, CORE, FANOUT_ACTION, POINTERS,
+                           PROMPT_REMINDER, REPLY_LANG_TEXT, open_lines_note,
+                           pony_level_line)
 from tezgah_paths import (CACHE, REPO_MARKS, SWITCHES, ai_research_dir, armed,
                           cache_dir, codegraph_bin, consult_options,
                           ensure_workspace, fallback_cache, have_judge_key, off,
@@ -106,6 +107,21 @@ def _tr_ui_ask(word):
     return (r"(?:\b(?:%s)\w*[^.!?\n]{0,40}\b(?:%s))" % (TR_UI_OBJECTS, word))
 
 
+# The fan-out hint's parts (PROMPT_HINTS["fanout"]). A list item's marker:
+# `1.`, `1)`, `1 -`, `1:`, `a)`, or a `-`/`*`/`+`/`•` bullet, then its text.
+_FAN_ITEM = r"(?:\d+[ \t]*[.):\u2013-]|[a-z]\)|[-*+\u2022])[ \t]+\S"
+# A file a prompt names: a path with a directory, or a name with an extension.
+# Anchored at a token start: unanchored, a long run of word characters made
+# every position a start and the search quadratic (100 KB took minutes).
+_FAN_FILE = (r"(?<![\w./-])[`'\"]?(?:(?:[\w.-]+/)+[\w.-]*\w|"
+             r"\w[\w-]*\.[a-z]{1,4}\b)[`'\"]?")
+# The imperative that opens an English clause and closes a Turkish one.
+_FAN_VERB_EN = (r"(?:fix|add|update|write|remove|delete|rename|move|refactor|"
+                r"document|bump|create|implement|migrate|replace)")
+_FAN_VERB_TR = (r"(?:düzelt|güncelle|ekle|yaz|sil|kaldır|taşı|bitir|tamamla|"
+                r"incele|oluştur|değiştir)")
+
+
 PROMPT_HINTS = (
     ("spec", r"\b(normal (user )?behaviou?r|clean ui|nicer|more intuitive|"
              r"un?professional|polish(ed)?|improve the (ui|ux)|make it (better|"
@@ -340,9 +356,22 @@ PROMPT_HINTS = (
     # 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*|"
+    # The owner's own shapes armed nothing until 2026-10-09: `1 - `, `1- `,
+    # `1:`, `a)`, `+` items, an inline `1. ... 2. ...`, "subagentlerle", three
+    # files named as one list, "First, ... Second, ...", and three imperative
+    # clauses in one sentence (clause-initial in English, clause-final in
+    # Turkish). A timestamp, a range and a traceback stay out (the corpus).
+    ("fanout", r"(?ms:^[ \t]*" + _FAN_ITEM + r".*?^[ \t]*" + _FAN_ITEM + r")|"
+               r"(?<![\w.])1[ \t]*[.)-][ \t]+\S[^\n]*?(?<![\w.])2[ \t]*[.)-][ \t]+\S|"
+               + _FAN_FILE + r"(?:[ \t]*(?:,[ \t]*(?:(?:and|ve)[ \t]+)?|"
+               r"(?:and|ve|&)[ \t]+)" + _FAN_FILE + r"){2,}|"
+               r"(?s:\bfirst(?:ly)?[,:].*?\bsecond(?:ly)?[,:])|"
+               r"(?s:\bbirinci(?:si)?[,:].*?\bikinci(?:si)?[,:])|"
+               r"(?m:(?:(?:^|[,;]|\band\b)[ \t]*(?:and[ \t]+)?" + _FAN_VERB_EN
+               + r"\b[^\n]*?){3})|"
+               r"(?m:(?:\b" + _FAN_VERB_TR + r"\w{0,4}[ \t]*(?:[,;.]|\bve\b|$)"
+               r"[^\n]*?){3})|"
+               r"\b(?:in parallel|paralel\w*|sub-?agent\w*|alt ?ajan\w*|"
                r"worktrees?|fan[- ]?out|orchestrat\w*|orkestra\w*)\b"),
 )
 
@@ -661,7 +690,8 @@ def autoindex(root):
 
 
 def sync_agents(root):
-    """Generate/refresh this repo's per-host subagent definitions (best effort)."""
+    """Generate/refresh this repo's Cursor and opencode subagent files (best
+    effort); Claude's and Codex's roles are user-level, written at install."""
     try:
         from tezgah_agents import sync_root
         return sync_root(root)
@@ -1094,8 +1124,13 @@ ARMED_RESURFACE = 20
 def armed_again(key):
     """The one line a matching prompt pays for a paragraph this session was
     already shown. The research rule keeps its `{OPEN_LINES}` slot: the open
-    lines are a fact about the repo now, not rule text the session holds."""
+    lines are a fact about the repo now, not rule text the session holds. The
+    fan-out rule keeps its action (`FANOUT_ACTION`): the rule is a thing to do
+    on this turn's list, and a bare reminder that it exists was not done."""
     label = dict(CORE_RULES)[key]
+    if key == "fanout":
+        return ("%s Armed again: %s The full rule is in the `tezgah-contract` "
+                "skill." % (label, FANOUT_ACTION))
     return ("%s Armed again: the full rule was given earlier this session and "
             "is in the `tezgah-contract` skill.%s"
             % (label, "{OPEN_LINES}" if key == "research" else ""))