@r1z4x/tezgah 1.5.0 → 1.6.0

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))
@@ -209,8 +222,9 @@ def _reviewer_body(host):
         "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"
+        "fix-later, and after round two what is left is fixed by the session\n"
+        "and closed with `--resolved`, or recorded fix-later, never a third\n"
+        "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"
@@ -440,10 +454,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 []
@@ -462,35 +474,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):
@@ -529,13 +540,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 {}
@@ -550,20 +567,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")):
@@ -656,14 +703,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 "
@@ -796,66 +847,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)
@@ -868,7 +902,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_components.py

@@ -103,7 +103,8 @@ COMPONENTS = [
      "switch": "research-off", "editable": False, "revert": "git"},
     {"key": "product", "label": "product",
      "files": ["hooks/tezgah_policy.py", "skills/product-analysis/SKILL.md",
-               "skills/feature-audit/SKILL.md"],
+               "skills/feature-audit/SKILL.md", "skills/product-flow/SKILL.md",
+               "hooks/tezgah_product.py"],
      "switch": "research-off", "editable": True, "revert": "git"},
     {"key": "attribution", "label": "attribution",
      "files": ["hooks/tezgah_policy.py", "hooks/tezgah_gate.py"],

package/hooks/tezgah_context.py

@@ -690,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)
@@ -786,16 +787,16 @@ def task_line(task):
     and refuses a write the phase or the allowlist excludes, but a refusal
     costs a turn - so the phase rides every user turn, and the refusal is never
     the first the session hears of it. One line because it is paid every turn;
-    the allowlist is the globs as written, and the phase is stated as the user's
-    to move rather than as a command to run: the line used to print the CLI the
-    user types, and E7b watched the session run that command five times in a row
-    against a gate that refuses it every time. A line that names an act the gate
-    refuses is an invitation to a loop."""
+    the allowlist is the globs as written, and the phase is stated as the
+    orchestrator's own move: the session runs `tezgah-task` itself when the
+    work reaches the next phase and closes the plan when it is done, never
+    handing those steps to the user."""
     paths = ", ".join(task.get("allowed_paths") or []) or "any path in the repo"
-    return ("Active task %s is in phase `%s`; writes allowed on: %s. The phase "
-            "belongs to the user - ask them for the one this work needs, and "
-            "do not move it yourself." % (task.get("id"), task.get("phase"),
-                                          paths))
+    return ("Active task %s is in phase `%s`; writes allowed on: %s. Move the "
+            "phase yourself with `tezgah-task phase <next>` when the work reaches "
+            "it, and `tezgah-task close %s done` when it is merged - never hand "
+            "these steps to the user." % (task.get("id"), task.get("phase"),
+                                          paths, task.get("id")))
 
 
 # --- the resume block: the live turn state a compact loses -------------------
@@ -1185,10 +1186,61 @@ def constraint_notice(cwd, session_id):
     return " ".join(render(subagent_core(core_for(cwd)[0])).split())
 
 
+# A data ask said by its output: a dashboard, a chart, a KPI, a metric to choose.
+# "Bu veriye uygun bir metric dashboard tasarla" armed nothing before plan 072.
+# These words are code words as often as product words (`dashboard.json`, a
+# metrics endpoint, a progress `gösterge`, the clipboard `pano`), and two rounds
+# of noun denylists inside the product regex kept missing the next code sense.
+# So the ask is judged per clause: it arms `product` only when no code marker -
+# a file name, an identifier, SQL, a build, test or runtime word - shares its
+# clause (decision 006: qualify the stem, never drop it).
+DATA_ASK = re.compile(
+    r"\b(?:(?:design|create|make|build|sketch|propose|need|want)\w* (?:\w+ ){0,4}"
+    r"(?:dashboard|charts?|visuali[sz]ation)|"
+    r"(?:metri[ck]s?|kpis?|data|sales|revenue|veri\w*|satış\w*|gelir\w*) "
+    r"(?:\w+ ){0,2}(?:dashboard|pano)|"
+    r"(?:dashboard|gösterge panel)\w* (?:\w+ ){0,4}(?:tasarla|oluştur|hazırla|"
+    r"yap|göster)\w*|"
+    r"(?:what|which) (?:\w+ ){0,3}(?:metri[ck]s|kpis|charts?) (?:\w+ ){0,3}"
+    r"(?:should|to|do|matter|would)|"
+    r"what should (?:\w+ ){0,3}dashboard show|"
+    r"(?:choose|pick|define|track|design)(?:s|ing)? (?:\w+ ){0,3}(?:metri[ck]s|kpis)|"
+    r"(?:metri[ck]s|kpis) (?:should|to|do|would) (?:\w+ ){0,2}"
+    r"(?:track|measure|use|watch)|success metrics?|"
+    r"(?:suggest|recommend)\w* (?:\w+ ){0,3}charts?|öner\w* (?:\w+ ){0,3}grafi\w*|"
+    r"hangi (?:metri[ck]\w*|kpi\w*|grafi\w*|göstergeleri?)|"
+    r"(?:metri[ck]\w*|kpi\w*) (?:\w+ ){0,3}(?:tasarla|seç|tanımla|belirle|takip|izle)\w*|"
+    r"gösterge panel\w*|visuali[sz]\w* (?:\w+ ){0,3}(?:data|numbers|veri\w*)|"
+    r"data visuali[sz]ation|veri\w* (?:\w+ ){0,3}görselleştir\w*)")
+CODE_SENSE = re.compile(
+    r"\w\.(?:py|tsx?|jsx?|json|go|rs|ya?ml|sql|java|rb|css|html)\b|\b\w+_\w+\b|"
+    r"/metrics\b|\bselect\b.{0,200}?\bfrom\b|\b(?:tables?|columns?|schema|sql|queries|"
+    r"query|bundle|webpack|vite|tests?|ci|counters?|registry|pipeline|backend|"
+    r"handlers?|structs?|endpoints?|exporters?|export\w*|servers?|librar\w*|"
+    r"packages?|modules?|database|index\w*|indeks\w*|"
+    r"middleware|debugger|data (?:structure|flow)s?|clipboard|spinner|threads?|"
+    r"commit|git|functions?|class|component|prop|hooks?|prometheus|grafana|"
+    r"kibana|statsd|opentelemetry|config\w*|provision\w*|api|routes?|snake_case|"
+    r"veri yapı\w*|fonksiyon\w*|bileşen\w*|modül\w*|dosya\w*|kopyala\w*|"
+    r"seçici\w*|yükleme|ilerleme|paket\w*)\b")
+
+
+def _data_ask(low):
+    """Does one clause of the prompt ask for a data view or a metric choice with
+    no code marker beside it? A clause ends at `!`, `?`, `;`, a newline or a full
+    stop followed by a space, so `dashboard.json` stays one clause."""
+    return any(DATA_ASK.search(clause) and not CODE_SENSE.search(clause)
+               for clause in re.split(r"[!?;\n]|\.\s", low))
+
+
 def classify_prompt(text):
-    """The conditional rule keys a prompt arms, from the shared hint table."""
+    """The conditional rule keys a prompt arms, from the shared hint table, plus
+    `product` for a data ask (DATA_ASK, gated per clause by CODE_SENSE)."""
     low = (text or "").lower()
-    return {key for key, pattern in PROMPT_HINTS if re.search(pattern, low)}
+    keys = {key for key, pattern in PROMPT_HINTS if re.search(pattern, low)}
+    if "product" not in keys and _data_ask(low):
+        keys.add("product")
+    return keys
 
 
 def prompt_text(payload):
@@ -1434,8 +1486,8 @@ DEFAULT_BUDGET = 13000
 # exists to prevent, not one it may cause.
 DROP_ORDER = ("knowledge", "worktrees", "lessons", "skill", "lessons_turn",
               "taste", "plans", "subagents", "steer", "orca", "consult", "research",
-              "research_broken", "graph", "offnote", "orchestrate", "index",
-              "resume", "scratch", "task", "delta", "pointer")
+              "research_broken", "graph", "offnote", "orchestrate",
+              "index", "resume", "scratch", "task", "delta", "pointer")
 
 
 def _first_item(text):
@@ -1576,7 +1628,7 @@ GATE_INACTIVE = (
     "tezgah gate inactive on this host: %d gated tool call(s) since this "
     "session's first turn and not one row from the gate, so the shortcut "
     "denials and the Stop check are not running. Say so before claiming a check "
-    "passed, and ask the user to run `tezgah-setup --report`.")
+    "passed, run `tezgah-setup --report` yourself and quote its MISS rows.")
 
 
 def _iso_epoch(value):