@r1z4x/tezgah 1.9.2 → 1.13.0

package/hosts/opencode/tui/cli/tui.tsx

@@ -0,0 +1,100 @@
+/** @jsxImportSource @opentui/solid */
+// tezgah status line for the opencode 2 terminal (a CLI plugin).
+//
+// opencode 2 ignores tui.json: a local CLI plugin is a DIRECTORY listed in
+// ~/.config/opencode/cli.json `plugins` (a spec naming a file is skipped), whose
+// `tui` module default-exports Plugin.define({ id, setup }). Same data and marks
+// as ../tezgah-tui.tsx (the opencode 1 shape, kept for v1 installs): one
+// `tezgah-status <dir> --json [sessionID]` call per refresh, each segment colored
+// green in force, yellow on-demand, red off, and a palette command for the legend.
+import { Plugin } from "@opencode/plugin/tui"
+import { createSignal, onCleanup, For } from "solid-js"
+import { run } from "../tezgah-tui.tsx"
+
+const SAFETY_MS = 30000
+// Server events arrive per streamed part; one status call per burst is enough.
+const DEBOUNCE_MS = 250
+
+type Seg = { key: string; state: string; glyph: string; text: string; group?: number }
+type Tone = { base: string }
+// The part of the CLI plugin context this file reads (opencode.ai/v2/docs/build/plugins/cli).
+type Ctx = {
+  location?: { directory?: string }
+  theme: { text: { muted: string; feedback: { success: Tone; warning: Tone; error: Tone } } }
+  data: { location: { default(): { directory?: string } | undefined }; listen(fn: () => void): () => void }
+  ui: { router: { current(): { type: string; sessionID?: string } | undefined } }
+}
+
+function color(ctx: Ctx, state: string) {
+  const t = ctx.theme.text
+  if (state === "on") return t.feedback.success.base
+  if (state === "ready") return t.feedback.warning.base
+  if (state === "off") return t.feedback.error.base
+  return t.muted
+}
+
+function args(ctx: Ctx): string[] {
+  const dir = ctx.location?.directory || ctx.data.location.default()?.directory || process.cwd()
+  // The active session id is what lets the used marks (graph/consult/orch) light.
+  const route = ctx.ui.router.current()
+  return route?.type === "session" && route.sessionID ? [dir, "--json", route.sessionID] : [dir, "--json"]
+}
+
+function TezgahBar(props: { ctx: Ctx }) {
+  const [segs, setSegs] = createSignal<Seg[]>([])
+  const update = () => {
+    try {
+      setSegs(JSON.parse(run(args(props.ctx)) || "[]"))
+    } catch {
+      setSegs([])
+    }
+  }
+  let pending: Timer | undefined
+  const soon = () => {
+    clearTimeout(pending)
+    pending = setTimeout(update, DEBOUNCE_MS)
+  }
+
+  update()
+  const stop = props.ctx.data.listen(soon)
+  const timer = setInterval(update, SAFETY_MS)
+  onCleanup(() => {
+    stop()
+    clearTimeout(pending)
+    clearInterval(timer)
+  })
+
+  return (
+    <box paddingLeft={1} flexShrink={0} flexDirection="row">
+      <For each={segs()}>
+        {(s, i) => (
+          <box flexDirection="row">
+            <text fg={color(props.ctx, s.state)}>{s.text + (s.glyph || "")}</text>
+            <text fg={props.ctx.theme.text.muted}>
+              {i() < segs().length - 1
+                ? (segs()[i() + 1].group === s.group ? " " : "  ·  ")
+                : ""}
+            </text>
+          </box>
+        )}
+      </For>
+    </box>
+  )
+}
+
+export default Plugin.define({
+  id: "tezgah.status",
+  setup(ctx) {
+    ctx.keymap.layer(() => ({
+      mode: "global",
+      commands: [{
+        id: "tezgah.legend",
+        title: "tezgah: status legend",
+        group: "tezgah",
+        palette: true,
+        run: () => ctx.ui.dialog.alert({ title: "tezgah status marks", message: run(["--legend"]) }),
+      }],
+    }))
+    return ctx.ui.slot({ append: "prompt.footer", render: () => <TezgahBar ctx={ctx} /> })
+  },
+})

package/hosts/opencode/tui/tezgah-tui.tsx

@@ -51,7 +51,8 @@ function pythonBin(): string {
   return (pythonMemo = found || names[0])
 }
 
-function run(args: string[]): string {
+// Exported for cli/tui.tsx, the opencode 2 shape of this plugin.
+export function run(args: string[]): string {
   try {
     const proc = Bun.spawnSync({ cmd: [pythonBin(), STATUS, ...args], stdout: "pipe", stderr: "ignore" })
     return new TextDecoder().decode(proc.stdout).trim()

package/hosts/qwen/hook.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Qwen Code lifecycle hook. Reads Qwen's JSON on stdin and answers in Qwen's own
+output shape, onto the shared tezgah core (hooks/).
+
+Qwen Code 0.21.13 fires SessionStart, UserPromptSubmit, PreToolUse, PostToolUse,
+PostToolUseFailure, SubagentStart, SubagentStop and Stop here
+(`bin/tezgah-setup::QWEN_HOOK_EVENTS`); anything else is ignored. Inert outside
+the roots.
+
+The always-on core is the managed block in `~/.qwen/QWEN.md`, which Qwen loads
+into every session, so SessionStart repeats it only when that block is missing.
+PreToolUse translates Qwen's runtime tool ids into the gate's vocabulary and
+denies with `hookSpecificOutput.permissionDecision` on exit 0 - never exit 2,
+whose stderr channel carries no reason the ledger and the probe can read. Qwen
+fires PostToolUse for a successful call and PostToolUseFailure for a failed one
+(a shell exit Qwen counts as an error, `isShellExitError`), so the event is the
+call's outcome. Stop blocks a done/tested claim with no successful check behind
+it, judged on `last_assistant_message`, the same rule Claude's Stop hook enforces
+(hooks/tezgah_integrity.py). The status line is `tezgah-statusline --qwen`, Qwen's
+`ui.statusLine` command, so no event here carries it.
+"""
+import json
+import os
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+sys.path.insert(0, os.path.join(ROOT, "hooks"))
+from tezgah_guard import attest_session, import_failed, safe  # noqa: E402
+try:
+    from tezgah_context import command_text, context_for, record, shell_kind  # noqa: E402
+    from tezgah_gate import cross_project_note, decision, graph_advice  # noqa: E402
+    from tezgah_integrity import (  # noqa: E402
+        SUBAGENT_CHANNEL, bind_session, note, note_tool, ran_nothing, report_bytes,
+        stop_reason, untrusted_source)
+    from tezgah_paths import HOST_DIRS, off, root_for  # noqa: E402
+    from tezgah_taste import write_note  # noqa: E402
+    from tezgah_untrusted import marks  # noqa: E402
+except Exception as exc:
+    import_failed(exc)
+
+# Qwen's runtime tool ids (the `ToolNames` table in the 0.21.13 bundle) -> the
+# shared gate's vocabulary. `replace` is the edit tool's id in older builds; the
+# 0.21.13 bundle has none, and an unknown id passes the gate untouched. MCP tools
+# arrive as `mcp__<server>__<tool>`, the shared shape, and pass through.
+# `monitor` runs a shell command too (Qwen's headless deny list pairs it with
+# SHELL), and `notebook_edit` writes an .ipynb (review of plan 138).
+GATE_TOOLS = {
+    "run_shell_command": "Bash",
+    "monitor": "Bash",
+    "write_file": "Write",
+    "edit": "Edit",
+    "replace": "Edit",
+    "notebook_edit": "NotebookEdit",
+    "agent": "Task",
+    "grep_search": "Grep",
+}
+
+
+def gate_name(name):
+    """The tool name the gate denies under and the ledger row records.
+
+    `call_id` hashes the name it is handed, so both halves map through here: a
+    PostToolUse row under the raw id would never match the PreToolUse call and
+    the loop guard would never deny (`hosts/codex/hook.py::gate_name`)."""
+    return GATE_TOOLS.get(name, name)
+
+
+def classify(payload):
+    """The used-tool kind for a tool payload, or None."""
+    name = payload.get("tool_name", "") or ""
+    if name.startswith("mcp__") and "codegraph" in name:
+        return "graph"
+    if name == "agent":
+        return "orch"
+    if name == "run_shell_command":
+        return shell_kind(command_text(payload.get("tool_input")))
+    return None
+
+
+def subagent_id(payload):
+    """The subagent id Qwen adds to a hook input run inside a subagent, else None."""
+    aid = payload.get("agent_id")
+    return aid if isinstance(aid, str) and aid else None
+
+
+def rules_carry_core():
+    """True when `QWEN.md` in Qwen's home holds tezgah-setup's managed block."""
+    try:
+        with open(os.path.join(HOST_DIRS["qwen"], "QWEN.md"), encoding="utf-8") as fh:
+            return "<!-- tezgah:start" in fh.read()
+    except OSError:
+        return False
+
+
+def result_size(result):
+    """The result's top-level length, the Claude-family writer's measure; a value
+    with no length counts as non-empty and only a missing result is None."""
+    if isinstance(result, (str, bytes, bytearray, list, tuple, dict, set, frozenset)):
+        return len(result)
+    return 1 if result is not None else None
+
+
+def inp_of(payload):
+    inp = payload.get("tool_input")
+    return inp if isinstance(inp, dict) else {}
+
+
+def post_tool(payload, cwd, session_id, failed):
+    """The ledger row for one finished call, and the notice for the model."""
+    tool = gate_name(payload.get("tool_name", ""))
+    inp = inp_of(payload)
+    # a `monitor` PostToolUse fires when the watch starts ("Monitor started"),
+    # long before its command ends: it records a run, never a pass (review of
+    # plan 138, round 2); a failed start still arrives as PostToolUseFailure
+    if payload.get("tool_name") == "monitor" and failed is False:
+        failed = None
+    safe(session_id, record, session_id, classify(payload))
+    if not root_for(cwd):
+        return None
+    result = payload.get("tool_response")
+    # read before this call's row lands: `source` is the taint's own mark
+    got = safe(session_id, marks, tool, inp, session_id, result)
+    source, notice = got or (None, None)
+    safe(session_id, note_tool, session_id, tool, inp, failed=failed,
+         interrupted=bool(failed and payload.get("is_interrupt") is True),
+         source=source, cwd=cwd,
+         out_bytes=(report_bytes(result)
+                    if untrusted_source(tool, inp) == SUBAGENT_CHANNEL
+                    else result_size(result)),
+         empty_run=ran_nothing(result), agent=subagent_id(payload))
+    advice = safe(session_id, graph_advice, tool, inp, cwd, "qwen")
+    taste = cross = None
+    if not failed:
+        taste = safe(session_id, write_note, session_id, inp, cwd, tool)
+        cross = safe(session_id, cross_project_note, session_id, tool, inp, cwd)
+    return "\n".join(p for p in (notice, advice, taste, cross) if p)
+
+
+def context(event, text):
+    return {"hookSpecificOutput": {"hookEventName": event,
+                                   "additionalContext": text}} if text else {}
+
+
+def main():
+    try:
+        payload = json.load(sys.stdin)
+    except Exception:
+        return
+    if not isinstance(payload, dict):
+        return
+    event = payload.get("hook_event_name") or ""
+    cwd = payload.get("cwd") or os.getcwd()
+    session_id = payload.get("session_id")
+    safe(session_id, bind_session, session_id)  # the switch latch (tezgah_paths.off)
+    out = {}
+    if event == "PreToolUse":
+        reason = safe(session_id, decision, gate_name(payload.get("tool_name", "")),
+                      inp_of(payload), cwd, session_id, agent=subagent_id(payload))
+        if reason:
+            out = {"hookSpecificOutput": {
+                "hookEventName": "PreToolUse",
+                "permissionDecision": "deny",
+                "permissionDecisionReason": reason,
+            }}
+    elif event in ("PostToolUse", "PostToolUseFailure"):
+        out = context(event, post_tool(payload, cwd, session_id,
+                                       event == "PostToolUseFailure"))
+    elif event == "SessionStart":
+        safe(session_id, attest_session, "qwen", session_id, cwd)
+        out = context(event, safe(session_id, context_for, "session_start", cwd,
+                                  payload, with_core=not rules_carry_core()))
+    elif event == "UserPromptSubmit":
+        out = context(event, safe(session_id, context_for, "user_prompt", cwd, payload))
+    elif event == "SubagentStart":
+        safe(session_id, record, session_id, "orch")
+        kind = payload.get("agent_type")
+        if subagent_id(payload) and isinstance(kind, str) and root_for(cwd):
+            safe(session_id, note, session_id, "subagent_start", kind,
+                 agent=subagent_id(payload))
+        # the delegate is a fresh context: Qwen documents additionalContext here
+        # as the subagent's initial context
+        out = context(event, safe(session_id, context_for, "subagent_start", cwd,
+                                  payload))
+    elif event == "SubagentStop":
+        # a subagent's end is judged record-only (ADR 011): one `subagent_end`
+        # row from its last message, never a block
+        safe(session_id, record, session_id, "orch")
+        if not off("verify-off") and root_for(cwd):
+            safe(session_id, stop_reason, payload.get("last_assistant_message") or "",
+                 session_id, cwd=cwd, subagent=True)
+    elif event == "Stop":
+        # Qwen's Stop carries `last_assistant_message` and `stop_hook_active`,
+        # and takes {"decision": "block", "reason": ...}. The reply after a block
+        # is judged again and refused at most once more (tezgah_integrity).
+        if not off("verify-off") and root_for(cwd):
+            reason = safe(session_id, stop_reason,
+                          payload.get("last_assistant_message"), session_id,
+                          cwd=cwd, after_block=bool(payload.get("stop_hook_active")),
+                          mode=payload.get("permission_mode"))
+            if reason:
+                out = {"decision": "block", "reason": reason}
+    if out:
+        print(json.dumps(out))
+
+
+main()

package/output-styles/tezgah.md

@@ -36,7 +36,7 @@ one small test); a one-liner needs none. A complex ask ships the lazy version
 and names the fuller one in the same reply instead of stalling. Reply: code
 first; write what was cut only when you consciously cut something the user asked
 for, in at most three lines. In force from the first turn; levels
-lite|full|ultra are set with `tezgah-pony` and ride the per-turn reminder when
+lite|full|ultra are set with `~/.config/tezgah/bin/tezgah-pony` and ride the per-turn reminder when
 not `full`; read the full `ponytail` skill from the router for the level table
 and examples. Off: "stop ponytail".
 
@@ -47,7 +47,10 @@ bounded action per step, and while it is in flight its position is restated in
 one line - the todo list is that source, never re-narrate the plan. End with the
 approval questions the Ask policy (below) leaves, or with nothing when none is
 left; a step you can take yourself is taken, never handed
-over. Finish the issue in hand before raising a second one; an error states
+over, and in the host's plan mode, where nothing can run, the plan is the
+deliverable: its approval is the question that turn asks and nothing is
+reported as done or tested.
+Finish the issue in hand before raising a second one; an error states
 location, cause and fix with no drama, naming a cause only when the evidence
 identifies it (else what is known and what would confirm it); after a change say
 what now works. A list shows at most five items, ranked, the rest kept in
@@ -62,7 +65,7 @@ assumption and ask one diagnostic question. Before sending, delete an opening
 sentence that announces, a closing one that recaps or asks "anything else?", any
 by-the-way sidebar and any hedge that carries no real uncertainty. In force from
 the first answer; read the full `i-have-adhd` skill from the router for the
-examples. Off: `tezgah-adhd off`, or the repo's `.no-adhd`.
+examples. Off: `~/.config/tezgah/bin/tezgah-adhd off`, or the repo's `.no-adhd`.
 
 **Deliver the whole ask; never the shortcut.** The request defines the
 deliverable: every named item is in scope until the user says otherwise, and the
@@ -112,15 +115,17 @@ lines: item - blocker - evidence - what unblocks it. No blockers: no heading.
 Work and process - the order, "shall I go on", a check, a plan, a consult
 member, a spend within `spend_cap`, a local merge of the session's branch,
 removing its worktree - are taken and stated in one line, never asked; a taste
-or intent fork goes in the batch with a default taken this turn, but building a
-plan this turn wrote waits for the answer. An outward step
+or intent fork goes in the batch with a default taken this turn, but the
+never-default items below wait for the answer. An outward step
 on the user's own remote (push, PR, release, their package) runs on a grant
 ("push without asking", "I approve", "bana sormadan pushla", "onay veriyorum"), else is asked once. Never on a
 default - ask and wait for an answer naming action and target: a force push,
 deleting what the session did not make, production, a credential, a third
-party, a spend over the cap. The batch: one "Approval questions"/"Onay için sorular" heading, waiting
+party, a spend over the cap, building a plan this turn wrote, picking a
+recommended variant, a way around a tezgah refusal, another session's work. The batch: one "Approval questions"/"Onay için sorular" heading, waiting
 items first, each numbered item with "Recommended:"/"Öneri:" its default; an ask tool
-sets a recommended option.
+sets a recommended option. No fresh subagent, no review verdict: say so and
+ask. Contest a finding only with a file:line; never lower a severity.
 **Say what a number was measured on.** A figure produced by a fixture - a temp
 HOME, a generated repository, a stand-in, a hand-written sample - is evidence
 about the code path, never a property of the running system, and it is reported
@@ -169,19 +174,19 @@ issue for one of its tools mid-session. Name a missing capability in one line,
 use the documented fallback (grep/find, or the second opinion skipped), and carry
 on with the task in hand. Tezgah maintenance is in scope when the user asks for
 it, or when the repo IS the tezgah checkout. Before working a topic an
-installed skill covers, run `tezgah-skill <words>` and read only the range it
+installed skill covers, run `~/.config/tezgah/bin/tezgah-skill <words>` and read only the range it
 returns.
 
 **Workspace: `.tezgah/` only.** Every per-project tezgah artifact - plans,
-research lines, analysis, lessons - lives under `<repo>/.tezgah/`, which the
-project's `.gitignore` excludes and which keeps its own private git repository
-(`git -C .tezgah ...`). Never create `plans/`, `research/` or `analysis/` at the
-project root and never `git add -f` anything under `.tezgah/`. Off:
+research lines, analysis, lessons - lives under `<repo>/.tezgah/`, ignored by
+the project, committed with `git -C .tezgah ...` - or, if the project tracks
+it, plain `git add`/`git commit`. Never create `plans/`, `research/` or
+`analysis/` at the project root and never `git add -f` under `.tezgah/`. Off:
 `workspace-off`.
 
 **Kill switches:** each one removes its own rule from this text, not just the
 status mark. `~/.config/tezgah/`: `exec-mode.off`, `orchestrate-off`,
-`consult-off`, `research-off`, `ponytail-auto.off`, `adhd-off`, `spec-off`,
+`consult-off`, `research-off`, `ponytail-auto.off`, `adhd-off`, `spec-off`, `design-off`,
 `reminder-off`, `verify-off` (the integrity rule: its prompt text, the shortcut
 denials and the Stop gate), `task-off` (the task rule), `judge-off` (the
 judgement seam: the triage, the docs fallback and the skill hint), `triage-off`,
@@ -189,6 +194,6 @@ judgement seam: the triage, the docs fallback and the skill hint), `triage-off`,
 rule), `workspace-off` (the root plans/research/analysis refusal),
 `pretooluse-off` (the whole gate);
 per-repo `.no-ponytail`, `.no-adhd`, `.no-graph`, `.no-lessons`.
-The ponytail intensity level is not a switch: `tezgah-pony lite|full|ultra`.
+The ponytail intensity level is not a switch: `~/.config/tezgah/bin/tezgah-pony lite|full|ultra`.
 
-**On-demand rules (armed when the task class matches; full text in the `tezgah-contract` skill).** Spec-first for an underspecified or quality-only ask. A second opinion before a call that is hard to reverse or that one model would answer with unearned confidence. OpenResearch routing for research. Product analysis is a five-axis evidence task - value, usability (the running app, not the source), feasibility (a cited `path:line`), competition, and keep/fix/cut/bet triage - with one named evidence class per finding. The code graph for "who calls X" and "what breaks if Z changes". Two or more independent items fan out to parallel subagents in one message, one git worktree per writing slice. The design floor a UI turn is judged against is `.tezgah/design-contract.md`: `tezgah-design derive` writes it from the repository's own tokens, `tezgah-design check` measures a change against it, and the `design-contract` skill owns its shape.
+**On-demand rules (armed when the task class matches; full text in the `tezgah-contract` skill).** Spec-first for an underspecified or quality-only ask. A second opinion before a call that is hard to reverse or that one model would answer with unearned confidence. OpenResearch routing for research. Product analysis is a five-axis evidence task - value, usability (the running app, not the source), feasibility (a cited `path:line`), competition, and keep/fix/cut/bet triage - with one named evidence class per finding (`product-analysis`, `pm-frameworks`). The code graph for "who calls X" and "what breaks if Z changes". Two or more independent items fan out to parallel subagents in one message, one git worktree per writing slice. A UI turn reads the `design-contract` skill (`design-library`, `analyze-app`) and is judged against `.tezgah/design-contract.md`: `~/.config/tezgah/bin/tezgah-design derive` writes it from the repository's own tokens and its `check` measures a change against it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@r1z4x/tezgah",
-  "version": "1.9.2",
+  "version": "1.13.0",
   "description": "One shared working contract for every AI coding assistant you run: Claude Code, Codex, Cursor, opencode, dsh and oh-my-pi (omp).",
   "license": "MIT",
   "repository": {

package/skills/ai-research/SKILL.md

@@ -1,17 +1,22 @@
 ---
 name: ai-research
 description: >
-  The vendored AI-research-SKILLs library - 98 upstream skills in 23 categories,
-  MIT - that now ships with tezgah. Use when a research line needs AI or ML
-  machinery: training or fine-tuning a model, serving or quantizing one,
-  evaluating a benchmark, reading model internals, building a retrieval or agent
-  pipeline, tracking runs, or writing the result up. Read the one entry the work
-  needs, never the tree. Do NOT use for code discovery ("where is X", "who calls
-  Y") - that is the code graph.
+  Use when a research line needs AI/ML machinery: training, fine-tuning,
+  serving, evals; ince ayar, dil modeli. Not for RL environments - use `rl-env`.
 ---
 
 # ai-research
 
+## When to use
+
+The vendored AI-research-SKILLs library - 98 upstream skills in 23 categories,
+MIT - that now ships with tezgah. Use when a research line needs AI or ML
+machinery: training or fine-tuning a model, serving or quantizing one,
+evaluating a benchmark, reading model internals, building a retrieval or agent
+pipeline, tracking runs, or writing the result up. Read the one entry the work
+needs, never the tree. Do NOT use for code discovery ("where is X", "who calls
+Y") - that is the code graph.
+
 Ninety-eight skills from Orchestra Research's `AI-research-SKILLs`, vendored into
 this repository at revision `773a529` (2026-06-15, MIT) and kept in the upstream
 layout, so a path here is the path there. Re-vendor, or verify the tree, with
@@ -27,8 +32,10 @@ before.
 
 1. **`index/<stage>.md`** - six files, one per stage of a research line. Read the
    one that matches the work in hand; it lists every entry with its purpose.
-2. **the entry's `SKILL.md`** - the file the index line names, e.g.
-   `11-evaluation/lm-evaluation-harness/SKILL.md`. That is the upstream body.
+2. **the entry's `ENTRY.md`** - the file the index line names, e.g.
+   `11-evaluation/lm-evaluation-harness/ENTRY.md`. That is the upstream body:
+   upstream's `SKILL.md`, renamed so a host that lists every `SKILL.md` below its
+   skills directory does not list it. A body that says `SKILL.md` means this file.
 3. **its `references/`** - the detail the body points at, when the body is not
    enough.
 
@@ -57,7 +64,7 @@ Each index line can carry a flag, and they are not decoration:
   live links in the same entry still work.
 
 An entry with no body vendored would be a line without a file - there is none:
-every one of the 98 ships its `SKILL.md`.
+every one of the 98 ships its `ENTRY.md`.
 
 ## Where tezgah's own rules still win
 
@@ -75,14 +82,14 @@ account, a paid service or the user's data still needs the user's yes first.
   this contract's protocol-before-run rule.
 - `20-ml-paper-writing/ml-paper-writing/references/citation-workflow.md` - how to
   verify a reference instead of writing one from memory.
-- `20-ml-paper-writing/academic-plotting/SKILL.md` - chart-type rules, a
+- `20-ml-paper-writing/academic-plotting/ENTRY.md` - chart-type rules, a
   colourblind-safe palette and venue column widths; every line ends in a figure.
-- `22-agent-native-research-artifact/rigor-reviewer/SKILL.md` - the 1-5 scoring
+- `22-agent-native-research-artifact/rigor-reviewer/ENTRY.md` - the 1-5 scoring
   anchors and severity inventory behind this contract's six-dimension review.
-- `22-agent-native-research-artifact/compiler/SKILL.md` - evidence fidelity: exact
+- `22-agent-native-research-artifact/compiler/ENTRY.md` - evidence fidelity: exact
   numbers, a derived subset never named `Table N`, every evidence file carrying
   its source.
-- `11-evaluation/lm-evaluation-harness/SKILL.md` - the runnable benchmark recipe a
+- `11-evaluation/lm-evaluation-harness/ENTRY.md` - the runnable benchmark recipe a
   research line usually quotes.
 
 ## Provenance

package/skills/ai-research/SOURCE

@@ -10,12 +10,14 @@ contributing author of that entry. Checkout for a re-vendor:
 
 Every skill's `SKILL.md` and every markdown file beside it, in the upstream
 layout, because a vendored path is its provenance. 98 skills across 23
-categories, 365 files, 4202519 bytes.
+categories, 365 files, 4202519 bytes. One rename: each entry's `SKILL.md` sits at
+the upstream path as `ENTRY.md`, bytes unchanged, so a host that lists every
+`SKILL.md` below its skills directory (codex, Cursor) does not list it.
 
 ## What is not, and why
 
 Files: `03-fine-tuning/unsloth/references/llms-full.md`, `03-fine-tuning/unsloth/references/llms-txt.md`, `08-distributed-training/deepspeed/references/tutorials.md` - machine-scraped reference dumps, which the entry's own
-`SKILL.md` already distils.
+`ENTRY.md` already distils.
 
 Directories: `20-ml-paper-writing/ml-paper-writing/templates`, `20-ml-paper-writing/systems-paper-writing/templates` - LaTeX class/bst/bib trees and example PDFs,
 re-downloadable from each venue.
@@ -27,9 +29,9 @@ is dropped by the importer's `*.md` filter, and `demos/`, `docs/`,
 ## The only modification
 
 A markdown file that carries no YAML frontmatter gets one attribution
-comment on its first line. `SKILL.md` files are byte-for-byte upstream,
-frontmatter included. `skills/ai-research/SKILL.md` is tezgah's own and is
-not part of the manifest.
+comment on its first line. `ENTRY.md` files are byte-for-byte upstream
+`SKILL.md`, frontmatter included. `skills/ai-research/SKILL.md` is
+tezgah's own and is not part of the manifest.
 
 ## Re-vendoring
 

package/skills/ai-research/index/1-frame.md

@@ -10,9 +10,9 @@ links N reference files upstream does not ship.
 
 | entry | file | what it covers | flags |
 |---|---|---|---|
-| `0-autoresearch-skill` | `0-autoresearch-skill/SKILL.md` | Orchestrates end-to-end autonomous AI research projects using a two-loop architecture. |  |
-| `brainstorming-research-ideas` | `21-research-ideation/brainstorming-research-ideas/SKILL.md` | Guides researchers through structured ideation frameworks to discover high-impact research directions. |  |
-| `creative-thinking-for-research` | `21-research-ideation/creative-thinking-for-research/SKILL.md` | Applies cognitive science frameworks for creative thinking to CS and AI research ideation. |  |
-| `compiler` | `22-agent-native-research-artifact/compiler/SKILL.md` | Compiles any research input — PDF papers, GitHub repositories, experiment logs, code directories, or raw notes — into a complete Agent-Native Research Artifact (ARA) with ... |  |
-| `research-manager` | `22-agent-native-research-artifact/research-manager/SKILL.md` | Records research provenance as a post-task epilogue, scanning conversation history at the end of a coding or research session to extract decisions, experiments, dead ends, claims ... |  |
-| `rigor-reviewer` | `22-agent-native-research-artifact/rigor-reviewer/SKILL.md` | Performs ARA Seal Level 2 semantic epistemic review on Agent-Native Research Artifacts, scoring six dimensions (evidence relevance, falsifiability, scope calibration, argument ... |  |
+| `0-autoresearch-skill` | `0-autoresearch-skill/ENTRY.md` | Orchestrates end-to-end autonomous AI research projects using a two-loop architecture. |  |
+| `brainstorming-research-ideas` | `21-research-ideation/brainstorming-research-ideas/ENTRY.md` | Guides researchers through structured ideation frameworks to discover high-impact research directions. |  |
+| `creative-thinking-for-research` | `21-research-ideation/creative-thinking-for-research/ENTRY.md` | Applies cognitive science frameworks for creative thinking to CS and AI research ideation. |  |
+| `compiler` | `22-agent-native-research-artifact/compiler/ENTRY.md` | Compiles any research input — PDF papers, GitHub repositories, experiment logs, code directories, or raw notes — into a complete Agent-Native Research Artifact (ARA) with ... |  |
+| `research-manager` | `22-agent-native-research-artifact/research-manager/ENTRY.md` | Records research provenance as a post-task epilogue, scanning conversation history at the end of a coding or research session to extract decisions, experiments, dead ends, claims ... |  |
+| `rigor-reviewer` | `22-agent-native-research-artifact/rigor-reviewer/ENTRY.md` | Performs ARA Seal Level 2 semantic epistemic review on Agent-Native Research Artifacts, scoring six dimensions (evidence relevance, falsifiability, scope calibration, argument ... |  |

package/skills/ai-research/index/2-data.md

@@ -10,12 +10,12 @@ links N reference files upstream does not ship.
 
 | entry | file | what it covers | flags |
 |---|---|---|---|
-| `huggingface-tokenizers` | `02-tokenization/huggingface-tokenizers/SKILL.md` | Fast tokenizers optimized for research and production. |  |
-| `sentencepiece` | `02-tokenization/sentencepiece/SKILL.md` | Language-independent tokenizer treating text as raw Unicode. |  |
-| `nemo-curator` | `05-data-processing/nemo-curator/SKILL.md` | GPU-accelerated data curation for LLM training. |  |
-| `ray-data` | `05-data-processing/ray-data/SKILL.md` | Scalable data processing for ML workloads. |  |
-| `chroma` | `15-rag/chroma/SKILL.md` | Open-source embedding database for AI applications. |  |
-| `faiss` | `15-rag/faiss/SKILL.md` | Facebook's library for efficient similarity search and clustering of dense vectors. |  |
-| `pinecone` | `15-rag/pinecone/SKILL.md` | Managed vector database for production AI applications. |  |
-| `qdrant` | `15-rag/qdrant/SKILL.md` | High-performance vector similarity search engine for RAG and semantic search. |  |
-| `sentence-transformers` | `15-rag/sentence-transformers/SKILL.md` | Framework for state-of-the-art sentence, text, and image embeddings. |  |
+| `huggingface-tokenizers` | `02-tokenization/huggingface-tokenizers/ENTRY.md` | Fast tokenizers optimized for research and production. |  |
+| `sentencepiece` | `02-tokenization/sentencepiece/ENTRY.md` | Language-independent tokenizer treating text as raw Unicode. |  |
+| `nemo-curator` | `05-data-processing/nemo-curator/ENTRY.md` | GPU-accelerated data curation for LLM training. |  |
+| `ray-data` | `05-data-processing/ray-data/ENTRY.md` | Scalable data processing for ML workloads. |  |
+| `chroma` | `15-rag/chroma/ENTRY.md` | Open-source embedding database for AI applications. |  |
+| `faiss` | `15-rag/faiss/ENTRY.md` | Facebook's library for efficient similarity search and clustering of dense vectors. |  |
+| `pinecone` | `15-rag/pinecone/ENTRY.md` | Managed vector database for production AI applications. |  |
+| `qdrant` | `15-rag/qdrant/ENTRY.md` | High-performance vector similarity search engine for RAG and semantic search. |  |
+| `sentence-transformers` | `15-rag/sentence-transformers/ENTRY.md` | Framework for state-of-the-art sentence, text, and image embeddings. |  |