diff --git a/marketplace.json b/marketplace.json
index efd72ba..4a74266 100644
--- a/marketplace.json
+++ b/marketplace.json
@@ -443,6 +443,30 @@
         "ci-cd",
         "gitlab-api"
       ]
+    },
+    {
+      "name": "zcoder",
+      "source": "./plugins/zcoder",
+      "description": "zCoder — always-on GLM multi-model orchestration for ZCode: routes every task to the right engine (vision / turbo / deep) with pinned thinking effort, plus skill-forge, a measured skill lifecycle with oracle-graded evals, Wilson-scored trials, Pareto acceptance, and 7-gate promotion.",
+      "description_i18n": {
+        "en": "zCoder — always-on GLM multi-model orchestration for ZCode: routes every task to the right engine (vision / turbo / deep) with pinned thinking effort, plus skill-forge, a measured skill lifecycle with oracle-graded evals, Wilson-scored trials, Pareto acceptance, and 7-gate promotion.",
+        "zh-CN": "zCoder —— ZCode 常驻 GLM 多模型编排器:把每个任务路由到合适的引擎(视觉 / 轻量 / 深度)并锁定思考力度;内置 skill-forge 可度量技能生命周期 —— 确定性预言机评分、Wilson 加权试验台账、Pareto 前沿验收与七道门晋升。"
+      },
+      "version": "0.1.4",
+      "author": {
+        "name": "anthonykewl20",
+        "url": "https://github.com/anthonykewl20"
+      },
+      "category": "developer-tools",
+      "keywords": [
+        "glm",
+        "orchestration",
+        "multi-model",
+        "routing",
+        "subagents",
+        "skill-evaluation",
+        "agent-swarms"
+      ]
     }
   ]
 }
diff --git a/plugins/zcoder/.zcode-plugin/plugin.json b/plugins/zcoder/.zcode-plugin/plugin.json
new file mode 100644
index 0000000..9c943d8
--- /dev/null
+++ b/plugins/zcoder/.zcode-plugin/plugin.json
@@ -0,0 +1,19 @@
+{
+  "name": "zcoder",
+  "version": "0.1.4",
+  "description": "zCoder — always-on GLM multi-model orchestration for ZCode: routes every task to the right engine (vision / turbo / deep) with pinned thinking effort, plus skill-forge, a measured skill lifecycle with oracle-graded evals, Wilson-scored trials, Pareto acceptance, and 7-gate promotion.",
+  "description_i18n": {
+    "en": "zCoder — always-on GLM multi-model orchestration for ZCode: routes every task to the right engine (vision / turbo / deep) with pinned thinking effort, plus skill-forge, a measured skill lifecycle with oracle-graded evals, Wilson-scored trials, Pareto acceptance, and 7-gate promotion.",
+    "zh-CN": "zCoder —— ZCode 常驻 GLM 多模型编排器:把每个任务路由到合适的引擎(视觉 / 轻量 / 深度)并锁定思考力度;内置 skill-forge 可度量技能生命周期 —— 确定性预言机评分、Wilson 加权试验台账、Pareto 前沿验收与七道门晋升。"
+  },
+  "author": {
+    "name": "anthonykewl20",
+    "url": "https://github.com/anthonykewl20"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/anthonykewl20/zCoder",
+  "agents": "agents",
+  "skills": "skills",
+  "commands": "commands",
+  "hooks": "hooks"
+}
diff --git a/plugins/zcoder/README.md b/plugins/zcoder/README.md
new file mode 100644
index 0000000..e2e9327
--- /dev/null
+++ b/plugins/zcoder/README.md
@@ -0,0 +1,78 @@
+# zCoder (ZCode plugin)
+
+Always-on GLM multi-model orchestration for ZCode, plus **skill-forge** — a measured lifecycle for building and improving skills. Every task is decomposed and routed to the right engine automatically; every skill change is graded by deterministic oracles before it ships.
+
+## What it solves
+
+- **Routing waste**: ZCode's main thread and its subagents can run the same task at the same effort. zCoder pins each engine's model and thinking effort, then routes by ordered predicates: atomic requests are answered directly, visual sub-tasks go to the vision engine, mechanical batches go to the cheap lane, and deep sub-tasks get the max-effort engine only when parallelism or context isolation pays for it.
+- **Unmeasured skills**: a skill that "seems better" after an edit is a vibe. skill-forge scores skills with deterministic Python oracles into a Wilson-scored, session-stamped trials ledger; improvements must be same-session PAIRED evidence on a Pareto frontier, and promotion passes 7 explicit gates. Idle automation never promotes — promotion requires interactive `--approved-by`.
+
+## Engines
+
+| Engine agent | Model | Effort | Routes |
+|---|---|---|---|
+| `glm-vision` | GLM-5.3-Flash | `max` | Images, OCR, screenshots/mockups, visual diffs, UI/UX inspection, diagrams |
+| `glm-turbo` | GLM-5.3-Flash | `low` | **Conditional lane** — routed to only after a verified PASS in the current session; until then mechanical batches run on the main thread (never route real work to an unverified engine) |
+| `glm-main` | GLM-5.3 | `max` | Architecture, multi-file logic, algorithms, deep debugging, security analysis, final correctness audits |
+
+**Degradation ladder:** if the vision engine fails, perception degrades to the main thread first (same model), then `glm-main`. An unverified engine is never trusted with real work — mechanical batches route to `glm-turbo` only after a verified PASS in the current session.
+
+**ZCode-only.** This plugin uses the `.zcode-plugin/plugin.json` manifest and ZCode hooks/agents/skills/commands exclusively. It intentionally ships no `.claude-plugin/` or `.codex-plugin/` compatibility manifest.
+
+## Components
+
+- `agents/` — the three engine agents. The `model:` and `thoughtLevel:` in each agent's frontmatter pin routing and effort; both are required. Omitting `thoughtLevel:` makes the harness inject compiled defaults that some backends reject (e.g. `high`/`low`), so the values are pinned, not implicit. `thoughtLevel:` edits apply live on the next dispatch; `model:` edits need a session restart.
+- `skills/glm-orchestrator/` — the orchestration protocol: 4-step chain (decompose → routing plan → dispatch → synthesize + Principal Engineer audit), zero-waste rule, degradation rules, worked example.
+- `skills/skill-forge/` + `commands/skill-scan.md` + `commands/skill-evolve.md` — the measured skill lifecycle. `/skill-scan` detects stack gaps zero-token (manifest-based, no LLM calls); `/skill-evolve` runs a staged evaluate→mutate→promote round (Pareto-targeted, mini-batch budget: a candidate that doesn't fix its target scenario dies before any full-matrix spend). Skills are scored by deterministic Python oracles into a Wilson-scored trials ledger (`tests/skill-evals/<skill>/trials.jsonl` in the project where the skill is exercised); comparisons are same-session interleaved only; improvements are reflective mutations that must cite the failing trial (`MUTATION.md`); acceptance is Pareto-frontier expansion (`pareto.py` — per-scenario dominance, never scalar averages; also emits the next mutation target and the plateau stop-rule: 2 consecutive promotions without frontier entry ⇒ write a new scenario, not another body mutation). Promotion passes 7 gates — static caps, oracle self-test, strictly-better paired evidence, mutation citation, differs-from-incumbent, growth limit, trigger evidence (a changed `description:` needs a recorded router-probe run: effective ≥0.75, zero cross-skill regressions) — and requires interactive `--approved-by`.
+- `skills/laravel-dev/`, `skills/yaml-json-convert/` — the first skills born from this lifecycle, each shipping its scenario/oracle eval suite under `tests/skill-evals/`.
+- `commands/` — `/orchestrate <task>` (full pipeline with visible routing JSON) and `/route <task>` (plan-only preview, no execution).
+- `hooks/` — **always-on routing, three events**: `SessionStart` anchors the routing directive at chat boot (covers new, resumed, cleared, and compacted sessions), `UserPromptSubmit` re-injects it on every prompt, and `PreToolUse` on the Agent tool runs a dispatch-contract check on every glm-engine dispatch (self-contained message, ≤300 words, no inlined file bodies — non-zCoder agents stay untouched).
+- `tests/` — the plugin's own regression and integrity suites (portable, zero-token): `skill-forge-static.sh` (static integrity checks), `skill-forge-smoke.sh` (adversarial fixtures against every script CLI, all state in a mktemp sandbox), the OHI monitoring scripts, the capability ledger, and the pre-registered trigger-case table.
+
+## Install (ZCode)
+
+1. Open ZCode → **Settings → Plugin Management → **Discover** tab.
+2. Find **zCoder** in the official marketplace and click **Get**.
+3. Keep it enabled — the plugin hooks enable the hook runner automatically.
+
+Verify: the `/` menu shows `orchestrate` and `route` under zCoder, and **Settings → Subagents** lists `glm-vision`, `glm-turbo`, `glm-main`.
+
+## Usage
+
+- Always-on: with the plugin enabled, zCoder orchestration applies to every chat automatically — the hooks anchor routing at session start, re-inject it on each prompt, and check each engine dispatch against the contract. No invocation needed.
+- Explicit: `/orchestrate implement this dashboard mockup and optimize the server fetch logic`.
+- Preview only: `/route refactor auth across 3 services and fix the CSV parser` → table of sub-tasks, engines, and effort levels without executing.
+- Skill lifecycle: `/skill-scan` to detect missing stack skills; `/skill-evolve <skill>` to run one measured improvement round.
+
+## Model IDs
+
+Defaults are model codes from the Z.ai GLM catalog: `glm-5.3-flash` (vision/turbo), `glm-5.3` (deep). If your build lists different names in the model picker, edit the `model:` line in the matching `agents/*.md` and restart the session — nothing else needs to change.
+
+## Tuning
+
+- **Thinking effort** — pinned per agent via `thoughtLevel:` in `agents/*.md`. Effort rejections are deterministic and cost zero tokens: never retry them. Pins apply at session start; mid-session `thoughtLevel:` edits may serve stale cached values.
+- **Vision model** — if your plan grants a dedicated vision model, change `model:` in `agents/glm-vision.md` and restart the session.
+- **Disable the always-on routing injection** (keep the agents/commands): `touch ~/.zcode/zcoder.off`, or run ZCode with `GLM_ORCHESTRATOR_DISABLE=1`. Delete the file / unset the variable to re-enable.
+- **Routing rules** — the matrix and dispatch rules live in `skills/glm-orchestrator/SKILL.md`; edit there to reweight precedence (e.g. make the turbo lane the default instead of the deep engine).
+
+## Dependencies, side effects, and security
+
+- **Network**: none. The plugin makes no outbound requests and bundles no MCP servers. Subagents dispatched by the orchestrator use ZCode's own model providers.
+- **Model/API dependencies**: the engine agents reference GLM models by ID (`glm-5.3`, `glm-5.3-flash`) available through ZCode's built-in Z.ai provider. A plan without those exact model IDs needs the one-line `model:` edit described above.
+- **Command execution**: the hooks run a local bash script (`hooks/inject-routing.sh`) on session start, every prompt, and Agent-tool dispatches. It only reads its stdin payload and prints a routing directive — no file writes, no network, and it exits immediately when either kill switch is active.
+- **File writes**: running skill-forge rounds (`/skill-evolve`) and the OHI monitors writes trial ledgers, promotion records, and logs under `tests/skill-evals/` and `tests/` **in the project where you run them**. The plugin never writes outside the current project or `~/.zcode` (the optional `zcoder.off` flag file, which you create yourself).
+- **No credentials, telemetry, or analytics** are collected or transmitted.
+
+## Health definition (learned the hard way)
+
+A green static suite only proves the **files agree with each other** — it is not system health. The turbo lane once sat at zero lifetime successful dispatches while every round reported green, because nothing measured ground-truth capability. Health is now a three-way conjunction, enforced statically:
+
+1. **Static suite green** (config coherence) — `tests/skill-forge-static.sh`,
+2. **Capability ledger green** — `tests/capability-ledger.json`: every engine explicitly VERIFIED-fresh / CONDITIONAL-routed-around / REMOVED; no silent defaults, no zombie lanes; and
+3. **No lifetime alarms** — `tests/ohi-stats.py` from the dispatch ledger: 0%-success and majority-fail engines report NEVER-WORKED / remove-or-investigate; consecutive-failure streaks flagged.
+
+Plus institutionalized humility: every FULL dogfood round runs one adversarial **blind-spot sweep** (an engine is asked what the system still cannot see), because blind spots are found by hunting, not by checklists.
+
+## License and provenance
+
+MIT. The reflective-mutation, size-cap, growth-cap, session-mining, Pareto-frontier, staged mini-batch, and trigger/description-evolution patterns are ported from [NousResearch/hermes-agent-self-evolution](https://github.com/NousResearch/hermes-agent-self-evolution) (MIT). Its AGPL Darwinian Evolver was deliberately not ported, and its DSPy/GEPA LLM-judge machinery was re-implemented as deterministic oracles (a judge's opinion is not a measurement).
diff --git a/plugins/zcoder/README_CN.md b/plugins/zcoder/README_CN.md
new file mode 100644
index 0000000..d8a0373
--- /dev/null
+++ b/plugins/zcoder/README_CN.md
@@ -0,0 +1,78 @@
+# zCoder(ZCode 插件)
+
+ZCode 的常驻 GLM 多模型编排器,并内置 **skill-forge** —— 一套可度量的技能构建与改进生命周期。每个任务都会被自动分解并路由到合适的引擎;每次技能变更在发布前都要经过确定性预言机评分。
+
+## 解决什么问题
+
+- **路由浪费**:ZCode 主线程与其子代理可能以相同力度运行同一任务。zCoder 为每个引擎锁定模型与思考力度,再按有序谓词路由:原子请求直接回答;视觉子任务交给视觉引擎;机械批量走廉价通道;深度子任务仅在并行或上下文隔离确实有收益时才使用最大力度引擎。
+- **无法度量的技能**:改完"感觉更好"的技能只是感觉。skill-forge 用确定性 Python 预言机把技能评分写入 Wilson 加权、按会话标记的试验台账;改进必须是同会话配对的 Pareto 前沿证据,晋升要过 7 道显式闸门。空闲的自动化永不晋升 —— 晋升需要交互式 `--approved-by`。
+
+## 引擎
+
+| 引擎代理 | 模型 | 力度 | 路由 |
+|---|---|---|---|
+| `glm-vision` | GLM-5.3-Flash | `max` | 图像、OCR、截图/设计稿、视觉比对、UI/UX 检查、图表 |
+| `glm-turbo` | GLM-5.3-Flash | `low` | **条件通道** —— 仅当本会话内该引擎有已验证的 PASS 后才路由;在此之前机械批量在主线程执行(绝不把真实工作交给未验证的引擎) |
+| `glm-main` | GLM-5.3 | `max` | 架构、跨文件逻辑、算法、深度调试、安全分析、最终正确性审计 |
+
+**降级阶梯**:若视觉引擎失败,感知先降级到主线程(同一模型),再降级到 `glm-main`。未经验证的引擎绝不承担真实工作 —— 机械批量仅在当前会话内 `glm-turbo` 获得已验证的 PASS 之后才路由给它。
+
+**仅限 ZCode。** 本插件使用 `.zcode-plugin/plugin.json` 清单,仅包含 ZCode 的 hooks/agents/skills/commands,刻意不附带 `.claude-plugin/` 或 `.codex-plugin/` 兼容清单。
+
+## 组件
+
+- `agents/` —— 三个引擎代理。每个代理 frontmatter 中的 `model:` 与 `thoughtLevel:` 锁定路由与力度,两者都必填:省略 `thoughtLevel:` 会让框架注入编译期默认值,而某些后端会拒绝(如 `high`/`low`),因此这些值是显式锁定的。`thoughtLevel:` 的修改在下一次分发即时生效;`model:` 的修改需要重启会话。
+- `skills/glm-orchestrator/` —— 编排协议:4 步链(分解 → 路由计划 → 分发 → 综合 + 主工程师审计)、零浪费规则、降级规则、完整示例。
+- `skills/skill-forge/` + `commands/skill-scan.md` + `commands/skill-evolve.md` —— 可度量的技能生命周期。`/skill-scan` 零 token 检测技术栈缺口(基于清单,不调用 LLM);`/skill-evolve` 执行一轮 分阶段 评估→变异→晋升(Pareto 定向、小批量预算:修不好目标场景的候选在任何全矩阵开销之前就被淘汰)。技能由确定性 Python 预言机评分并写入 Wilson 加权试验台账(位于运行该技能项目下的 `tests/skill-evals/<skill>/trials.jsonl`);只做同会话交错比较;改进是必须引用失败试验的反身性变异(`MUTATION.md`);验收标准是 Pareto 前沿扩张(`pareto.py` —— 按场景支配,绝不使用标量平均;同时输出下一个变异目标与平台期止损规则:连续 2 次晋升未进入前沿 ⇒ 写新场景,而不是继续改正文)。晋升通过 7 道闸门 —— 静态上限、预言机自检、严格更优的配对证据、变异引用、与现任不同、增长上限、触发证据(修改 `description:` 需要记录在案的路由探针运行:有效值 ≥0.75 且零跨技能回归)—— 并需要交互式 `--approved-by`。
+- `skills/laravel-dev/`、`skills/yaml-json-convert/` —— 该生命周期产出的前两个技能,各自在 `tests/skill-evals/` 下附带场景/预言机评测套件。
+- `commands/` —— `/orchestrate <任务>`(完整流水线,可见路由 JSON)与 `/route <任务>`(仅预览计划,不执行)。
+- `hooks/` —— **常驻路由,三个事件**:`SessionStart` 在会话启动时锚定路由指令(覆盖新建、恢复、清空与压缩会话);`UserPromptSubmit` 在每次输入时重新注入;`PreToolUse`(Agent 工具)对每次 glm 引擎分发执行分发契约检查(自包含消息、≤300 词、不内联文件正文 —— 非 zCoder 代理不受影响)。
+- `tests/` —— 插件自身的回归与完整性套件(可移植、零 token):`skill-forge-static.sh`(静态完整性检查)、`skill-forge-smoke.sh`(针对每个脚本 CLI 的对抗性夹具,全部状态在 mktemp 沙箱中)、OHI 监控脚本、能力台账,以及预注册的触发用例表。
+
+## 安装(ZCode)
+
+1. 打开 ZCode → **Settings → Plugin Management → Discover** 标签页。
+2. 在官方市场中找到 **zCoder**,点击 **Get**。
+3. 保持启用 —— 插件 hooks 会自动启用 hook runner。
+
+验证:`/` 菜单在 zCoder 下显示 `orchestrate` 与 `route`,且 **Settings → Subagents** 列出 `glm-vision`、`glm-turbo`、`glm-main`。
+
+## 使用
+
+- 常驻:插件启用后,zCoder 编排自动作用于每次会话 —— hooks 在会话启动时锚定路由、每次输入时重新注入、每次引擎分发时检查契约。无需手动调用。
+- 显式:`/orchestrate implement this dashboard mockup and optimize the server fetch logic`。
+- 仅预览:`/route refactor auth across 3 services and fix the CSV parser` → 输出子任务、引擎与力度表格,不执行。
+- 技能生命周期:`/skill-scan` 检测缺失的技术栈技能;`/skill-evolve <skill>` 执行一轮可度量的改进。
+
+## 模型 ID
+
+默认值是 Z.ai GLM 目录中的模型代码:`glm-5.3-flash`(视觉/轻量)、`glm-5.3`(深度)。如果你的构建在模型选择器中列出不同名称,修改对应 `agents/*.md` 中的 `model:` 行并重启会话即可 —— 无需其他改动。
+
+## 调优
+
+- **思考力度** —— 通过 `agents/*.md` 中的 `thoughtLevel:` 按代理锁定。力度被拒绝是确定性且零 token 成本的:绝不重试。锁定在会话启动时生效;会话中途修改 `thoughtLevel:` 可能命中过期缓存。
+- **视觉模型** —— 如果你的套餐提供了专用视觉模型,修改 `agents/glm-vision.md` 中的 `model:` 并重启会话。
+- **关闭常驻路由注入**(保留 agents/commands):`touch ~/.zcode/zcoder.off`,或以 `GLM_ORCHESTRATOR_DISABLE=1` 启动 ZCode。删除该文件 / 取消该变量即可重新启用。
+- **路由规则** —— 路由矩阵与分发规则位于 `skills/glm-orchestrator/SKILL.md`;在其中编辑即可调整优先级(例如让轻量通道替代深度引擎成为默认)。
+
+## 依赖、副作用与安全
+
+- **网络**:无。插件不发起任何出站请求,不捆绑 MCP 服务器。编排器分发的子代理使用 ZCode 自身的模型提供方。
+- **模型/API 依赖**:引擎代理按 ID 引用 GLM 模型(`glm-5.3`、`glm-5.3-flash`),经由 ZCode 内置的 Z.ai 提供方访问。若套餐没有这些精确的模型 ID,按上文所述修改一行 `model:` 即可。
+- **命令执行**:hooks 在会话启动、每次输入与 Agent 工具分发时运行本地 bash 脚本(`hooks/inject-routing.sh`)。它只读取 stdin 载荷并打印路由指令 —— 不写文件、不联网,且任一开关生效时立即退出。
+- **文件写入**:运行 skill-forge 轮次(`/skill-evolve`)与 OHI 监控会**在你运行它们的项目**下的 `tests/skill-evals/` 与 `tests/` 中写入试验台账、晋升记录与日志。插件绝不写入当前项目与 `~/.zcode`(可选的 `zcoder.off` 开关文件)之外的位置。
+- **不收集、不传输**任何凭据、遥测或分析数据。
+
+## 健康定义(惨痛教训)
+
+绿色的静态套件只能证明**文件彼此一致** —— 那不是系统健康。轻量通道曾经在整个生命周期内零成功分发,而每一轮都报告绿色,因为没有任何东西测量真实能力。健康现在是三重合取,并由静态检查强制:
+
+1. **静态套件绿色**(配置一致)—— `tests/skill-forge-static.sh`;
+2. **能力台账绿色** —— `tests/capability-ledger.json`:每个引擎显式为 VERIFIED-fresh / CONDITIONAL-routed-around / REMOVED;无静默默认、无僵尸通道;以及
+3. **无生命周期告警** —— `tests/ohi-stats.py` 基于分发台账:0% 成功与多数失败的引擎报告 NEVER-WORKED / 移除或调查;连续失败被标记。
+
+加上制度化的谦逊:每个 FULL 轮次运行一次对抗性**盲区扫描**(让一个引擎回答系统还看不见什么),因为盲区是猎出来的,不是清单查出来的。
+
+## 许可与来源
+
+MIT。反身性变异、尺寸上限、增长上限、会话挖掘、Pareto 前沿、分阶段小批量与触发/描述演化模式移植自 [NousResearch/hermes-agent-self-evolution](https://github.com/NousResearch/hermes-agent-self-evolution)(MIT)。其 AGPL 达尔文进化器被刻意未移植,其 DSPy/GEPA LLM 评审机制被重新实现为确定性预言机(评审的意见不是测量)。
diff --git a/plugins/zcoder/agents/glm-main.md b/plugins/zcoder/agents/glm-main.md
new file mode 100644
index 0000000..986ff87
--- /dev/null
+++ b/plugins/zcoder/agents/glm-main.md
@@ -0,0 +1,28 @@
+---
+name: glm-main
+description: "GLM_MAIN engine — GLM-5.3 core at maximum thinking effort. Use for high-depth sub-tasks: architecture and system design, complex multi-file logic, algorithm design and optimization, hard debugging with unclear root cause, concurrency/performance analysis, security and edge-case vulnerability analysis, database/data-model design, final correctness audits of generated code. Dispatch when the sub-task runs in parallel with other engine work or needs isolated, bounded context — the orchestrator's main thread runs the same GLM-5.3 at max effort, so a solo deep sub-task is usually answered there directly. Do NOT dispatch mechanical or already-fully-specified trivial work (that is glm-turbo's job)."
+model: glm-5.3
+thoughtLevel: max
+color: blue
+tools: [Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, TodoWrite]
+---
+
+You are GLM_MAIN, the deep-reasoning engine of a GLM model cluster (GLM-5.3 core, maximum thinking effort). A lead orchestrator decomposes work and dispatches you the hard atomic sub-tasks. You return engineering-grade results that the orchestrator can synthesize without rework.
+
+## Operating rules
+
+1. **Reason before you touch.** State the approach in 2–4 dense lines, then execute. For design tasks, decide and commit — present the chosen design with its decisive tradeoffs, not a survey of options.
+2. **Exhaust edge cases by construction.** Enumerate failure modes relevant to the dispatched sub-task (boundaries, concurrency, partial failure, empty/huge inputs, encoding, auth boundaries) and show how the design or code neutralizes each. An unaudited edge is an unfinished task.
+3. **Respect the existing system.** Read the surrounding code before changing it; match its idioms, naming, and structure. Changes must integrate — never float a parallel style.
+4. **Precision over volume.** Every line you emit must be load-bearing. No restating the prompt, no filler prose, no unrequested alternatives. If you rejected an approach for a non-obvious reason, one line on why is enough. Treat context as bounded: never re-read what this dispatch already read, and compress interim findings to ≤5 lines before moving to the next phase.
+5. **Own correctness.** If you find a defect in your own approach mid-execution, stop and fix the approach — do not ship a known-wrong result. Surface any risk you could not eliminate in RISKS.
+
+## Output contract
+
+```
+GLM_MAIN RESULT
+- decision/design: <what and why, dense>
+- implementation/analysis: <code or reasoning artifact>
+- edge cases covered: <list: case → neutralization>
+RISKS: <residual risks or unknowns; omit if none>
+```
diff --git a/plugins/zcoder/agents/glm-turbo.md b/plugins/zcoder/agents/glm-turbo.md
new file mode 100644
index 0000000..9bf82b5
--- /dev/null
+++ b/plugins/zcoder/agents/glm-turbo.md
@@ -0,0 +1,26 @@
+---
+name: glm-turbo
+description: "GLM_TURBO engine — the cheap mechanical lane (GLM-5.3-Flash at low thinking effort; the GLM-5-Turbo model is retired: undispatchable in this harness — every thoughtLevel value including `none` is rejected by the backend, verified through 2026-09-04). Use for low-latency, low-depth work: code formatting, boilerplate/draft generation, light refactoring of already-identified files, JSON/YAML parsing or transformation, regex drafting, bulk text transformation, mechanical renames, docstring/comment writing — batch several independent such items into ONE dispatch to amortize overhead. The dispatch message must already contain everything needed — this engine does not explore. Do NOT dispatch for architecture, coordinated multi-file design, algorithm design, debugging of unclear causes, one-line rewrites answerable inline, or anything requiring deep reasoning (that is glm-main's job)."
+model: glm-5.3-flash
+thoughtLevel: low
+color: green
+tools: [Read, Write, Edit, Bash, Glob, Grep]
+---
+
+You are GLM_TURBO, the low-effort mechanical execution engine of a GLM model cluster (GLM-5.3-Flash at low thinking effort). You are dispatched for mechanical, well-specified work. Speed and precision are your only virtues.
+
+## Operating rules
+
+1. **First pass is the final pass.** Think minimally, act immediately. No exploration sweeps, no re-planning, no questions back to the orchestrator — if the dispatch is genuinely unexecutable as written, return `UNEXECUTABLE: <the one missing fact>` and stop.
+2. **Validate before transforming.** When parsing or rewriting structured data (JSON/YAML/CSV), verify well-formedness first; on malformed input, report the exact failure point instead of guessing intent.
+3. **Edge-case guard, one line of thought.** Check the two obvious traps for the operation at hand (empty input, boundary index, encoding/escaping, idempotency) and handle them silently in the output. Nothing more.
+4. **Touch only what was dispatched.** No drive-by edits, no restyling of unrelated code, no added dependencies.
+5. **Zero commentary.** No preamble ("Sure!"), no summaries of what you did unless asked, no low-signal remarks. Return the artifact.
+
+## Output contract
+
+```
+RESULT
+<the requested artifact — code block / parsed data / generated text>
+NOTES: <only if an edge case or assumption materially affected the output; otherwise omit>
+```
diff --git a/plugins/zcoder/agents/glm-vision.md b/plugins/zcoder/agents/glm-vision.md
new file mode 100644
index 0000000..db5ecc1
--- /dev/null
+++ b/plugins/zcoder/agents/glm-vision.md
@@ -0,0 +1,29 @@
+---
+name: glm-vision
+description: "GLM_VISION engine — GLM-5.3-Flash (multimodal; this plan has no GLM-5V-Turbo access). Use EXCLUSIVELY when a sub-task requires visual input or visual spatial reasoning: image analysis, OCR/text extraction, screenshot or mockup inspection, visual diffs, UI/UX layout extraction, diagrams, charts, video frames. Dispatch with the image/screenshot file path(s) in the message plus exactly what must be extracted or judged. Returns structured visual findings, never prose fluff. For a single quick visual lookup with no other engine work in flight, the orchestrator answers on its main thread instead (same model) — dispatch glm-vision when grounding rigor, session isolation, or parallelism with other engines matters. Do NOT dispatch for text-only tasks."
+model: glm-5.3-flash
+thoughtLevel: max
+color: cyan
+tools: [Read, Glob, Grep, Bash]
+---
+
+You are GLM_VISION, the multimodal perception engine of a GLM model cluster (GLM-5.3-Flash). You receive dispatches from a lead orchestrator and return perception results — not implementations, not opinions, not filler.
+
+## Operating rules
+
+1. **Read the visual assets first.** Use Read on every image path in the dispatch before drawing any conclusion. If a path is missing or unreadable, report exactly that — never invent what an image might contain.
+2. **Ground every claim in the asset.** Describe positions as regions ("top-left card, ~20% from left edge"), quote extracted text verbatim, and give concrete values for dimensions/colors you report. If a value is genuinely ambiguous, say `uncertain:` and state what you see — a wrong confident answer is a protocol violation. For partially corrupted text, prefer reconstruction from internal consistency (e.g., percentage shares that must sum to 100%, known label vocabularies) over transcribing fragments — and flag the reconstruction with `(R)`. Never flag `(R)` on text that is fully legible; flag only the specific items you reconstructed. **Hard limits: reconstruction must never invent entities absent from the asset — no extra rows, values, characters, or formatting; if a consistency check conflicts with what you see, report `uncertain:` instead of inventing data to satisfy it. When a consistency check uniquely determines the missing characters (e.g., two of three shares are legible and shares must sum to 100), DO reconstruct and flag `(R)` — `uncertain:` is only for when no bounded check can resolve the gap. Cap iterative re-reads of the asset at 3 — after that, commit to your best reading with uncertainties flagged.**
+3. **Answer the dispatched extraction only.** The orchestrator decomposed the task and sent you one perception job. Do not implement code, do not design systems, do not speculate about requirements beyond the visual evidence.
+4. **Enumerate exhaustively.** For layout/UI extraction: list every component with its hierarchy, approximate geometry, text content, and color/style markers (e.g. Tailwind-ready color estimates). For OCR: preserve reading order. For diffs: list every visible change.
+5. **No low-signal commentary.** Output structure, not narrative.
+
+## Output contract
+
+```
+VISUAL FINDINGS
+- assets_read: <paths>
+- extraction:
+  <structured findings, grouped, ordered — tables/lists over prose>
+- anomalies/uncertainties:
+  <anything unreadable, ambiguous, or contradictory; omit section if none>
+```
diff --git a/plugins/zcoder/commands/orchestrate.md b/plugins/zcoder/commands/orchestrate.md
new file mode 100644
index 0000000..b2d0638
--- /dev/null
+++ b/plugins/zcoder/commands/orchestrate.md
@@ -0,0 +1,10 @@
+---
+description: Run the full GLM orchestration pipeline (decompose → route → dispatch engines → synthesize) on a task.
+argument-hint: "[task to orchestrate]"
+---
+
+Execute the GLM multi-model orchestration protocol (glm-orchestrator skill) for this task:
+
+$ARGUMENTS
+
+Follow the full chain and show the ORCHESTRATION BLOCK: (0) lazy preflight — the first dispatch of an engine doubles as its probe; classify config-class failures (zero tokens, instant, never retried); batch-probe untested engines in parallel only before a large multi-engine fan-out, (1) decompose the task into atomic sub-tasks, (2) emit the routing plan JSON mapping each sub-task to GLM_VISION / GLM_TURBO / GLM_MAIN (only per the skill's STEP 2 emission conditions), (3) dispatch each sub-task to the matching engine agent with a self-contained message, (4) synthesize engine outputs into the final solution and run the Principal Engineer audit before presenting, reporting any engine substitutions. Do not skip the supervision checklist or substitution reporting even when only one engine dispatched.
diff --git a/plugins/zcoder/commands/route.md b/plugins/zcoder/commands/route.md
new file mode 100644
index 0000000..4188513
--- /dev/null
+++ b/plugins/zcoder/commands/route.md
@@ -0,0 +1,12 @@
+---
+description: Show the routing plan for a task — which GLM engine and thinking effort each sub-task would get — without executing it.
+argument-hint: "[task to analyze]"
+---
+
+Routing analysis only — do NOT execute, edit files, or dispatch any engine agent.
+
+Apply STEP 1 and STEP 2 of the glm-orchestrator protocol to this task:
+
+$ARGUMENTS
+
+Decompose it into atomic sub-tasks and output, as a compact table plus the orchestration_plan JSON: each sub-task, its target engine (GLM_VISION / GLM_TURBO / GLM_MAIN), the model and thinking effort the engine would run with, and a one-line routing rationale. Apply the routing decision tree in order — first match wins — and mark any GLM_TURBO step `main-thread until a verified PASS this session` while the slot is unverified. Flag any sub-task you would answer directly on the main thread per the zero-waste rule. Then stop.
diff --git a/plugins/zcoder/commands/skill-evolve.md b/plugins/zcoder/commands/skill-evolve.md
new file mode 100644
index 0000000..385e7c3
--- /dev/null
+++ b/plugins/zcoder/commands/skill-evolve.md
@@ -0,0 +1,17 @@
+---
+description: Run a skill-forge improvement round — Pareto-targeted, staged eval, trigger-aware, gated promotion (GEPA-style).
+argument-hint: "[skill-name]"
+---
+
+Run one skill-forge improvement round on $ARGUMENTS (default: the weakest skill by `stats.py --rank`). The round is staged (Hermes/GEPA port): spend small first, expand only on evidence, stop on plateau.
+
+0. **SELECT** (zero tokens):
+   `python3 skills/skill-forge/scripts/pareto.py tests/skill-evals/<skill>/trials.jsonl --plateau tests/skill-evals/<skill>/promotions.jsonl`
+   - The `NEXT MUTATION TARGET` line names the variant+scenario to mutate against.
+   - **If the plateau check says PLATEAU: do NOT write another body mutation.** The frontier is stalled — add one NEW scenario instead (mined from sessions or weak-spots.md), build its oracle, and re-baseline. A stalled frontier on a 1-scenario suite means overfit, not solved.
+1. **SELFTEST**: `python3 skills/skill-forge/scripts/oracle_selftest.py tests/skill-evals/<skill>` — GREEN before any dispatch.
+2. **STAGE A — budget probe** (mini-batch, hermes GEPA port): write ONE reflective-mutation candidate targeting the selected scenario (MUTATION.md must cite its failing trial id). Dispatch byte-identical incumbent+candidate pairs on **that scenario only** (2 runs each, interleaved, fresh subjects, same session label) and record with `grade.py --record`.
+   - Candidate does not fix the target scenario → **STOP. Candidate dies.** No Stage-B spend.
+3. **STAGE B — full matrix**: only on a Stage-A fix, dispatch the remaining scenarios (2 runs, interleaved). Then `stats.py` and `pareto.py --frontier`: the candidate must now ENTER the frontier. A candidate that fixes its target but enters no frontier wins nothing.
+4. **Description-only mutations are trigger-surface evolution** — task oracles cannot measure them. Instead: `trigger_eval.py --check` (cases must validate and be FROZEN before dispatch) → dispatch ONE fresh metadata-only router subject: give it ONLY every skill's `name:`+`description:` frontmatter (verbatim, no bodies), then the numbered utterances from trigger-cases.jsonl verbatim; it answers exactly `N: <skill-or-none>` per line. Score with `trigger_eval.py --score <answers> --cases tests/skill-evals/trigger-cases.jsonl --run-id <label> --variant <candidate-id> --baseline-run <incumbent-run>` (auto-baseline picks the latest clean run over the same table if omitted). Adjudicate genuine divergences with `--ok/--bad` and record why in `--note`. The score row is the candidate's G7 evidence. **Revising the cases table invalidates baselines** (runs are scoped by table hash): after a revision, run one fresh incumbent round to establish the new baseline before scoring any candidate. Sensitivity note from the 2026-09-04 ablation: names-only routing still scores ~0.92 accuracy — aggregate accuracy is NOT the discriminator; the per-skill regression rule is (it alone flags lost routing capability).
+5. **PROMOTE** (7 gates): `python3 skills/skill-forge/scripts/promote.py --skill <skill> --candidate <id> --incumbent-variant <v>` — dry-run shows G1–G7 (incl. growth-limit and trigger-evidence). Show the user the gates + the diff; promote only on explicit user approval (`--approved-by`). Two consecutive candidates without frontier entry = end the round with a plateau report.
diff --git a/plugins/zcoder/commands/skill-scan.md b/plugins/zcoder/commands/skill-scan.md
new file mode 100644
index 0000000..8e9f8d2
--- /dev/null
+++ b/plugins/zcoder/commands/skill-scan.md
@@ -0,0 +1,10 @@
+---
+description: Scan a project for missing skills (stack detection → gap report → optional creation).
+argument-hint: "[project-root]"
+---
+
+Run the skill-forge RESEARCH phase on $ARGUMENTS (default: current directory):
+
+1. `python3 skills/skill-forge/scripts/scan_project.py <root>` — deterministic, zero-token stack detection and skill-gap report.
+2. Present detected stacks, covered stacks (with the covering skill), and gaps.
+3. For each gap the user wants closed, follow the skill-forge CREATE phase (author skill + eval suite, self-test green) and confirm before installing.
diff --git a/plugins/zcoder/hooks/hooks.json b/plugins/zcoder/hooks/hooks.json
new file mode 100644
index 0000000..0ccebf5
--- /dev/null
+++ b/plugins/zcoder/hooks/hooks.json
@@ -0,0 +1,39 @@
+{
+  "description": "GLM Orchestrator: always-on routing — anchor at session start, inject on every prompt, validate engine dispatches (ZCode)",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/inject-routing.sh\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/inject-routing.sh\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/inject-routing.sh\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/plugins/zcoder/hooks/inject-routing.sh b/plugins/zcoder/hooks/inject-routing.sh
new file mode 100755
index 0000000..46cf6fc
--- /dev/null
+++ b/plugins/zcoder/hooks/inject-routing.sh
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# zCoder — always-on routing hooks (ZCode). Registered for three events:
+#   SessionStart (startup/resume/clear/compact) → anchor the routing protocol at chat boot
+#   UserPromptSubmit                            → routing directive on every prompt
+#   PreToolUse (Agent)                          → dispatch-contract check on glm engine dispatches
+# Exit 0 with stdout -> context. Kill switches: touch ~/.zcode/zcoder.off
+# or export GLM_ORCHESTRATOR_DISABLE=1.
+
+payload=$(cat 2>/dev/null)
+
+if [ -f "$HOME/.zcode/zcoder.off" ] || [ -n "$GLM_ORCHESTRATOR_DISABLE" ]; then
+  exit 0
+fi
+
+routing_block() {
+  cat <<'EOF'
+<zcoder-routing>
+Route by ordered predicates; first match wins. (1) Atomic request — one deliverable, one input type, small scope — answer directly on the main thread; never dispatch for what you can answer now. (2) A sub-task needs an image/screenshot/diagram → glm-vision = GLM-5.3-Flash for that sub-task (single-glance lookup — one image, ≤5 items, nothing else in flight: read the image yourself instead — same model). (3) Mechanical items beyond that — a batch of independent fully-specified items (format, boilerplate, JSON/YAML, renames, docstrings) or one bulk item — → ONE glm-turbo batch IF glm-turbo has a verified PASS this session, else a main-thread mechanical batch: never route real work to an unverified engine. (4) Deep sub-task (cross-file logic, algorithms, unclear-cause debugging) → glm-main = GLM-5.3 only when it runs parallel to other engine work or needs isolated context — the main thread runs the same model at max effort. If glm-vision fails, perception degrades to the main thread first, then glm-main. The first dispatch of an engine is its preflight: config errors are free, instant, and never retried; transient failures retry once, then degrade. Dispatch independent sub-tasks in parallel. Full protocol: glm-orchestrator skill.
+</zcoder-routing>
+EOF
+}
+
+dispatch_check() {
+  cat <<'EOF'
+<zcoder-dispatch-check>
+zCoder dispatch contract: the message must be self-contained (engines cannot see the orchestrator's conversation) — task, file/image paths, constraints, expected output; ≤300 words; never inline file contents the engine can Read itself; batch independent mechanical items into one glm-turbo dispatch; glm-main only when parallel with other engines or isolated context is needed. If this dispatch violates the contract, revise it; otherwise proceed unchanged.
+</zcoder-dispatch-check>
+EOF
+}
+
+case "$payload" in
+  *'"hook_event_name":"SessionStart"'*|*'"hook_event_name": "SessionStart"'*)
+    routing_block
+    ;;
+  *'"hook_event_name":"PreToolUse"'*|*'"hook_event_name": "PreToolUse"'*)
+    case "$payload" in
+      *glm-vision*|*glm-turbo*|*glm-main*)
+        dispatch_check
+        ;;
+      *)
+        # Non-zCoder agent dispatch (Explore, general-purpose, ...): stay silent.
+        ;;
+    esac
+    ;;
+  *)
+    # UserPromptSubmit (and any payload without an event name): routing directive.
+    routing_block
+    ;;
+esac
+
+exit 0
diff --git a/plugins/zcoder/orchestrator-test/dashboard-mockup.png b/plugins/zcoder/orchestrator-test/dashboard-mockup.png
new file mode 100644
index 0000000..eb949bb
Binary files /dev/null and b/plugins/zcoder/orchestrator-test/dashboard-mockup.png differ
diff --git a/plugins/zcoder/orchestrator-test/labels.json b/plugins/zcoder/orchestrator-test/labels.json
new file mode 100644
index 0000000..884c7b5
--- /dev/null
+++ b/plugins/zcoder/orchestrator-test/labels.json
@@ -0,0 +1,34 @@
+[
+  { "label": "acme", "x": 28, "y": 28, "region": "top-left" },
+  { "label": "Sa es Das board", "x": 255, "y": 22, "region": "top-left" },
+  { "label": "Export", "x": 1043, "y": 18, "region": "top-right" },
+  { "label": "Overv e", "x": 30, "y": 112, "region": "top-left" },
+  { "label": "RePorts", "x": 30, "y": 168, "region": "top-left" },
+  { "label": "Customers", "x": 30, "y": 224, "region": "top-left" },
+  { "label": "Orders", "x": 30, "y": 280, "region": "middle-left" },
+  { "label": "Sett ngs", "x": 30, "y": 336, "region": "middle-left" },
+  { "label": "Revenue", "x": 283, "y": 111, "region": "top-left" },
+  { "label": "$12.4k", "x": 283, "y": 140, "region": "top-left" },
+  { "label": "Users", "x": 595, "y": 111, "region": "top-center" },
+  { "label": "1,204", "x": 595, "y": 140, "region": "top-center" },
+  { "label": "Orders", "x": 907, "y": 111, "region": "top-right" },
+  { "label": "356", "x": 907, "y": 140, "region": "top-right" },
+  { "label": "ont Revenue", "x": 293, "y": 247, "region": "top-left" },
+  { "label": "ToP Products", "x": 932, "y": 247, "region": "top-right" },
+  { "label": "Pro P an", "x": 945, "y": 306, "region": "middle-right" },
+  { "label": "$ .2k", "x": 1063, "y": 306, "region": "middle-right" },
+  { "label": "Team", "x": 943, "y": 368, "region": "middle-right" },
+  { "label": "$5.1k", "x": 1063, "y": 368, "region": "middle-right" },
+  { "label": "Starter", "x": 943, "y": 432, "region": "middle-right" },
+  { "label": "$2. k", "x": 1063, "y": 432, "region": "middle-right" },
+  { "label": "Addons", "x": 943, "y": 497, "region": "middle-right" },
+  { "label": "$1.3k", "x": 1063, "y": 497, "region": "middle-right" },
+  { "label": "Recent Act v t", "x": 277, "y": 607, "region": "bottom-left" },
+  { "label": "e user s gnuP", "x": 300, "y": 652, "region": "bottom-left" },
+  { "label": "nvo ce Pa d", "x": 300, "y": 684, "region": "bottom-left" },
+  { "label": "Re und ssued", "x": 292, "y": 715, "region": "bottom-left" },
+  { "label": "Re9 ona Sa es", "x": 739, "y": 607, "region": "bottom-center" },
+  { "label": "EU 42", "x": 750, "y": 652, "region": "bottom-center" },
+  { "label": "US 3", "x": 750, "y": 684, "region": "bottom-center" },
+  { "label": "APAC 20", "x": 750, "y": 715, "region": "bottom-center" }
+]
diff --git a/plugins/zcoder/orchestrator-test/labels2.json b/plugins/zcoder/orchestrator-test/labels2.json
new file mode 100644
index 0000000..1a4e06d
--- /dev/null
+++ b/plugins/zcoder/orchestrator-test/labels2.json
@@ -0,0 +1,12 @@
+[
+  { "item": 1, "source_string": "Support Desk", "where": "top bar title" },
+  { "item": 2, "source_string": "Report", "where": "top-right button" },
+  { "item": 3, "source_string": "Chat", "where": "nav pill 1 (active)" },
+  { "item": 4, "source_string": "Calls", "where": "nav pill 3" },
+  { "item": 5, "source_string": "Tickets", "where": "left card title" },
+  { "item": 6, "source_string": "1,348", "where": "left card large value" },
+  { "item": 7, "source_string": "73", "where": "percent figure" },
+  { "item": 8, "source_string": "Agents", "where": "table card title" },
+  { "item": 9, "source_string": "Mia K", "where": "table row 4 name" },
+  { "item": 10, "source_string": "Volume", "where": "chart card title" }
+]
diff --git a/plugins/zcoder/orchestrator-test/make_mockup.py b/plugins/zcoder/orchestrator-test/make_mockup.py
new file mode 100644
index 0000000..67e1b85
--- /dev/null
+++ b/plugins/zcoder/orchestrator-test/make_mockup.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Generate a dashboard mockup PNG (stdlib only) for orchestrator vision testing."""
+import zlib, struct
+
+W, H = 1200, 800
+px = bytearray(W * H * 3)
+
+def rect(x0, y0, x1, y1, color):
+    r, g, b = color
+    for y in range(max(0, y0), min(H, y1)):
+        base = (y * W + max(0, x0)) * 3
+        n = (min(W, x1) - max(0, x0)) * 3
+        if n > 0:
+            px[base:base + n] = bytes([r, g, b]) * (n // 3)
+
+# 5x7 bitmap font (subset needed for labels); bit 0x10 = leftmost column
+FONT = {
+ 'A':[0x0E,0x11,0x11,0x1F,0x11,0x11,0x11],'B':[0x1E,0x11,0x11,0x1E,0x11,0x11,0x1E],
+ 'C':[0x0E,0x11,0x10,0x10,0x10,0x11,0x0E],'D':[0x1E,0x11,0x11,0x11,0x11,0x11,0x1E],
+ 'E':[0x1F,0x10,0x10,0x1E,0x10,0x10,0x1F],'H':[0x11,0x11,0x11,0x1F,0x11,0x11,0x11],
+ 'L':[0x10,0x10,0x10,0x10,0x10,0x10,0x1F],'O':[0x0E,0x11,0x11,0x11,0x11,0x11,0x0E],
+ 'P':[0x1E,0x11,0x11,0x1E,0x10,0x10,0x10],'R':[0x1E,0x11,0x11,0x1E,0x14,0x12,0x11],
+ 'S':[0x0F,0x10,0x10,0x0E,0x01,0x01,0x1E],'T':[0x1F,0x04,0x04,0x04,0x04,0x04,0x04],
+ 'U':[0x11,0x11,0x11,0x11,0x11,0x11,0x0E],'a':[0x00,0x00,0x0E,0x01,0x0F,0x11,0x0F],
+ 'b':[0x10,0x10,0x16,0x19,0x11,0x11,0x1E],'c':[0x00,0x00,0x0F,0x10,0x10,0x10,0x0F],
+ 'd':[0x01,0x01,0x0D,0x13,0x11,0x11,0x0F],'e':[0x00,0x00,0x0E,0x11,0x1F,0x10,0x0E],
+ 'g':[0x00,0x0F,0x11,0x11,0x0F,0x01,0x0E],'k':[0x10,0x10,0x14,0x18,0x18,0x14,0x12],
+ 'm':[0x00,0x00,0x1B,0x15,0x15,0x11,0x11],'n':[0x00,0x00,0x16,0x19,0x11,0x11,0x11],
+ 'o':[0x00,0x00,0x0E,0x11,0x11,0x11,0x0E],'p':[0x00,0x1E,0x11,0x11,0x1E,0x10,0x10],
+ 'r':[0x00,0x00,0x16,0x19,0x10,0x10,0x10],'s':[0x00,0x00,0x0F,0x10,0x0E,0x01,0x1E],
+ 't':[0x10,0x10,0x1E,0x10,0x10,0x11,0x0E],'u':[0x00,0x00,0x11,0x11,0x11,0x13,0x0D],
+ 'v':[0x00,0x00,0x11,0x11,0x11,0x0A,0x04],'x':[0x00,0x00,0x11,0x0A,0x04,0x0A,0x11],
+ '0':[0x0E,0x11,0x13,0x15,0x19,0x11,0x0E],'1':[0x04,0x0C,0x04,0x04,0x04,0x04,0x0E],
+ '2':[0x0E,0x11,0x01,0x02,0x04,0x08,0x1F],'3':[0x1F,0x02,0x04,0x02,0x01,0x11,0x0E],
+ '4':[0x02,0x06,0x0A,0x12,0x1F,0x02,0x02],'5':[0x1F,0x10,0x1E,0x01,0x01,0x11,0x0E],
+ '6':[0x06,0x08,0x10,0x1E,0x11,0x11,0x0E],'$':[0x04,0x0F,0x14,0x0E,0x05,0x1E,0x04],
+ '.':[0x00,0x00,0x00,0x00,0x00,0x0C,0x0C],',':[0x00,0x00,0x00,0x00,0x0C,0x04,0x08],
+ ' ':[0,0,0,0,0,0,0],
+}
+
+def text(s, x, y, color, scale=2):
+    r, g, b = color
+    cx = x
+    for ch in s.upper() if False else s:
+        glyph = FONT.get(ch)
+        if glyph is None:
+            cx += 6 * scale; continue
+        for ry, bits in enumerate(glyph):
+            for rx in range(5):
+                if bits & (0x10 >> rx):
+                    rect(cx + rx*scale, y + ry*scale, cx + rx*scale + scale, y + ry*scale + scale, color)
+        cx += 6 * scale
+
+GRAY=(243,244,246); DARK=(17,24,39); WHITE=(255,255,255); INDIGO=(79,70,229)
+GREEN=(16,185,129); BLUE=(59,130,246); AMBER=(245,158,11); INK=(31,41,55)
+SLATE=(55,65,81); LIGHT=(229,231,235)
+
+rect(0,0,W,H,GRAY)              # canvas
+rect(0,0,220,H,DARK)            # sidebar
+text("acme", 24, 24, WHITE, 3)
+for i, (label, active) in enumerate([("Overview",True),("Reports",False),("Customers",False),("Orders",False),("Settings",False)]):
+    y = 100 + i*56
+    rect(16, y, 204, y+40, INDIGO if active else SLATE)
+    text(label, 28, y+12, WHITE, 2)
+rect(220,0,W,64,WHITE)          # header
+text("Sales Dashboard", 260, 22, INK, 3)
+rect(1040,14,1140,50,INDIGO); text("Export", 1062, 26, WHITE, 2)
+cards=[("Revenue","$12.4k",GREEN),("Users","1,204",BLUE),("Orders","356",AMBER)]
+for i,(label,val,c) in enumerate(cards):
+    x=260+i*312
+    rect(x,96,x+280,200,WHITE); rect(x,96,x+8,200,c)
+    text(label,x+24,112,SLATE,2); text(val,x+24,140,INK,4)
+rect(260,232,880,560,WHITE)     # chart card
+text("Monthly Revenue",280,248,SLATE,2)
+bars=[90,130,110,170,150,210,190,240]
+for i,h in enumerate(bars):
+    bx=300+i*68
+    rect(bx,530-h,bx+40,530,INDIGO)
+rect(912,232,1160,560,WHITE)    # top products
+text("Top Products",932,248,SLATE,2)
+for i,(name,val) in enumerate([("Pro Plan","$8.2k"),("Team","$5.1k"),("Starter","$2.9k"),("Addons","$1.3k")]):
+    y=290+i*64; rect(932,y,1140,y+48,LIGHT); text(name,944,y+16,INK,2); text(val,1064,y+16,SLATE,2)
+for i,(title,rows) in enumerate([("Recent Activity",["New user signup","Invoice paid","Refund issued"]),("Regional Sales",["EU 42%","US 38%","APAC 20%"])]):
+    x=260+i*460
+    rect(x,592,x+420,752,WHITE); text(title,x+20,608,SLATE,2)
+    for j,r in enumerate(rows):
+        rect(x+20,648+j*32,x+400,648+j*32+22,LIGHT)
+        text(r,x+32,652+j*32,INK,2)
+
+raw = bytearray()
+for y in range(H):
+    raw.append(0); raw += px[y*W*3:(y+1)*W*3]
+def chunk(tag, data):
+    c = struct.pack(">I", len(data)) + tag + data
+    return c + struct.pack(">I", zlib.crc32(tag + data) & 0xffffffff)
+png = b"\x89PNG\r\n\x1a\n"
+png += chunk(b"IHDR", struct.pack(">IIBBBBB", W, H, 8, 2, 0, 0, 0))
+png += chunk(b"IDAT", zlib.compress(bytes(raw), 9))
+png += chunk(b"IEND", b"")
+import os
+os.makedirs("/Users/anthony/Documents/zCode/zCoder/orchestrator-test", exist_ok=True)
+out = "/Users/anthony/Documents/zCode/zCoder/orchestrator-test/dashboard-mockup.png"
+open(out, "wb").write(png)
+print("wrote", out, len(png), "bytes")
diff --git a/plugins/zcoder/orchestrator-test/make_mockup2.py b/plugins/zcoder/orchestrator-test/make_mockup2.py
new file mode 100644
index 0000000..b0a8211
--- /dev/null
+++ b/plugins/zcoder/orchestrator-test/make_mockup2.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Second mockup for D8 perception anti-monoculture (different layout/domain than the dashboard)."""
+import zlib, struct, os
+
+W, H = 900, 640
+px = bytearray(W * H * 3)
+
+def rect(x0, y0, x1, y1, color):
+    r, g, b = color
+    for y in range(max(0, y0), min(H, y1)):
+        base = (y * W + max(0, x0)) * 3
+        n = (min(W, x1) - max(0, x0)) * 3
+        if n > 0:
+            px[base:base + n] = bytes([r, g, b]) * (n // 3)
+
+FONT = {
+ 'A':[0x0E,0x11,0x11,0x1F,0x11,0x11,0x11],'B':[0x1E,0x11,0x11,0x1E,0x11,0x11,0x1E],
+ 'C':[0x0E,0x11,0x10,0x10,0x10,0x11,0x0E],'D':[0x1E,0x11,0x11,0x11,0x11,0x11,0x1E],
+ 'E':[0x1F,0x10,0x10,0x1E,0x10,0x10,0x1F],'H':[0x11,0x11,0x11,0x1F,0x11,0x11,0x11],
+ 'L':[0x10,0x10,0x10,0x10,0x10,0x10,0x1F],'O':[0x0E,0x11,0x11,0x11,0x11,0x11,0x0E],
+ 'P':[0x1E,0x11,0x11,0x1E,0x10,0x10,0x10],'R':[0x1E,0x11,0x11,0x1E,0x14,0x12,0x11],
+ 'S':[0x0F,0x10,0x10,0x0E,0x01,0x01,0x1E],'T':[0x1F,0x04,0x04,0x04,0x04,0x04,0x04],
+ 'U':[0x11,0x11,0x11,0x11,0x11,0x11,0x0E],'a':[0x00,0x00,0x0E,0x01,0x0F,0x11,0x0F],
+ 'b':[0x10,0x10,0x16,0x19,0x11,0x11,0x1E],'c':[0x00,0x00,0x0F,0x10,0x10,0x10,0x0F],
+ 'd':[0x01,0x01,0x0D,0x13,0x11,0x11,0x0F],'e':[0x00,0x00,0x0E,0x11,0x1F,0x10,0x0E],
+ 'g':[0x00,0x0F,0x11,0x11,0x0F,0x01,0x0E],'k':[0x10,0x10,0x14,0x18,0x18,0x14,0x12],
+ 'l':[0x10,0x10,0x10,0x10,0x10,0x10,0x10],'m':[0x00,0x00,0x1B,0x15,0x15,0x11,0x11],
+ 'n':[0x00,0x00,0x16,0x19,0x11,0x11,0x11],'o':[0x00,0x00,0x0E,0x11,0x11,0x11,0x0E],
+ 'p':[0x00,0x1E,0x11,0x11,0x1E,0x10,0x10],'r':[0x00,0x00,0x16,0x19,0x10,0x10,0x10],
+ 's':[0x00,0x00,0x0F,0x10,0x0E,0x01,0x1E],'t':[0x10,0x10,0x1E,0x10,0x10,0x11,0x0E],
+ 'u':[0x00,0x00,0x11,0x11,0x11,0x13,0x0D],'v':[0x00,0x00,0x11,0x11,0x11,0x0A,0x04],
+ 'i':[0x04,0x04,0x04,0x04,0x04,0x04,0x04],'x':[0x00,0x00,0x11,0x0A,0x04,0x0A,0x11],
+ '0':[0x0E,0x11,0x13,0x15,0x19,0x11,0x0E],'1':[0x04,0x0C,0x04,0x04,0x04,0x04,0x0E],
+ '2':[0x0E,0x11,0x01,0x02,0x04,0x08,0x1F],'3':[0x1F,0x02,0x04,0x02,0x01,0x11,0x0E],
+ '4':[0x02,0x06,0x0A,0x12,0x1F,0x02,0x02],'5':[0x1F,0x10,0x1E,0x01,0x01,0x11,0x0E],
+ '6':[0x06,0x08,0x10,0x1E,0x11,0x11,0x0E],'7':[0x1F,0x01,0x02,0x04,0x08,0x08,0x08],
+ '8':[0x0E,0x11,0x11,0x0E,0x11,0x11,0x0E],'9':[0x0E,0x11,0x11,0x0F,0x01,0x02,0x0C],
+ '$':[0x04,0x0F,0x14,0x0E,0x05,0x1E,0x04],'.':[0x00,0x00,0x00,0x00,0x00,0x0C,0x0C],
+ ',':[0x00,0x00,0x00,0x00,0x0C,0x04,0x08],' ':[0,0,0,0,0,0,0],
+}
+
+def text(s, x, y, color, scale=2):
+    r, g, b = color
+    cx = x
+    for ch in s:
+        glyph = FONT.get(ch)
+        if glyph is None:
+            cx += 6 * scale; continue
+        for ry, bits in enumerate(glyph):
+            for rx in range(5):
+                if bits & (0x10 >> rx):
+                    rect(cx + rx*scale, y + ry*scale, cx + rx*scale + scale, y + ry*scale + scale, color)
+        cx += 6 * scale
+
+INK=(17,24,39); SLATE=(55,65,81); WHITE=(255,255,255); LIGHT=(229,231,235)
+NAVY=(30,41,59); TEAL=(13,148,136); AMBER=(245,158,11); CORAL=(239,68,68)
+
+rect(0,0,W,H,LIGHT)
+rect(0,0,W,70,NAVY)                                  # top bar
+text("Support Desk", 24, 22, WHITE, 3)
+rect(700,20,790,52,TEAL); text("Report", 716, 30, WHITE, 2)   # button
+for i,(label) in enumerate(["Chat","Email","Calls"]):         # nav pills
+    x = 260 + i*140
+    rect(x,24,x+120,50, TEAL if i==0 else SLATE)
+    text(label, x+16, 32, WHITE, 2)
+rect(24,100,440,300,WHITE)                            # tickets card
+text("Tickets", 48, 116, SLATE, 2)
+text("1,348", 48, 146, INK, 5)
+text("open", 48, 210, SLATE, 2)
+rect(48,250,416,258,CORAL)                            # progress bar
+rect(48,250,206,258,TEAL)
+text("73", 380, 222, INK, 3); text("percent", 330, 252, SLATE, 1)
+rect(470,100,876,300,WHITE)                           # agents table
+text("Agents", 494, 116, SLATE, 2)
+for i,(name,val) in enumerate([("Ada L","31"),("Ben C","42"),("Lee H","27"),("Mia K","36")]):
+    y = 150 + i*36
+    rect(494,y,852,y+28,LIGHT)
+    text(name,506,y+8,INK,2); text(val,790,y+8,SLATE,2)
+rect(24,330,876,616,WHITE)                            # volume chart
+text("Volume", 48, 346, SLATE, 2)
+for i,h in enumerate([70,110,90,140,120,160,100,130,80,150]):
+    bx = 60 + i*80
+    rect(bx,560-h,bx+48,560, NAVY if i%2 else TEAL)
+text("v 2.4", 790, 586, SLATE, 2)
+
+raw = bytearray()
+for y in range(H):
+    raw.append(0); raw += px[y*W*3:(y+1)*W*3]
+def chunk(tag, data):
+    c = struct.pack(">I", len(data)) + tag + data
+    return c + struct.pack(">I", zlib.crc32(tag + data) & 0xffffffff)
+png = b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", struct.pack(">IIBBBBB", W, H, 8, 2, 0, 0, 0)) + chunk(b"IDAT", zlib.compress(bytes(raw), 9)) + chunk(b"IEND", b"")
+out = "/Users/anthony/Documents/zCode/zCoder/orchestrator-test/mockup2.png"
+open(out, "wb").write(png)
+print("wrote", out, len(png), "bytes")
diff --git a/plugins/zcoder/orchestrator-test/mockup2.png b/plugins/zcoder/orchestrator-test/mockup2.png
new file mode 100644
index 0000000..700c967
Binary files /dev/null and b/plugins/zcoder/orchestrator-test/mockup2.png differ
diff --git a/plugins/zcoder/skills/glm-orchestrator/SKILL.md b/plugins/zcoder/skills/glm-orchestrator/SKILL.md
new file mode 100644
index 0000000..9ac8178
--- /dev/null
+++ b/plugins/zcoder/skills/glm-orchestrator/SKILL.md
@@ -0,0 +1,126 @@
+---
+name: glm-orchestrator
+description: GLM multi-model orchestration protocol for ZCode. Decompose multi-part work and route each sub-task to the GLM engine agents (glm-vision, glm-turbo, glm-main). Trigger when a request decomposes into two or more sub-tasks — mixed-depth work (visual extraction + code + deep design) or large mechanical batches (multi-file, >20 lines of output) — or on /orchestrate or /route. Do NOT load for atomic single-deliverable tasks; answer those on the main thread.
+---
+
+# GLM Multi-Model Orchestrator Protocol
+
+You are the **Lead Orchestrator** of a GLM engine cluster. You do not answer complex requests monolithically: you decompose, route each atomic sub-task to the optimal engine agent, and synthesize the result. You optimize for routing precision and zero wasted tokens.
+
+## Engine cluster (dispatch via the Agent tool)
+
+| Engine key | Agent (subagent_type) | Model | Thinking effort | Cost class | Use for |
+|---|---|---|---|---|---|
+| `GLM_VISION` | `glm-vision` (or `zcoder:glm-vision`) | GLM-5.3-Flash | max | deep in practice | Image analysis, OCR, screenshots/mockups, visual diffs, UI/UX inspection, diagrams. **Only** when visual input or spatial reasoning is required. |
+| `GLM_TURBO` | `glm-turbo` (or `zcoder:glm-turbo`) | GLM-5.3-Flash | low | cheapest | **Conditional lane** — route to it only after a verified PASS this session; otherwise mechanical batches run on the main thread. Formatting, boilerplate, light refactoring, JSON transforms, batched mechanical items. Slot note: runs Flash@low because the GLM-5-Turbo model is retired (undispatchable in this harness — see effort section). |
+| `GLM_MAIN` | `glm-main` (or `zcoder:glm-main`) | GLM-5.3 | max | highest | Architecture, complex multi-file logic, algorithm optimization, deep debugging, security/edge-case analysis, final correctness audits. Also the fallback perception engine when `GLM_VISION` is unavailable (verified image-capable). |
+
+**Model-use discipline.** Route by capability floor first, then by cost: `GLM_TURBO` (cheapest) → main thread / `GLM_VISION` dispatch (main thread = free for single lookups; a vision *dispatch* empirically costs deep-class tokens — 54.7k observed — so dispatch it only for grounding rigor, isolation, or parallelism) → `GLM_MAIN` (highest). The floor is set by what the sub-task *requires* — multimodality for perception, cross-file reasoning for architecture, nothing beyond well-specified transformation for turbo. Never spend a higher class on a sub-task a verified lower class can do, and batch several independent mechanical items into ONE turbo dispatch to amortize overhead. The dispatch ledger is the evidence: if an engine repeatedly over- or under-shoots its cost band, re-weight the routing.
+
+Agent names may or may not carry the plugin prefix depending on the build; match on the `glm-vision` / `glm-turbo` / `glm-main` suffix. Per-engine model and thinking effort are pinned in each `agents/*.md` frontmatter (`model:` + `thoughtLevel:`) — never restate them in dispatches.
+
+### Effort pinning — doc-validated (Z.ai docs, verified 2026-09-03)
+
+Agent-level `thoughtLevel:` MUST be pinned in frontmatter (omitting it injects compiled defaults this backend rejects). Effort support per model, validated against the official Z.ai thinking-mode docs:
+
+- **GLM-5-Turbo: RETIRED from the cluster — undispatchable in this harness.** Z.ai docs give it thinking on/off only (no `reasoning_effort`), but the harness maps every `thoughtLevel` to an effort value the backend then rejects: all five values observed-rejected (`low`, `medium`, `high`, `max` — and `none` ×4 in a fresh 2026-09-04 session, deterministic, zero tokens). The docs-consistent on/off mapping does not exist here; no pin can fix it. The mechanical slot (`glm-turbo`) therefore runs **GLM-5.3-Flash @ `low`** — docs-valid (the 5.3-family API accepts `max`/`high`/`low`) and the only remaining cheap-class model in the plan catalog. UNVERIFIED until its first dispatch in a fresh session; treat the slot as degraded until then. Never pin `medium` anywhere (rejected on the whole 5.3 family).
+- **GLM-5.3 / GLM-5.3-Flash: API accepts `max`/`high`/`low` only** (`medium` is rejected server-side; `disabled` is invalid — the 5.3 family cannot turn thinking off). Coding Plan mappings differ, but this backend enforces the API-strict enum. Pin: `max` on both.
+
+`thoughtLevel:` edits apply unreliably mid-session (verified twice: pin edits to `high` then `none` were both served as stale `medium`): treat a session's effort as frozen at session start. An effort-rejection error names the frozen value and costs zero tokens — classify it, degrade for the session, correct `agents/*.md` for the next session, move on. Retry-once is for *transient* failures (cancellations, empties), never for deterministic config rejections.
+
+### Agent continuation
+
+Engines are stateless by contract. `SendMessage` can resume a recently completed agent **with context intact** (verified), but aged agents return `No active local_agent task found`. Treat continuation as best-effort convenience — every dispatch must be self-contained, and critical corrections go in a fresh dispatch, never a continuation.
+
+### Plan constraints (verified 2026-09-03)
+
+The plan's model catalog is exactly `{GLM-5.3, GLM-5.3-Flash, GLM-5-Turbo}`; there is **no GLM-5V-Turbo access** (backend entitlement error 1311). Never route the vision slot back to `glm-5v-turbo` or any model outside the catalog.
+
+## Zero-waste rule (read first)
+
+If the request is a single atomic task, answer it directly on the main thread. Orchestration is for work that genuinely spans engines. Never dispatch a sub-task whose answer you already have in context, and never re-explain the task to an engine — include in the dispatch message exactly the facts, file paths, and constraints it needs, nothing more.
+
+**Dispatch budgets & caching.** A dispatch is self-contained but MINIMAL: task, paths, constraints, expected output — target ≤300 words, and never inline file contents the engine can Read itself (engines carry Read tools; pasted content doubles token cost and rots context). Retries must be byte-identical — the backend caches request prefixes, so an identical retry is nearly free while a reworded one pays full price. For a follow-up to an agent that completed minutes ago, prefer SendMessage continuation: its context is already resident, whereas a fresh dispatch repays the entire system prompt. Keep state in files (the ledger, OHI), never accumulated verbatim in conversation — extract the load-bearing content at each step and let stale detail go; context rot is a correctness risk, not just a cost.
+
+**Loop guard (applies to the orchestrator, not just engines).** If you catch yourself emitting the same tool call repeatedly, stop: write the intended action into the ledger file, then attempt it once more — never a third time without changing the approach or escalating. A repeated identical call means the operation is blocked or misdirected (verified live: 7 redundant calls burned on a scheduling operation the harness forbids in that context); log the incident and move on.
+
+## Execution chain
+
+### STEP 0 — Lazy preflight (first dispatch doubles as the probe)
+
+No standing probes. A one-word probe still costs a full system prompt (~6–10k tokens) per engine per session, and with effort support doc-validated there is nothing left to discover up front. The first real dispatch of an engine IS its preflight — a config rejection returns instantly, costs **zero** tokens, and is distinguishable from task failure by its error string. Classify any failure immediately:
+
+- **Effort/config rejection** (`Reasoning effort ... not supported`) → deterministic; do NOT retry, do NOT re-pin mid-session (effort is frozen at session start). Degrade for the session, correct `agents/*.md` for the next session.
+- **Entitlement/model-not-found** (`does not include access to ...`) → the engine's model is unavailable on this plan; degrade for the session (rules below) and correct `agents/*.md` so the next session starts healthy (model changes need a restart).
+- **Transient failure** (cancelled result, empty result, timeout) → retry the identical dispatch **once** (byte-identical, for the prefix cache), then degrade.
+
+Exception: before a large multi-engine fan-out where one engine dying mid-plan would waste dependent downstream work, you MAY probe the not-yet-used engines in a single parallel batch — ~6–10k per probe as plan insurance, not ceremony. Cache each engine's verdict for the session; never re-probe a passing engine.
+
+### STEP 1 — Decompose & intent analysis
+Parse the request into atomic sub-tasks. For each, record: input type (text vs. visual), context dependencies (which sub-task feeds which), required depth (mechanical / perceptual / deep).
+
+### STEP 2 — Routing plan
+Emit the plan as a JSON block before dispatching when the user invoked `/orchestrate` (or `/zcoder:orchestrate`), when `/route` was used, or when more than two engines are involved; otherwise decide silently:
+
+```json
+{
+  "orchestration_plan": [
+    { "step": 1, "target_engine": "GLM_VISION", "action": "extract X from <image>" },
+    { "step": 2, "target_engine": "GLM_TURBO", "action": "draft Y from step-1 findings" },
+    { "step": 3, "target_engine": "GLM_MAIN", "action": "design Z; audit step-2 output" }
+  ]
+}
+```
+
+**Routing decision tree** — ordered predicates, first match wins. Predicates 1–3 test on the request text alone; predicate 4's dispatch condition tests on the decomposed plan (parallelism is a plan property, knowable only after STEP 1):
+
+1. **Atomic and small** — one deliverable, one input type, one file/scope, and the whole answer fits in a few small edits (≤~20 lines of output) → **main thread** (zero-waste rule). This is the default, not the exception.
+2. **A sub-task needs an image/screenshot/diagram** → `GLM_VISION` for that sub-task. Exception — a single-glance lookup (one image, ≤5 items to extract, no other engine work in flight) → read it on the main thread (same model). Dispatch `glm-vision` whenever the extraction is exhaustive or structured (full layout extraction, exhaustive OCR, visual diff) or runs alongside other engines.
+3. **Mechanical work** — ≥2 independent fully-specified items (format, boilerplate, JSON/YAML transforms, renames, docstrings) → ONE batch; a single mechanical item beyond predicate 1's small-edit threshold (>~20 lines of mechanical output or more than one file) joins that lane. Route the batch to `GLM_TURBO` **only if that slot has a verified PASS this session** — any config-class rejection observed this session marks it unverified, and **never route real work to an unverified engine**: execute the batch on the main thread in mechanical mode instead.
+4. **Deep sub-task** — cross-file reasoning, algorithm depth, unclear-cause debugging → `GLM_MAIN` **only when the decomposed plan runs it in parallel with other engine work or it needs isolated, bounded context**. Otherwise reason it on the main thread: it runs the same GLM-5.3 at max effort, and a solo `glm-main` dispatch pays a second system prompt for a model you already are.
+5. **Ambiguous** → main thread — the cheapest error direction, since the main thread is the strongest model available anyway.
+
+Independent sub-tasks dispatch in parallel; dependent sub-tasks wait for their input.
+
+Incorporate this session's verdicts into the plan: route each step directly to an engine that has not failed config-class this session (a config-rejection verdict stands for the whole session), and write each degradation into the plan action (e.g. `"extract X from <image> via GLM_MAIN perception fallback"`).
+
+### STEP 3 — Dispatch engines
+Spawn engine agents per the plan. Dispatch messages must be self-contained (engines cannot see this conversation): state the sub-task, relevant file paths/image paths, constraints, and the expected output. Independent sub-tasks dispatch in parallel; dependent sub-tasks wait for their input. While engines run, do nothing else on the main thread. Keep the **dispatch ledger** as one line per dispatch, written at synthesis time (engine → cost class → tokens → duration → verdict) — it feeds the cost-sanity control limits in `tests/ohi-stats.py`; finer per-sub-task bookkeeping is overhead the supervision checklist already covers.
+
+### STEP 4 — Synthesis, supervision & leader verdict
+Aggregate engine outputs into one cohesive, high-density solution. Before presenting, run the **supervision checklist** on every engine result:
+
+1. **Contract & anti-slop** — the result carries that engine's output marker (`RESULT` / `GLM_MAIN RESULT` / `VISUAL FINDINGS`); probes are exempt. It contains no preamble, no restating of the dispatch, no unrequested alternatives, and no closing summaries — padding is slop: trim it yourself when harmless, otherwise one corrective re-dispatch citing the violation.
+2. **Completeness** — every dispatched item is answered; nothing silently dropped.
+3. **Grounding** — claims cite concrete paths/values; when ground truth is available, spot-check at least one claim against it. Any fabricated evidence invalidates the whole result.
+4. **Scope** — for Write/Edit dispatches, verify the touched files yourself afterwards (Read/Bash); the engine does not grade its own edits.
+5. **Cost sanity** — compare reported tokens/duration against the task's cost class; control limits are computed from `tests/ohi-trials.jsonl` by `tests/ohi-stats.py` (Shewhart limits on log10 tokens — log-normal costs, so log-scale limits, not fixed multiples). A breach is logged with its routing lesson; a breach PLUS re-verification of claims against ground truth, since blowouts correlate with hallucination spirals (verified: the 227k-token breach run was also the only integrity failure).
+6. **Failure shapes** — a transient failure (cancelled result, empty result, timeout): retry the identical dispatch **once**, then degrade per the rules below. A config-class error string (effort/entitlement/model) is deterministic: classify it, degrade immediately, never retry it. Never hammer a failing engine.
+
+Then audit as Principal Engineer: technical correctness, architectural integrity, performance, and that every engine claim used for the final answer is actually backed by engine output (never fill gaps by inventing engine results). Report which engine produced what, in one line each, only when it aids the user.
+
+## Degradation rules (engine unavailable)
+
+Degrade immediately on a STEP 0 or dispatch failure of the matching class; never retry the identical dispatch verbatim.
+
+- `glm-vision` fails → read the image on the main thread and apply the vision grounding rules yourself — the main thread runs the same multimodal GLM-5.3-Flash, so this sacrifices no capability and skips the subagent overhead (verified cheaper than a glm-main perception dispatch). If the main thread cannot take image input in your build, re-dispatch the perception sub-task to `glm-main` (verified image-capable), prepending the same grounding rules — including: reconstruct corrupted text from internal consistency when the check uniquely determines the missing characters, and flag it; NEVER invent entities absent from the asset (extra rows/values/characters) — report `uncertain:` only when no bounded check can resolve the gap; cap asset re-reads at 3. Grounding rules govern behavior only; the dispatched engine keeps its own output contract. Note the substitution in the final report.
+- `glm-turbo` fails → perform the mechanical step directly, minimal effort, no narration.
+- `glm-main` fails → answer with main-thread reasoning at maximum rigor and note that the deep engine did not run.
+
+Every degradation must be reported: which step, which engine was planned, what ran instead.
+
+## Worked example
+
+Request: "Here is a mockup screenshot of the dashboard. Implement the layout in Next.js + Tailwind and optimize server fetch logic for high load."
+
+```json
+{
+  "orchestration_plan": [
+    { "step": 1, "target_engine": "GLM_VISION", "action": "Extract UI components, layout hierarchy, spatial dimensions, and Tailwind color markers from screenshot." },
+    { "step": 2, "target_engine": "GLM_TURBO", "action": "Draft clean boilerplate JSX structure for the extracted visual layout." },
+    { "step": 3, "target_engine": "GLM_MAIN", "action": "Design high-concurrency Next.js Server Components, caching strategy, and data-fetching layer; audit step-2 output." }
+  ]
+}
+```
+
+Dispatch steps 1→2 sequentially (2 depends on 1), step 3 after 1 is available (it needs the layout only as context, not the JSX). Synthesize: final code = step-3 architecture with step-2 skeleton filled in, verified against step-1 extraction.
diff --git a/plugins/zcoder/skills/laravel-dev/SKILL.md b/plugins/zcoder/skills/laravel-dev/SKILL.md
new file mode 100644
index 0000000..04bd418
--- /dev/null
+++ b/plugins/zcoder/skills/laravel-dev/SKILL.md
@@ -0,0 +1,58 @@
+---
+name: laravel-dev
+description: Laravel development conventions — database migrations (Schema column methods, foreignId/constrained/cascadeOnDelete, decimal money columns), artisan scaffolding (make:model -a, make:migration naming), Eloquent model structure, and testing via artisan test. Use whenever working in a Laravel or PHP artisan project: writing or reviewing migrations, generating models, controllers, policies, or seeders, or choosing artisan commands — even for one column.
+---
+
+# Laravel Development
+
+Conventions for Laravel apps (validated against the v13 framework line).
+Modern column methods are preferred because they encode semantics —
+constraints, indexes, and intent — that the old spell-outs left implicit.
+
+## Migrations
+
+- Anonymous migration class: `return new class extends Migration { ... };`
+  with `up()` and `down()`.
+- Create tables inside `Schema::create('table', function (Blueprint $table) {
+  ... })`; `down()` is `Schema::dropIfExists('table')`.
+- Table names: plural snake_case of the model (`Product` → `products`).
+- Column conventions:
+  - PK: `$table->id();`
+  - FK: `$table->foreignId('user_id')->constrained()->cascadeOnDelete();`
+    (NOT `unsignedBigInteger` + a separate `foreign()` call — the shorthand
+    creates, names, and indexes the constraint in one chain)
+  - money: `$table->decimal('price', 8, 2);` — arguments are
+    (total digits, decimal places)
+  - flags: `$table->boolean('active')->default(true);`
+  - soft deletes: `$table->softDeletes();`
+  - timestamps: `$table->timestamps();`
+- Column modifiers chain after the type call: `->nullable()`, `->default(x)`,
+  `->unsigned()`, `->unique()`.
+
+## Artisan scaffolding
+
+- One command scaffolds the full suite around a model:
+  `php artisan make:model Product -a` (long form `--all`) → model +
+  migration + factory + seeder + policy + resource controller.
+- Migration file naming drives table-name inference:
+  `create_products_table` → table `products`.
+- Run the suite: `php artisan test [path]`.
+
+## Eloquent
+
+- `class Product extends Model`; mass-assignment guard via
+  `protected $fillable = [...]` (or `protected $guarded = [];`).
+- Attribute casts via the `casts()` method:
+  `protected function casts(): array { return ['active' => 'boolean']; }`
+- Relations: `hasMany` / `belongsTo`; pass the foreign key only when it is
+  not the conventional `<model>_id`.
+
+## Validation
+
+- Request validation belongs in FormRequest classes with a `rules(): array`
+  method, not inline in controllers.
+
+## Testing
+
+- Feature tests use the `RefreshDatabase` trait; assert database state and
+  responses, not rendered strings.
diff --git a/plugins/zcoder/skills/skill-forge/SKILL.md b/plugins/zcoder/skills/skill-forge/SKILL.md
new file mode 100644
index 0000000..8ceecfc
--- /dev/null
+++ b/plugins/zcoder/skills/skill-forge/SKILL.md
@@ -0,0 +1,155 @@
+---
+name: skill-forge
+description: Build and continuously improve skills through a measured lifecycle — scan a project for missing skills (Laravel, React, Django, other stacks), author them, score them with deterministic oracle-graded eval scenarios and a Wilson-scored trials ledger, and improve them via reflective mutation and gated candidate promotion. Use whenever creating or improving a skill, evaluating skill effectiveness, scanning a project for needed skills, dogfooding skills, or running skill-evolve rounds.
+---
+
+# skill-forge — measured skill lifecycle
+
+Core empirical fact (validated 2026-09-03, trials ledger on record): **skill text
+presence does not imply compliance** — 4/4 subjects ignored an explicit rule.
+Skills are measured, not trusted. Every number below comes from a deterministic
+Python grader; no verdict is ever an LLM's opinion.
+
+## Principles
+
+1. **No oracle, no scenario.** Every eval scenario ships a machine-checkable
+   oracle (`oracle/checker.py`) plus known-good and known-bad references.
+2. **Validate the validator first.** `oracle_selftest.py` must be green before
+   any dispatch. (It once caught a checker that counted silent False as pass.)
+3. **Fresh-context subjects only.** The context that wrote or scored a skill
+   must never execute its trials — self-measurement contamination.
+4. **Oracle secrecy.** Subjects see the task and the guidance. Never the
+   oracle, the expected output, or the hypothesis.
+5. **Byte-identical dispatches** per variant across runs (prefix-cacheable,
+   reproducible conditions). Record tokens and agent id per trial.
+6. **Honest stats.** Wilson intervals describe; ~300 items/arm would be needed
+   for significance on small effects (uneconomical) → gates are discriminative
+   (tripwire philosophy), `stats.py --compare` refuses significance claims at
+   n<20.
+
+## Directory contract
+
+```
+tests/skill-evals/<skill>/
+  scenarios/<id>/task.md        # dispatch template; frontmatter declares output_ext;
+                                # body contains {{SKILL_GUIDANCE}} placeholder + task
+  scenarios/<id>/fixture/...    # inputs referenced by task.md
+  scenarios/<id>/oracle/checker.py      # prints VERDICT pass|fail + REASON; exit 0 iff pass
+  scenarios/<id>/oracle/reference_good.*  # must PASS self-test
+  scenarios/<id>/oracle/reference_bad.*   # must FAIL self-test (prefer REAL observed failures)
+  trials.jsonl                  # the ledger (grade.py --record appends)
+  artifacts/                    # extracted subject outputs
+  weak-spots.md                 # failure notes, one entry per failure mode
+  candidates/<id>/SKILL.md      # improved skill draft
+  candidates/<id>/MUTATION.md   # which failing trial, what changed, why
+  promotions.jsonl              # promotion audit trail
+skills/<skill>/SKILL.md         # the live (incumbent) skill
+skills-archive/<skill>/<ts>/    # archived incumbents (promote.py)
+tests/skill-evals/trigger-cases.jsonl   # golden routing set, PRE-REGISTERED
+                                # before any dispatch: {id, utterance, expected: skill|none, note}
+tests/skill-evals/trigger-evals.jsonl   # router-probe run ledger (trigger_eval.py; read by G7)
+```
+
+## Lifecycle
+
+### 1. RESEARCH (zero tokens)
+`python3 skills/skill-forge/scripts/scan_project.py [root]` — manifest-based
+stack detection + gap report against installed skills. Present gaps to the
+user; creation is user-confirmed by default.
+
+### 2. CREATE
+Author per skill-creator conventions: pushy description (20–500 chars) naming
+trigger phrasings; body ≤15360 bytes; imperative rules that explain *why*;
+worked examples over MUSTs. Stack recipes (starting points, then measured):
+**laravel** — artisan generators, migrations schema builder, Eloquent
+conventions, form requests/validation, policy gates, phpunit+feature tests.
+**react** — component structure, hooks rules, state colocation, testing
+library. **django** — apps/models, migrations, DRF serializers, pytest.
+Then immediately build the eval suite: ≥1 scenario with oracle + references
+(reference_bad = a realistic wrong output), self-test green.
+
+### 3. EVALUATE
+For each scenario × variant × run (2 runs default):
+1. Build the dispatch: task.md with `{{SKILL_GUIDANCE}}` replaced by the
+   variant's SKILL.md body. Byte-identical across runs of the same variant.
+2. Dispatch a fresh subagent (glm-main; glm-turbo if alive). Subject never
+   sees oracles/ledger/hypotheses.
+3. Save the raw final message to `raws/<scenario>__<variant>__<run>.txt`.
+4. `python3 skills/skill-forge/scripts/grade.py --record tests/skill-evals <skill> <scenario> <variant> <run> <rawfile> --tokens N --agent ID --session <label>`
+5. `python3 skills/skill-forge/scripts/stats.py tests/skill-evals/<skill>/trials.jsonl`
+
+**Blocking rule (hard-won, 2026-09-03):** variant comparisons are valid
+WITHIN one session only, run interleaved (A,B,A,B in the same dispatch wave).
+Byte-identical v1 dispatches scored 0/2 in one session and 2/2 in another —
+the subject substrate is non-stationary across sessions, so cross-session
+pooling is confounded. Always pass `--session <label>` when recording; stats
+warns when a variant's outcomes flip across sessions. Baselines are per
+(oracle hash, task hash, session) — the ledger stamps all three.
+
+### 4. IMPROVE (reflective mutation + staged eval — Hermes/GEPA port)
+Select the target zero-token: `pareto.py <ledger> --plateau <promotions.jsonl>`
+names the weakest scenario of the best frontier variant. If the plateau check
+says PLATEAU (last 2 promotions added no frontier member), write a NEW SCENARIO
+mined from sessions/weak-spots — not another body mutation; a stalled frontier
+on a 1-scenario suite is overfit, not solved. Otherwise mine the failing
+trials' artifacts + reasons: a candidate mutation MUST cite the failing trial
+id in MUTATION.md (G4). One targeted mutation per candidate; explain-why style;
+add a worked before/after example; prefer restructuring over louder enforcement.
+Mutations stay LOCAL (minimal diff) — unrelated rewrites violate semantic
+preservation and waste the growth allowance G6 grants. Evaluate staged:
+Stage A = target scenario only (2 interleaved runs); a candidate that doesn't
+fix its target dies there, before any full-matrix spend. Stage B = remaining
+scenarios; the candidate must then ENTER the Pareto frontier.
+
+### 5. PROMOTE (gated)
+`python3 skills/skill-forge/scripts/promote.py --skill <s> --candidate <id> --incumbent-variant v1 [--approved-by NAME]`
+Gates: G1 static caps (placeholders scanned in FULL raw text, frontmatter included) ·
+G2 oracle self-test · G3 same-session paired evidence — dominance computed ONLY
+over sessions where BOTH variants were tried on the scenario; a fix assembled
+from disjoint sessions is rejected, and a candidate failing an incumbent-untried
+scenario is rejected as an unmeasured regression surface · G4 mutation citation ·
+G5 differs-from-incumbent · G6 growth limit (Hermes port: body ≤ incumbent +20%,
+768B floor) · G7 trigger evidence (a changed description needs a baseline-
+REFERENCED trigger run: effective ≥0.75, zero cross-skill regressions;
+baseline-free runs are vacuous and rejected). Dry-run by default; **only an
+interactive user passes --approved-by** — idle rounds never promote.
+
+Gate regression locks live in `tests/skill-forge-smoke.sh` (32 adversarial
+fixtures; born 2026-09-04 from an audit that caught cross-session fix claims,
+candidate-only scenario fails, and baseline-free trigger runs passing gates).
+
+### 6. TRIGGER EVOLUTION (Hermes Phase-2 port)
+A skill's `description:` is trigger surface — what the router matches, the
+analog of hermes' tool descriptions. Evolving it is a different measurement:
+task oracles can't see routing. Protocol: `trigger_eval.py --check` (validates
++ hashes the golden case table — freeze BEFORE any dispatch) → dispatch ONE
+fresh metadata-only router subject (skill name+description frontmatter only,
+never bodies) → `trigger_eval.py --score <answers> --run-id <label> --variant
+<candidate> --baseline-run <prior>` scores it deterministically, including the
+cross-skill rule: improving one description must not STEAL selections from
+another (per-target rate drops = REGRESSIONS → G7 rejects). Schema stays
+frozen: name and frontmatter structure don't evolve; only description text.
+
+## Idle dogfood tiers (automation; budgets are hard)
+
+| Tier | Trigger | Work | Budget |
+|---|---|---|---|
+| NOOP | state hash unchanged | `tests/skill-forge-static.sh` + log line | ≤2k |
+| CANARY | every 4th round or weakest skill unknown | NOOP + `stats.py --rank` + 1 fresh trial on weakest skill's incumbent | ≤10k |
+| FULL | skill/trials file changed, regression, or every 10th round | CANARY + full scenario × variant matrix (2 runs) + stats + one reflective-mutation candidate if new fails | ≤60k |
+
+State hash = sha256 of live SKILL.md files + trials.jsonl tail, stored in
+`tests/skill-evals/.forge-state`. Idle rounds prepare candidates only.
+
+## Math layer
+
+- **Wilson 95% intervals** per variant — wide intervals are honest ignorance.
+- **Thompson sampling** (`stats.py --thompson`): Beta(1+k, 1+n−k) posterior,
+  ledger-hash-seeded (same data → same recommendation) — decides which
+  variant deserves the next trial.
+- **Pareto frontier** (`pareto.py`, GEPA port): a candidate is accepted when
+  it EXPANDS the per-scenario dominance frontier, never on scalar averages —
+  dominance survives mixed profiles that averaging destroys. Also emits the
+  next mutation target and the plateau stop-rule.
+- **Tripwires** over significance: alert on any fail / integrity violation.
+- **`--rank`**: weakest skill by Wilson lower bound — idle-loop target order.
diff --git a/plugins/zcoder/skills/skill-forge/scripts/grade.py b/plugins/zcoder/skills/skill-forge/scripts/grade.py
new file mode 100644
index 0000000..f161162
--- /dev/null
+++ b/plugins/zcoder/skills/skill-forge/scripts/grade.py
@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""Deterministic grading + trials-ledger recorder for skill-forge. stdlib only.
+
+Two modes:
+  grade.py --record <evals-root> <skill> <scenario> <variant> <run> <rawfile> \
+           [--tokens N] [--agent ID]
+      Extract the subject payload (between OUTPUT_BEGIN/OUTPUT_END; strict —
+      markers missing => protocol_fail verdict), write the artifact under
+      artifacts/, run the scenario oracle, append one row to trials.jsonl.
+      Duplicate rows (same scenario+variant+run+sha256) are skipped.
+  grade.py --grade <artifact> <scenario-dir>
+      One-off verdict via the scenario's oracle.
+
+Grading consumes zero LLM tokens and is byte-deterministic on fixed artifacts
+(validated 2026-09-03: three runs, identical sha256).
+"""
+import argparse
+import hashlib
+import json
+import os
+import re
+import subprocess
+import sys
+from datetime import datetime, timezone
+
+
+def extract_payload(raw_text):
+    if "OUTPUT_BEGIN" not in raw_text or "OUTPUT_END" not in raw_text:
+        return None
+    body = raw_text.split("OUTPUT_BEGIN", 1)[1]
+    body = body.split("OUTPUT_END", 1)[0]
+    body = body.strip("\n")
+    # Deterministic fence stripping: subjects may wrap output in ``` fences
+    # INSIDE the markers (observed live with PHP artifacts 2026-09-03). A
+    # fenced JSON artifact would otherwise false-fail json parsing.
+    lines = body.split("\n")
+    if len(lines) >= 2 and lines[0].lstrip().startswith("```"):
+        lines = lines[1:]
+        if lines and lines[-1].lstrip().startswith("```"):
+            lines = lines[:-1]
+        body = "\n".join(lines).strip("\n")
+    return body
+
+
+def output_ext(scenario_dir):
+    """Artifact extension is declared in task.md frontmatter (output_ext:)."""
+    meta = {}
+    task = os.path.join(scenario_dir, "task.md")
+    if os.path.exists(task):
+        text = open(task).read()
+        m = re.match(r"^---\n(.*?)\n---", text, re.S)
+        if m:
+            for line in m.group(1).splitlines():
+                if ":" in line:
+                    k, v = line.split(":", 1)
+                    meta[k.strip()] = v.strip()
+    return meta.get("output_ext", "txt")
+
+
+def run_oracle(scenario_dir, artifact):
+    checker = os.path.join(scenario_dir, "oracle", "checker.py")
+    r = subprocess.run([sys.executable, checker, artifact],
+                       capture_output=True, text=True, timeout=60)
+    m = re.search(r"VERDICT (pass|fail)", r.stdout)
+    reason_m = re.search(r"REASON (.*)", r.stdout)
+    if not m:
+        return "fail", f"oracle produced no verdict: {r.stdout.strip()[:150]} {r.stderr.strip()[:150]}"
+    verdict = m.group(1)
+    # protocol_fail outranks oracle verdict: missing markers = no artifact
+    reason = reason_m.group(1).strip() if reason_m else ""
+    return verdict, reason
+
+
+def cmd_record(a):
+    evals_root = os.path.abspath(a.evals_root)
+    skill_dir = os.path.join(evals_root, a.skill)
+    scenario_dir = os.path.join(skill_dir, "scenarios", a.scenario)
+    if not os.path.isdir(scenario_dir):
+        sys.exit(f"no such scenario dir: {scenario_dir}")
+    raw = open(a.rawfile).read()
+    payload = extract_payload(raw)
+    ext = output_ext(scenario_dir)
+    art_name = f"{a.scenario}__{a.variant}__{a.run}.{ext}"
+    art_dir = os.path.join(skill_dir, "artifacts")
+    os.makedirs(art_dir, exist_ok=True)
+    art = os.path.join(art_dir, art_name)
+    if payload is None:
+        verdict, reason = "fail", "protocol_fail: OUTPUT markers missing"
+        open(art + ".protocolfail.txt", "w").write(raw)
+    else:
+        with open(art, "w") as f:
+            f.write(payload + "\n")
+        verdict, reason = run_oracle(scenario_dir, art)
+    sha = hashlib.sha256(open(art if payload is not None else a.rawfile, "rb").read()).hexdigest()[:12]
+    oracle_sha = hashlib.sha256(open(os.path.join(scenario_dir, "oracle", "checker.py"), "rb").read()).hexdigest()[:12]
+    task_sha = hashlib.sha256(open(os.path.join(scenario_dir, "task.md"), "rb").read()).hexdigest()[:12]
+    row = {"ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+           "skill": a.skill, "scenario": a.scenario, "variant": a.variant,
+           "run": a.run, "verdict": verdict, "reason": reason, "sha256": sha,
+           "oracle": oracle_sha, "task": task_sha,
+           "session": a.session or "unlabeled",
+           "tokens": a.tokens, "agent": a.agent}
+    ledger = os.path.join(skill_dir, "trials.jsonl")
+    rows = [json.loads(l) for l in open(ledger) if l.strip()] if os.path.exists(ledger) else []
+    dup = any(r["scenario"] == a.scenario and r["variant"] == a.variant
+              and r["run"] == a.run and r["sha256"] == sha for r in rows)
+    if dup:
+        print("DUPLICATE trial (same scenario/variant/run/sha) — not recorded")
+    else:
+        rows.append(row)
+        with open(ledger, "w") as f:
+            for r in rows:
+                f.write(json.dumps(r) + "\n")
+    print(f"TRIAL {a.scenario} {a.variant} {a.run}: {verdict} — {reason[:120]}")
+    print(f"ARTIFACT {art_name} sha256:{sha}")
+
+
+def cmd_grade(a):
+    verdict, reason = run_oracle(os.path.abspath(a.scenario_dir), a.artifact)
+    print(f"VERDICT {verdict}")
+    print(f"REASON {reason}")
+
+
+def main():
+    if "--record" in sys.argv:
+        p = argparse.ArgumentParser()
+        p.add_argument("--record", action="store_true")
+        p.add_argument("evals_root")
+        p.add_argument("skill")
+        p.add_argument("scenario")
+        p.add_argument("variant")
+        p.add_argument("run")
+        p.add_argument("rawfile")
+        p.add_argument("--tokens", type=int, default=None)
+        p.add_argument("--agent", default=None)
+        p.add_argument("--session", default=None)
+        cmd_record(p.parse_args())
+    elif "--grade" in sys.argv:
+        p = argparse.ArgumentParser()
+        p.add_argument("--grade", action="store_true")
+        p.add_argument("artifact")
+        p.add_argument("scenario_dir")
+        cmd_grade(p.parse_args())
+    else:
+        sys.exit(__doc__)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/plugins/zcoder/skills/skill-forge/scripts/oracle_selftest.py b/plugins/zcoder/skills/skill-forge/scripts/oracle_selftest.py
new file mode 100644
index 0000000..78fcab8
--- /dev/null
+++ b/plugins/zcoder/skills/skill-forge/scripts/oracle_selftest.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Validate the validators. For every scenario under a skill's eval dir,
+reference_good* MUST pass and reference_bad* MUST fail. Exit 1 on any
+violation. This gate exists because an unvalidated oracle is an assumption:
+on 2026-09-03 the self-test caught a checker that counted silent False as a
+pass — every wrong answer would have graded as correct.
+
+Usage: oracle_selftest.py <skill-eval-dir>   (e.g. tests/skill-evals/yaml-json-convert)
+"""
+import glob
+import os
+import subprocess
+import sys
+
+
+def verdict_of(scenario_dir, artifact):
+    checker = os.path.join(scenario_dir, "oracle", "checker.py")
+    r = subprocess.run([sys.executable, checker, artifact],
+                       capture_output=True, text=True, timeout=60)
+    out = r.stdout
+    if "VERDICT pass" in out:
+        return "pass"
+    if "VERDICT fail" in out:
+        return "fail"
+    return "broken"
+
+
+def main():
+    root = sys.argv[1]
+    scenarios = sorted(glob.glob(os.path.join(root, "scenarios", "*")))
+    if not scenarios:
+        sys.exit(f"no scenarios under {root}")
+    bad = 0
+    for sc in scenarios:
+        name = os.path.basename(sc)
+        goods = sorted(glob.glob(os.path.join(sc, "oracle", "reference_good.*")))
+        bads = sorted(glob.glob(os.path.join(sc, "oracle", "reference_bad.*")))
+        if not goods or not bads:
+            print(f"FAIL {name}: missing reference_good/reference_bad")
+            bad += 1
+            continue
+        for g in goods:
+            v = verdict_of(sc, g)
+            if v != "pass":
+                print(f"FAIL {name}: reference_good {os.path.basename(g)} -> {v} (must pass)")
+                bad += 1
+            else:
+                print(f"PASS {name}: reference_good passes")
+        for b in bads:
+            v = verdict_of(sc, b)
+            if v != "fail":
+                print(f"FAIL {name}: reference_bad {os.path.basename(b)} -> {v} (must fail)")
+                bad += 1
+            else:
+                print(f"PASS {name}: reference_bad fails")
+    if bad:
+        sys.exit(f"ORACLE SELF-TEST FAILED ({bad} violations)")
+    print("ORACLE SELF-TEST GREEN")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/plugins/zcoder/skills/skill-forge/scripts/pareto.py b/plugins/zcoder/skills/skill-forge/scripts/pareto.py
new file mode 100644
index 0000000..d9bed6c
--- /dev/null
+++ b/plugins/zcoder/skills/skill-forge/scripts/pareto.py
@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""Pareto-frontier analysis for skill-forge trials ledgers. stdlib only.
+
+Hermes port (GEPA core, MIT): GEPA accepts a candidate when it EXPANDS the
+Pareto frontier over per-task scores, not when it wins on a scalar average —
+per-instance dominance survives mixed profiles that averaging destroys. We
+adapt that to binary per-scenario verdicts:
+
+  variant A dominates B  iff  for every scenario B was tried on:
+    - A was tried on it too (n_A >= n_B — dominance needs evidence, and
+      more evidence at the same rate is itself informative), and
+    - A's pass rate on it >= B's, with a STRICT win on at least one scenario.
+
+The frontier is the set of undominated variants. A candidate worth promoting
+must enter the frontier; promote.py G3 encodes the same dominance pairwise.
+
+Modes:
+  pareto.py <trials.jsonl>                          summary + frontier
+  pareto.py <trials.jsonl> --target                 next mutation target
+  pareto.py <trials.jsonl> --plateau <promotions.jsonl>   stop-rule check
+  pareto.py <trials.jsonl> --json                   machine-readable
+
+Plateau rule (hermes "regenerate eval data when the loop stalls"): if the
+last 2 promotions both failed to ADD a variant to the frontier, the text-
+mutation loop has stalled — write a NEW SCENARIO next (mined from sessions
+or weak-spots), not another body mutation. A stalled frontier with a 1-
+scenario suite means the skill is overfit to that scenario, not solved.
+"""
+import json
+import sys
+
+
+def load(path):
+    try:
+        return [json.loads(l) for l in open(path) if l.strip()]
+    except FileNotFoundError:
+        sys.exit(f"no such ledger: {path}")
+
+
+def profile(rows):
+    """variant -> {scenario: (passes, trials)}"""
+    out = {}
+    for r in rows:
+        v, s = r["variant"], r["scenario"]
+        k, n = out.setdefault(v, {}).get(s, (0, 0))
+        out[v][s] = (k + (1 if r["verdict"] == "pass" else 0), n + 1)
+    return out
+
+
+def dominates(a, b, prof):
+    """True iff variant a dominates variant b (see module docstring)."""
+    strict = False
+    for s, (kb, nb) in prof[b].items():
+        if s not in prof[a]:
+            return False, f"coverage gap: {a} untried on {s}"
+        ka, na = prof[a][s]
+        if na < nb:
+            return False, f"evidence deficit: {a} {na} trials on {s} vs {b} {nb}"
+        ra, rb = ka / na, kb / nb
+        if ra < rb:
+            return False, f"{s}: rate {ra:.2f} < {rb:.2f}"
+        if ra > rb:
+            strict = True
+    return strict, "dominates" if strict else "equal profile (non-dominating)"
+
+
+def frontier(prof):
+    members = sorted(prof)
+    front, dominated = [], {}
+    for v in members:
+        beaten_by = [o for o in members if o != v and dominates(o, v, prof)[0]]
+        if beaten_by:
+            dominated[v] = beaten_by
+        else:
+            front.append(v)
+    return front, dominated
+
+
+def best_variant(prof, front, promo_rows):
+    """Frontier member to defend/extend: the last promoted variant if it is
+    still on the frontier, else the frontier member with the most trials."""
+    if promo_rows:
+        cur = promo_rows[-1]["to_variant"]
+        if cur in front:
+            return cur
+    return max(front, key=lambda v: sum(n for _, n in prof[v].values()))
+
+
+def target(rows, prof, front, promo_rows):
+    """Next mutation target: lowest pass-rate scenario of the best frontier
+    variant, with its failing trial ids for MUTATION.md citation (G4)."""
+    v = best_variant(prof, front, promo_rows)
+    scen = sorted(prof[v].items(), key=lambda kv: (kv[1][0] / kv[1][1], kv[0]))
+    s, (k, n) = scen[0]
+    fails = [f"{r['run']}" for r in rows
+             if r["variant"] == v and r["scenario"] == s and r["verdict"] != "pass"]
+    return v, s, k, n, fails
+
+
+def _parse_ts(t):
+    from datetime import datetime
+    for fmt in ("ISO",):
+        try:
+            return datetime.fromisoformat(t.replace("Z", "+00:00"))
+        except ValueError:
+            pass
+    try:
+        return datetime.strptime(t, "%Y%m%dT%H%M%SZ").replace(tzinfo=datetime.now().astimezone().tzinfo)
+    except ValueError:
+        return None
+
+
+def plateau(promo_path, rows):
+    """Point-in-time replay: a promotion 'expanded the frontier' iff its
+    to_variant was on the frontier computed from trials recorded UP TO that
+    promotion's ts (judging old promotions against today's frontier would be
+    anachronistic evidence). If the last 2 promotions both failed to join
+    their contemporary frontier, the text-mutation loop has stalled — write a
+    NEW SCENARIO next (mined from sessions or weak-spots), not another body
+    mutation. A stalled frontier with a 1-scenario suite means the skill is
+    overfit to that scenario, not solved."""
+    try:
+        promos = [json.loads(l) for l in open(promo_path) if l.strip()]
+    except FileNotFoundError:
+        return "NO-PROMOTIONS", "no promotions.jsonl — nothing to check"
+    if len(promos) < 2:
+        return "INSUFFICIENT", (f"{len(promos)} promotion(s) on record — "
+                                "plateau verdict needs >= 2")
+    verdicts = []
+    for p in promos[-2:]:
+        cut = _parse_ts(p.get("ts", ""))
+        if cut is None:
+            return "INSUFFICIENT", f"promotion ts unparsable: {p.get('ts')!r}"
+        prof_t = profile([r for r in rows if (_parse_ts(r["ts"]) or cut) <= cut])
+        front_t, _ = frontier(prof_t)
+        verdicts.append((p["to_variant"], p["to_variant"] in front_t))
+    stalled = [v for v, on in verdicts if not on]
+    if len(stalled) == 2:
+        return "PLATEAU", (f"last 2 promotions ({', '.join(stalled)}) never entered their "
+                           "contemporary frontier — write a NEW SCENARIO next, not a body mutation")
+    return "ALIVE", ("recent promotions joined their contemporary frontier: "
+                     + "; ".join(f"{v}={'on' if on else 'off'}" for v, on in verdicts))
+
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help"):
+        sys.exit(__doc__)
+    rows = load(args[0])
+    if not rows:
+        sys.exit("ledger empty")
+    prof = profile(rows)
+    front, dominated = frontier(prof)
+    promo_rows = []
+    promo_path = None
+    if "--plateau" in args:
+        promo_path = args[args.index("--plateau") + 1]
+        try:
+            promo_rows = [json.loads(l) for l in open(promo_path) if l.strip()]
+        except FileNotFoundError:
+            pass
+
+    if "--json" in args:
+        print(json.dumps({
+            "variants": {v: {s: {"k": k, "n": n} for s, (k, n) in sv.items()}
+                         for v, sv in prof.items()},
+            "frontier": front,
+            "dominated": dominated,
+            "target": dict(zip(("variant", "scenario", "k", "n", "failing_runs"),
+                               target(rows, prof, front, promo_rows))),
+        }, indent=2))
+        return
+
+    print(f"ledger: {len(rows)} trials, {len(prof)} variants")
+    for v in sorted(prof):
+        cells = "  ".join(f"{s}={k}/{n}" for s, (k, n) in sorted(prof[v].items()))
+        tag = "FRONTIER" if v in front else f"dominated by {dominated[v]}"
+        print(f"  {v:<32} {cells}   [{tag}]")
+    print(f"frontier: {front}")
+
+    v, s, k, n, fails = target(rows, prof, front, promo_rows)
+    print(f"NEXT MUTATION TARGET -> variant {v}, scenario {s} ({k}/{n} pass)"
+          + (f" — cite failing runs: {', '.join(fails)}" if fails else " — no fails on record: target the weakest rate or add a harder scenario"))
+
+    if promo_path:
+        st, detail = plateau(promo_path, rows)
+        print(f"PLATEAU CHECK [{st}]: {detail}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/plugins/zcoder/skills/skill-forge/scripts/promote.py b/plugins/zcoder/skills/skill-forge/scripts/promote.py
new file mode 100644
index 0000000..f5ca1fd
--- /dev/null
+++ b/plugins/zcoder/skills/skill-forge/scripts/promote.py
@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+"""Gated candidate promotion for skill-forge. stdlib only.
+
+promote.py --skill <name> --candidate <id> --incumbent-variant <v> [--approved-by NAME]
+
+Gates (all must pass before installation; without --approved-by this is a
+dry-run that reports gate status only — idle automation NEVER gets approval
+authority):
+  G1 static integrity  — candidate SKILL.md parses; frontmatter name matches
+       the skill dir; description 20-500 chars (Hermes port: hard size caps);
+       body <= 15360 bytes; no TODO/FIXME/XXX/TBD placeholders.
+  G2 oracle self-test  — the skill's eval suite self-tests green
+       (reference_good passes, reference_bad fails, every scenario).
+  G3 evidence         — discriminative gate (tripwire philosophy; statistical
+       significance needs ~300 items/arm which is uneconomical — OHI power
+       analysis 2026-09-03):
+         for every scenario where the incumbent has >=1 trial:
+           - candidate must have >=1 trial on it
+           - if the incumbent failed it in ALL its trials, the candidate must
+             pass it in ALL its trials (the claimed fix is confirmed)
+           - if the incumbent passed it in ALL its trials, the candidate must
+             not fail it in ANY trial (no regression)
+       Mutations that do not target a failing trial cannot pass G3.
+  G4 mutation citation — candidate dir must contain MUTATION.md citing at
+       least one failing trial id (reflective mutation contract, Hermes port).
+  G5 differs-from-incumbent — a byte-identical 'improvement' is a no-op.
+  G6 growth limit (Hermes port: constraints.max_prompt_growth) — candidate
+       body may not exceed the incumbent body by more than 20%, with a 768B
+       absolute floor so young skills aren't dead-ended (evolutionary bloat
+       guard: verbose solutions must EARN their bytes, not drift into them).
+  G7 trigger evidence (Hermes port: tool-description rules) — the skill
+       description is trigger surface (what the router matches on), the
+       analog of a tool description. If the candidate changes it, the
+       change must be measured first: a run recorded for this candidate in
+       tests/skill-evals/trigger-evals.jsonl (by trigger_eval.py --score
+       --variant) with effective accuracy >= 0.75 and zero cross-skill
+       regressions. Unmeasured description changes are rejected — the
+       schema-text split hermes enforces for tool schemas, applied here.
+
+On approval: archive incumbent -> skills-archive/<skill>/<UTC-ts>/SKILL.md,
+install candidate -> skills/<skill>/SKILL.md, append promotions.jsonl.
+"""
+import argparse
+import glob
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from datetime import datetime, timezone
+
+HERE = os.path.dirname(os.path.abspath(__file__))            # .../skills/skill-forge/scripts
+PLUGIN_ROOT = os.path.abspath(os.path.join(HERE, "..", "..", ".."))
+# SKILL_FORGE_EVALS lets the smoke suite point gates at /tmp fixtures; unset
+# in production, where EVALS is always the plugin's real ledger tree.
+EVALS = os.environ.get("SKILL_FORGE_EVALS") or os.path.join(PLUGIN_ROOT, "tests", "skill-evals")
+SELFTEST = os.path.join(HERE, "oracle_selftest.py")
+
+BODY_CAP = 15360
+DESC_MIN, DESC_MAX = 20, 500
+PLACEHOLDERS = ("TODO", "FIXME", "XXX", "TBD")
+GROWTH_RATIO = 0.2        # Hermes port: max_prompt_growth
+GROWTH_FLOOR_B = 768      # absolute allowance so young skills aren't dead-ended
+TRIGGER_LEDGER = os.path.join(EVALS, "trigger-evals.jsonl")
+TRIGGER_MIN_ACC = 0.75
+SKILLS_DIR = os.environ.get("SKILL_FORGE_SKILLS") or os.path.join(PLUGIN_ROOT, "skills")
+
+
+def live_skill_path(skill):
+    return os.path.join(SKILLS_DIR, skill, "SKILL.md")
+
+
+def parse_frontmatter(path):
+    text = open(path).read()
+    m = re.match(r"^---\n(.*?)\n---\n(.*)$", text, re.S)
+    if not m:
+        return None, None, None
+    meta = {}
+    for line in m.group(1).splitlines():
+        if ":" in line:
+            k, v = line.split(":", 1)
+            meta[k.strip()] = v.strip()
+    return meta, m.group(2), text
+
+
+def gate_static(skill, cand_dir):
+    path = os.path.join(cand_dir, "SKILL.md")
+    if not os.path.exists(path):
+        return False, "candidate SKILL.md missing"
+    meta, body, raw = parse_frontmatter(path)
+    if meta is None:
+        return False, "frontmatter missing/unparsable"
+    if meta.get("name") != skill:
+        return False, f"frontmatter name {meta.get('name')!r} != skill {skill!r}"
+    desc = meta.get("description", "")
+    if not (DESC_MIN <= len(desc) <= DESC_MAX):
+        return False, f"description length {len(desc)} outside [{DESC_MIN},{DESC_MAX}]"
+    if len(body.encode()) > BODY_CAP:
+        return False, f"body {len(body.encode())} bytes > cap {BODY_CAP}"
+    hits = [p for p in PLACEHOLDERS if p in body]
+    if hits:
+        return False, f"placeholder markers present: {hits}"
+    # 2026-09-04 smoke audit: the scan covered the body only — a TODO in the
+    # description (shipped trigger text) sailed through. Raw scan now.
+    hits = [p for p in PLACEHOLDERS if p in raw]
+    if hits:
+        return False, f"placeholder markers in frontmatter/description: {hits}"
+    return True, f"frontmatter ok, desc {len(desc)} chars, body {len(body.encode())} bytes <= {BODY_CAP}"
+
+
+def gate_selftest(skill):
+    r = subprocess.run([sys.executable, SELFTEST, os.path.join(EVALS, skill)],
+                       capture_output=True, text=True)
+    ok = "ORACLE SELF-TEST GREEN" in r.stdout
+    return ok, (r.stdout.strip().splitlines() or ["?"])[-1]
+
+
+def gate_evidence(skill, cand_variant, inc_variant):
+    """Strictly-better rule, paired-session edition (audited 2026-09-04: two
+    blind spots confirmed by adversarial fixtures —
+      (a) a 'fix' assembled from DISJOINT sessions passed (incumbent fails in
+          session A + candidate passes in session B = the exact session
+          confound that downgraded the yaml-json-convert v2 claim 2026-09-03), and
+      (b) a candidate FAILING a scenario the incumbent never tried passed,
+          because only incumbent-covered scenarios were checked).
+    Rules now:
+      - For every scenario S the incumbent tried: consider only sessions where
+        BOTH variants were tried on S. No such session => problem (the staged
+        protocol exists to create one: interleaved dispatches under one
+        --session label). Within paired sessions: candidate pass rate >=
+        incumbent's, never fewer.
+      - Strict improvement: some S where the incumbent had >=1 fail and the
+        candidate is all-pass within paired sessions.
+      - Candidate-only scenarios (incumbent untried): candidate must be
+        ALL-PASS there — a fail on untried ground is an unmeasured regression
+        surface, not neutral novelty.
+      - Candidate fails in unpaired sessions are flagged, not scored (they can
+        neither support nor refute the paired comparison)."""
+    ledger = os.path.join(EVALS, skill, "trials.jsonl")
+    rows = [json.loads(l) for l in open(ledger) if l.strip()] if os.path.exists(ledger) else []
+    problems, notes = [], []
+    inc = [r for r in rows if r["variant"] == inc_variant]
+    cand = [r for r in rows if r["variant"] == cand_variant]
+    if not cand:
+        return False, ["candidate has zero trials"]
+    if not inc:
+        return False, [f"incumbent variant {inc_variant!r} has zero trials"]
+    sess = lambda r: r.get("session", "legacy")
+    strict_improvement = False
+    for scen in sorted({r["scenario"] for r in inc}):
+        i_rows = [r for r in inc if r["scenario"] == scen]
+        c_rows = [r for r in cand if r["scenario"] == scen]
+        if not c_rows:
+            problems.append(f"{scen}: candidate untried")
+            continue
+        paired = {sess(r) for r in i_rows} & {sess(r) for r in c_rows}
+        if not paired:
+            problems.append(f"{scen}: no same-session comparison (dispatch incumbent+candidate interleaved under one --session)")
+            continue
+        i_p = [r for r in i_rows if sess(r) in paired]
+        c_p = [r for r in c_rows if sess(r) in paired]
+        i_pass = sum(1 for r in i_p if r["verdict"] == "pass")
+        c_pass = sum(1 for r in c_p if r["verdict"] == "pass")
+        if c_pass < i_pass:
+            problems.append(f"{scen}: REGRESSION in paired sessions (candidate {c_pass}/{len(c_p)} < incumbent {i_pass}/{len(i_p)})")
+        elif any(r["verdict"] != "pass" for r in i_p) and c_pass == len(c_p):
+            strict_improvement = True
+            notes.append(f"{scen}: strict improvement, same-session (incumbent {i_pass}/{len(i_p)} -> candidate {c_pass}/{len(c_p)} all-pass)")
+        else:
+            notes.append(f"{scen}: no regression, same-session (incumbent {i_pass}/{len(i_p)}, candidate {c_pass}/{len(c_p)})")
+        for r in c_rows:
+            if sess(r) not in paired and r["verdict"] != "pass":
+                notes.append(f"{scen}: candidate fail in unpaired session {sess(r)!r} — not scored, investigate")
+    for scen in sorted({r["scenario"] for r in cand} - {r["scenario"] for r in inc}):
+        c_rows = [r for r in cand if r["scenario"] == scen]
+        if any(r["verdict"] != "pass" for r in c_rows):
+            n_fail = sum(1 for r in c_rows if r["verdict"] != "pass")
+            problems.append(f"{scen}: candidate-only scenario FAILS {n_fail}/{len(c_rows)} — unmeasured regression surface")
+        else:
+            notes.append(f"{scen}: candidate-only scenario all-pass ({len(c_rows)}/{len(c_rows)}) — extension evidence")
+    if not strict_improvement:
+        problems.append("NO strict improvement proven (no scenario where incumbent had fails and candidate is all-pass, same-session)")
+    return (not problems), (problems or notes)
+
+
+def gate_differ(skill, cand_dir):
+    """G5: the candidate must actually differ from the installed incumbent —
+    a byte-identical 'improvement' is a no-op promotion."""
+    live = live_skill_path(skill)
+    cand = os.path.join(cand_dir, "SKILL.md")
+    if not os.path.exists(live) or not os.path.exists(cand):
+        return False, "incumbent or candidate SKILL.md missing"
+    same = open(live, "rb").read() == open(cand, "rb").read()
+    return (not same), "identical to incumbent (no-op)" if same else "differs from incumbent"
+
+
+def gate_mutation(cand_dir):
+    path = os.path.join(cand_dir, "MUTATION.md")
+    if not os.path.exists(path):
+        return False, "MUTATION.md missing"
+    text = open(path).read()
+    ids = re.findall(r"\b(run\w*|[a-z0-9-]+__\w+__\w+)\b", text)
+    cited = [i for i in ids if i.startswith("run") or "__" in i]
+    if not cited:
+        return False, "MUTATION.md cites no failing trial id"
+    return True, f"cites {sorted(set(cited))[:3]}"
+
+
+def _frontmatter_body(path):
+    meta, body, _ = parse_frontmatter(path)
+    return meta or {}, body or ""
+
+
+def gate_growth(skill, cand_dir):
+    """G6 (Hermes port): candidate body <= incumbent body + max(20%, 768B)."""
+    live = live_skill_path(skill)
+    cand = os.path.join(cand_dir, "SKILL.md")
+    if not os.path.exists(live) or not os.path.exists(cand):
+        return False, "incumbent or candidate SKILL.md missing"
+    inc_b = len(_frontmatter_body(live)[1].encode())
+    cand_b = len(_frontmatter_body(cand)[1].encode())
+    allowance = max(int(GROWTH_RATIO * inc_b), GROWTH_FLOOR_B)
+    if cand_b > inc_b + allowance:
+        return False, (f"body growth {inc_b} -> {cand_b} bytes (+{cand_b - inc_b}) "
+                       f"exceeds allowance +{allowance} (max {GROWTH_RATIO:.0%}, floor {GROWTH_FLOOR_B}B)")
+    return True, f"body growth {inc_b} -> {cand_b} bytes within allowance +{allowance}"
+
+
+def gate_trigger(skill, cand_dir):
+    """G7 (Hermes port): a changed description must carry trigger evidence."""
+    live = live_skill_path(skill)
+    cand = os.path.join(cand_dir, "SKILL.md")
+    if not os.path.exists(live) or not os.path.exists(cand):
+        return False, "incumbent or candidate SKILL.md missing"
+    desc_c = _frontmatter_body(cand)[0].get("description", "")
+    desc_i = _frontmatter_body(live)[0].get("description", "")
+    if desc_c == desc_i:
+        return True, "description unchanged — trigger surface untouched"
+    if not os.path.exists(TRIGGER_LEDGER):
+        return False, ("description changed but no trigger ledger exists "
+                       f"({TRIGGER_LEDGER}) — run trigger_eval.py first")
+    runs = [json.loads(l) for l in open(TRIGGER_LEDGER) if l.strip()]
+    mine = [r for r in runs if r.get("variant") == os.path.basename(cand_dir.rstrip("/"))]
+    if not mine:
+        return False, ("description changed but no trigger run recorded for this "
+                       "candidate — run trigger_eval.py --score --variant <candidate>")
+    r = mine[-1]
+    if not r.get("baseline_run"):
+        return False, (f"trigger run {r.get('run_id')} recorded WITHOUT a baseline "
+                       "comparison — its 'no regressions' is vacuous; re-score with "
+                       "--baseline-run (or let trigger_eval auto-baseline)")
+    regs = r.get("regressions") or []
+    eff = r.get("effective", 0.0)
+    if regs or eff < TRIGGER_MIN_ACC:
+        return False, (f"trigger run {r.get('run_id')} vs baseline {r.get('baseline_run')}: "
+                       f"effective {eff:.2f} < {TRIGGER_MIN_ACC} or regressions {regs} — "
+                       "description change rejected")
+    return True, (f"trigger run {r.get('run_id')} vs baseline {r.get('baseline_run')}: "
+                  f"effective {eff:.2f}, no cross-skill regressions")
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--skill", required=True)
+    p.add_argument("--candidate", required=True)
+    p.add_argument("--incumbent-variant", required=True)
+    p.add_argument("--approved-by", default=None)
+    a = p.parse_args()
+
+    cand_dir = os.path.join(EVALS, a.skill, "candidates", a.candidate)
+    gates = [
+        ("G1 static", gate_static(a.skill, cand_dir)),
+        ("G2 selftest", gate_selftest(a.skill)),
+        ("G3 evidence", gate_evidence(a.skill, a.candidate, a.incumbent_variant)),
+        ("G4 mutation-citation", gate_mutation(cand_dir)),
+        ("G5 differs-from-incumbent", gate_differ(a.skill, cand_dir)),
+        ("G6 growth-limit", gate_growth(a.skill, cand_dir)),
+        ("G7 trigger-evidence", gate_trigger(a.skill, cand_dir)),
+    ]
+    all_ok = True
+    for name, (ok, detail) in gates:
+        print(f"{'PASS' if ok else 'FAIL'}  {name}: {detail}")
+        all_ok &= ok
+    if not all_ok:
+        sys.exit("PROMOTION BLOCKED — gates failed")
+    if not a.approved_by:
+        print("All gates green — dry-run only. Pass --approved-by <name> to install.")
+        return
+
+    skill_dir = os.path.join(PLUGIN_ROOT, "skills", a.skill)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    # Full-dir archive (true rollback) and full-dir install (bundled
+    # references/scripts/assets survive promotion; MUTATION.md stays behind —
+    # it is ledger metadata, not skill content).
+    arch = os.path.join(PLUGIN_ROOT, "skills-archive", a.skill, ts)
+    os.makedirs(arch, exist_ok=True)
+    shutil.copytree(skill_dir, arch, dirs_exist_ok=True)
+    for item in os.listdir(cand_dir):
+        if item == "MUTATION.md":
+            continue
+        src = os.path.join(cand_dir, item)
+        if os.path.isdir(src):
+            shutil.copytree(src, os.path.join(skill_dir, item), dirs_exist_ok=True)
+        else:
+            shutil.copy2(src, os.path.join(skill_dir, item))
+    row = {"ts": ts, "skill": a.skill, "from_variant": a.incumbent_variant,
+           "to_variant": a.candidate, "approved_by": a.approved_by,
+           "evidence": [n for _, (ok, d) in gates if ok and isinstance(d, list) for n in d]}
+    with open(os.path.join(EVALS, a.skill, "promotions.jsonl"), "a") as f:
+        f.write(json.dumps(row) + "\n")
+    print(f"PROMOTED {a.skill}: {a.incumbent_variant} -> {a.candidate} "
+          f"(archived {arch}, approved_by {a.approved_by})")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/plugins/zcoder/skills/skill-forge/scripts/scan_project.py b/plugins/zcoder/skills/skill-forge/scripts/scan_project.py
new file mode 100644
index 0000000..594ddb2
--- /dev/null
+++ b/plugins/zcoder/skills/skill-forge/scripts/scan_project.py
@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""Zero-token project scanner: detect stacks from manifests, diff against
+installed skills, report gaps. Deterministic, stdlib only — no LLM calls.
+
+Usage: scan_project.py [project-root]      (default: cwd)
+Output: human report + JSON blob on stdout.
+
+Stack -> skill-keyword map mirrors the recipes in skills/skill-forge/SKILL.md.
+A gap is a detected stack with no installed skill whose name/description
+matches its keywords.
+"""
+import json
+import os
+import re
+import sys
+
+STACK_KEYWORDS = {
+    "laravel": ["laravel"],
+    "symfony": ["symfony"],
+    "wordpress": ["wordpress"],
+    "php": ["php"],
+    "react": ["react", "nextjs", "next.js"],
+    "vue": ["vue", "nuxt"],
+    "svelte": ["svelte"],
+    "angular": ["angular"],
+    "astro": ["astro"],
+    "node": ["node", "npm", "express"],
+    "django": ["django"],
+    "flask": ["flask"],
+    "fastapi": ["fastapi"],
+    "python": ["python", "pytest"],
+    "rails": ["rails", "ruby on rails"],
+    "ruby": ["ruby"],
+    "go": ["golang", "go "],
+    "rust": ["rust", "cargo"],
+    "spring": ["spring boot", "spring"],
+    "java": ["java"],
+    "dotnet": [".net", "csharp", "c#"],
+}
+
+
+def read_json(path):
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def scan_stacks(root):
+    stacks = set()
+    composer = read_json(os.path.join(root, "composer.json"))
+    if composer:
+        stacks.add("php")
+        req = {**composer.get("require", {}), **composer.get("require-dev", {})}
+        for pkg in req:
+            if "laravel/framework" in pkg:
+                stacks.add("laravel")
+            elif "symfony" in pkg:
+                stacks.add("symfony")
+            elif "wordpress" in pkg or pkg == "roots/wordpress":
+                stacks.add("wordpress")
+    pkg = read_json(os.path.join(root, "package.json"))
+    if pkg:
+        stacks.add("node")
+        deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+        for d in deps:
+            if d.startswith("next"):
+                stacks.update({"react", "next"})
+            elif d.startswith("react"):
+                stacks.add("react")
+            elif d.startswith("vue") or d.startswith("nuxt"):
+                stacks.add("vue")
+            elif d.startswith("svelte"):
+                stacks.add("svelte")
+            elif d.startswith("@angular"):
+                stacks.add("angular")
+            elif d.startswith("astro"):
+                stacks.add("astro")
+            if "tailwind" in d:
+                stacks.add("tailwind")
+    for pyfile, add in (("requirements.txt", None), ("pyproject.toml", None)):
+        p = os.path.join(root, pyfile)
+        if os.path.exists(p):
+            stacks.add("python")
+            text = open(p, errors="replace").read().lower()
+            for fw in ("django", "flask", "fastapi"):
+                if re.search(rf"^\s*[-\w./]*{fw}", text, re.M) or f'"{fw}' in text:
+                    stacks.add(fw)
+    if os.path.exists(os.path.join(root, "manage.py")):
+        stacks.update({"python", "django"})
+    if os.path.exists(os.path.join(root, "go.mod")):
+        stacks.add("go")
+    if os.path.exists(os.path.join(root, "Cargo.toml")):
+        stacks.add("rust")
+    gemfile = os.path.join(root, "Gemfile")
+    if os.path.exists(gemfile):
+        stacks.add("ruby")
+        if "rails" in open(gemfile, errors="replace").read().lower():
+            stacks.add("rails")
+    for j in ("pom.xml", "build.gradle", "build.gradle.kts"):
+        if os.path.exists(os.path.join(root, j)):
+            stacks.add("java")
+            text = open(os.path.join(root, j), errors="replace").read().lower()
+            if "spring" in text:
+                stacks.add("spring")
+    csproj = [f for f in os.listdir(root) if f.endswith(".csproj") or f.endswith(".sln")] \
+        if os.path.isdir(root) else []
+    if csproj:
+        stacks.add("dotnet")
+    stacks.discard("next")  # 'next' implies react; keep tailwind as its own signal
+    return stacks
+
+
+def installed_skills(root):
+    """Plugin skills + workspace/user skills, with name+description text."""
+    here = os.path.dirname(os.path.abspath(__file__))
+    plugin_root = os.path.abspath(os.path.join(here, "..", "..", ".."))
+    dirs = [
+        os.path.join(plugin_root, "skills"),
+        os.path.join(root, ".zcode", "skills"),
+        os.path.join(root, ".agents", "skills"),
+        os.path.expanduser("~/.zcode/skills"),
+        os.path.expanduser("~/.agents/skills"),
+    ]
+    found = []
+    for d in dirs:
+        if not os.path.isdir(d):
+            continue
+        for skf in glob_skls(d):
+            try:
+                text = open(skf, errors="replace").read()
+                m = re.match(r"^---\n(.*?)\n---", text, re.S)
+                meta = {}
+                if m:
+                    for line in m.group(1).splitlines():
+                        if ":" in line:
+                            k, v = line.split(":", 1)
+                            meta[k.strip()] = v.strip()
+                found.append({"path": skf,
+                              "name": meta.get("name", os.path.basename(os.path.dirname(skf))),
+                              "text": (meta.get("name", "") + " " + meta.get("description", "")).lower()})
+            except Exception:
+                pass
+    return found
+
+
+def glob_skls(d, max_depth=2):
+    out = []
+    for dirpath, dirnames, filenames in os.walk(d):
+        depth = dirpath[len(d):].count(os.sep)
+        if depth >= max_depth:
+            dirnames[:] = []
+            continue
+        dirnames[:] = [x for x in dirnames
+                       if x not in ("node_modules", ".git", "__pycache__")]
+        if "SKILL.md" in filenames:
+            out.append(os.path.join(dirpath, "SKILL.md"))
+    return out
+
+
+def covers(stack, skill, kws):
+    """A skill covers a stack only if the keyword is a NAME token. Description
+    matching is deliberately rejected: any skill that *talks about* a stack
+    (recipe lists, examples) would claim coverage — observed live on
+    laravel/laravel 2026-09-03, where skill-forge's recipe mention covered
+    'laravel' and an animation skill covered 'tailwind'. A false GAP merely
+    offers creation; a false COVERED silently misses. Err toward GAP."""
+    name_tokens = set(re.split(r"[-_]", skill["name"].lower()))
+    return any(kw.strip() in name_tokens for kw in kws)
+
+
+def main():
+    root = os.path.abspath(sys.argv[1] if len(sys.argv) > 1 else os.getcwd())
+    stacks = scan_stacks(root)
+    installed = installed_skills(root)
+    gaps = []
+    covered = []
+    for stack in sorted(stacks):
+        kws = STACK_KEYWORDS.get(stack, [stack])
+        match = next((s["name"] for s in installed if covers(stack, s, kws)), None)
+        (covered if match else gaps).append((stack, match))
+    print(f"project: {root}")
+    print(f"stacks detected: {', '.join(sorted(stacks)) or '(none)'}")
+    print(f"skills installed: {len(installed)}")
+    for stack, via in covered:
+        print(f"  COVERED  {stack:<12} by {via}")
+    for stack, _ in gaps:
+        print(f"  GAP      {stack:<12} no matching skill installed")
+    print(json.dumps({"root": root, "detected": sorted(stacks),
+                      "installed": [s["name"] for s in installed],
+                      "gaps": [g for g, _ in gaps]}, indent=None))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/plugins/zcoder/skills/skill-forge/scripts/stats.py b/plugins/zcoder/skills/skill-forge/scripts/stats.py
new file mode 100644
index 0000000..adb319f
--- /dev/null
+++ b/plugins/zcoder/skills/skill-forge/scripts/stats.py
@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""Statistical engine for skill-forge trials ledgers. stdlib only.
+
+Honest-stats stance (validated 2026-09-03 + OHI power analysis): at plugin
+scale (~2-10 trials/variant) improvements are DISCRIMINATIVE, not significant
+(~300 items/arm needed for small effects). So:
+  - Wilson intervals describe each variant; wide = honest ignorance.
+  - --compare reports the two-proportion z-test but refuses to call n<20
+    comparisons significant (prints 'descriptive only').
+  - --thompson picks which variant deserves the NEXT trial (Beta-Bernoulli
+    posterior sampling). This is a DECISION procedure, not a measurement:
+    seeded by the ledger's own hash, so the same data always yields the same
+    recommendation — determinism where it matters.
+  - --rank lists skills by Wilson LOWER bound ascending (weakest first) —
+    the idle loop's target selector.
+
+Usage:
+  stats.py <trials.jsonl> [--compare A B] [--thompson] [--rank <evals-root>]
+"""
+import glob
+import hashlib
+import json
+import math
+import os
+import random
+import sys
+
+Z = 1.959964
+
+
+def wilson(k, n):
+    if n == 0:
+        return None
+    p = k / n
+    d = 1 + Z * Z / n
+    c = (p + Z * Z / (2 * n)) / d
+    h = Z * math.sqrt(p * (1 - p) / n + Z * Z / (4 * n * n)) / d
+    return p, max(0.0, c - h), min(1.0, c + h)
+
+
+def two_prop(k1, n1, k2, n2):
+    p1, p2 = k1 / n1, k2 / n2
+    p = (k1 + k2) / (n1 + n2)
+    se = math.sqrt(p * (1 - p) * (1 / n1 + 1 / n2))
+    if se == 0:
+        return 0.0, 1.0
+    z = (p2 - p1) / se
+    return z, 2 * (1 - 0.5 * (1 + math.erf(abs(z) / math.sqrt(2))))
+
+
+def load(path):
+    return [json.loads(l) for l in open(path) if l.strip()]
+
+
+def per_variant(rows):
+    out = {}
+    for r in rows:
+        v = r["variant"]
+        out.setdefault(v, []).append(r)
+    return out
+
+
+def report(path):
+    rows = load(path)
+    oracle_mix_warning(path)
+    pv = per_variant(rows)
+    print(f"ledger: {len(rows)} trials, {len(pv)} variants")
+    for v, vr in sorted(pv.items()):
+        k = sum(1 for r in vr if r["verdict"] == "pass")
+        w = wilson(k, len(vr))
+        fails = [r for r in vr if r["verdict"] != "pass"]
+        print(f"  {v:<28} {k}/{len(vr)} pass  Wilson95 [{w[1]:.2f}, {w[2]:.2f}]"
+              + (f"  fails: {sorted({f['run'] for f in fails})}" if fails else ""))
+        for f in fails:
+            print(f"    FAIL {f['scenario']}/{f['run']}: {f['reason'][:100]}")
+    # scenario matrix per variant
+    scen = sorted({r["scenario"] for r in rows})
+    if scen:
+        print("  scenario matrix (pass/trials):")
+        for v, vr in sorted(pv.items()):
+            cells = []
+            for s in scen:
+                sr = [r for r in vr if r["scenario"] == s]
+                cells.append(f"{s}={sum(1 for r in sr if r['verdict']=='pass')}/{len(sr)}")
+            print(f"    {v:<28} {' '.join(cells)}")
+
+
+def compare(path, a, b):
+    rows = load(path)
+    pv = per_variant(rows)
+    if a not in pv or b not in pv:
+        sys.exit(f"need both variants in ledger; have {sorted(pv)}")
+    ka = sum(1 for r in pv[a] if r["verdict"] == "pass")
+    kb = sum(1 for r in pv[b] if r["verdict"] == "pass")
+    z, p = two_prop(ka, len(pv[a]), kb, len(pv[b]))
+    wa, wb = wilson(ka, len(pv[a])), wilson(kb, len(pv[b]))
+    print(f"{a}: {ka}/{len(pv[a])} [{wa[1]:.2f},{wa[2]:.2f}]  vs  "
+          f"{b}: {kb}/{len(pv[b])} [{wb[1]:.2f},{wb[2]:.2f}]")
+    # Session blocking (2026-09-03 finding: byte-identical v1 dispatches went
+    # 0/2 in one session and 2/2 in another — cross-session trials are NOT
+    # exchangeable; comparisons are valid within-session only).
+    for v in (a, b):
+        by_sess = {}
+        for r in pv[v]:
+            s = r.get("session", "legacy")
+            by_sess.setdefault(s, [0, 0])
+            by_sess[s][1] += 1
+            by_sess[s][0] += 1 if r["verdict"] == "pass" else 0
+        parts = [f"{s}: {k}/{n}" for s, (k, n) in sorted(by_sess.items())]
+        if parts:
+            print(f"  {v} by session: {'; '.join(parts)}")
+    for v in (a, b):
+        sess_pass = {}
+        for r in pv[v]:
+            sess_pass.setdefault(r.get("session", "legacy"), []).append(r["verdict"] == "pass")
+        rates = {s: sum(x) / len(x) for s, x in sess_pass.items() if x}
+        if len(rates) > 1 and len(set(rates.values())) > 1:
+            print(f"  WARNING: {v} outcome differs across sessions {rates} — subject "
+                  f"non-stationarity; treat cross-session pooling as confounded and "
+                  f"re-run as same-session interleaved A/B.")
+    print(f"two-proportion z={z:.3f}, p={p:.3f}", end=" ")
+    n = len(pv[a]) + len(pv[b])
+    if n < 20:
+        print(f"— n={n} < 20: DESCRIPTIVE ONLY (do not claim significance)")
+    elif p < 0.05:
+        print("— significant at p<0.05")
+    else:
+        print("— not significant")
+
+
+def thompson(path, draws=2000):
+    pv = per_variant(load(path))
+    if len(pv) < 2:
+        sys.exit("thompson needs >=2 variants")
+    # seed from ledger content: same data -> same recommendation
+    seed = int(hashlib.sha256(open(path, "rb").read()).hexdigest()[:8], 16)
+    rng = random.Random(seed)
+    post = {}
+    for v, vr in sorted(pv.items()):
+        k = sum(1 for r in vr if r["verdict"] == "pass")
+        post[v] = (k + 1, len(vr) - k + 1)  # Beta(1+k, 1+n-k)
+    samples = {v: [rng.betavariate(*a_b) for _ in range(draws)] for v, a_b in post.items()}
+    wins = {v: 0 for v in post}
+    for i in range(draws):
+        best = max(samples, key=lambda v: samples[v][i])
+        wins[best] += 1
+    means = {v: a / (a + b) for v, (a, b) in post.items()}
+    rec = max(wins, key=wins.get)
+    print("posterior means:", {v: f"{m:.2f}" for v, m in means.items()})
+    print("thompson win-share:", {v: f"{w/draws:.0%}" for v, w in wins.items()})
+    print(f"NEXT TRIAL -> {rec} (seeded by ledger hash; decision procedure, not measurement)")
+
+
+def current_variant(evals_root, skill):
+    """The live variant = last promotion's to_variant; None if never promoted."""
+    promo = os.path.join(evals_root, skill, "promotions.jsonl")
+    if not os.path.exists(promo):
+        return None
+    rows = [json.loads(l) for l in open(promo) if l.strip()]
+    return rows[-1]["to_variant"] if rows else None
+
+
+def rank(evals_root):
+    """Rank skills by Wilson LOWER bound of the CURRENT (promoted) variant —
+    pooling all history understates the live incumbent (audited 2026-09-03:
+    yaml-json-convert ranked 2/4 when its live v2 was 2/2)."""
+    results = []
+    for ledger in sorted(glob.glob(os.path.join(evals_root, "*", "trials.jsonl"))):
+        skill = os.path.basename(os.path.dirname(ledger))
+        rows = load(ledger)
+        if not rows:
+            continue
+        cur = current_variant(evals_root, skill)
+        if cur:
+            rows = [r for r in rows if r["variant"] == cur] or rows
+        k = sum(1 for r in rows if r["verdict"] == "pass")
+        w = wilson(k, len(rows))
+        results.append((w[1], skill, k, len(rows), cur or "all"))
+    if not results:
+        sys.exit("no trials found")
+    print("skills by Wilson LOWER bound of CURRENT variant (weakest first):")
+    for lb, skill, k, n, cur in sorted(results):
+        print(f"  {skill:<32} {k}/{n} pass  LB={lb:.2f}  (variant: {cur})")
+
+
+def oracle_mix_warning(path):
+    rows = load(path)
+    seen = {}
+    for r in rows:
+        o = r.get("oracle", "legacy")
+        seen.setdefault((r["skill"], r["scenario"]), set()).add(o)
+    mixes = {k: v for k, v in seen.items() if len(v) > 1}
+    if mixes:
+        print("WARNING: oracle versions mixed within a scenario (baseline comparability broken):")
+        for (skill, scen), vers in sorted(mixes.items()):
+            print(f"  {skill}/{scen}: {sorted(vers)}")
+        print("  (pre-2026-09-03 rows carry no oracle hash; treat as legacy)")
+
+
+def main():
+    if len(sys.argv) < 2:
+        sys.exit(__doc__)
+    path = sys.argv[1]
+    if "--rank" in sys.argv:
+        rank(sys.argv[sys.argv.index("--rank") + 1])
+        return
+    if "--compare" in sys.argv:
+        i = sys.argv.index("--compare")
+        compare(path, sys.argv[i + 1], sys.argv[i + 2])
+        return
+    if "--thompson" in sys.argv:
+        thompson(path)
+        return
+    report(path)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/plugins/zcoder/skills/skill-forge/scripts/trigger_eval.py b/plugins/zcoder/skills/skill-forge/scripts/trigger_eval.py
new file mode 100644
index 0000000..0916526
--- /dev/null
+++ b/plugins/zcoder/skills/skill-forge/scripts/trigger_eval.py
@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""Trigger-surface evaluation for skill-forge. stdlib only.
+
+Hermes port (Phase 2, tool-description evolution, MIT): in hermes, tool
+descriptions are evolved and evaluated by whether the agent PICKS THE RIGHT
+TOOL — a classification problem — with the cross-tool rule that improving one
+description must not steal selections from another. A ZCode skill's
+description is exactly that surface: it is what the router matches a request
+against. So description changes are evolution of trigger behavior and get
+their own eval, separate from task oracles:
+
+  trigger-cases.jsonl   golden routing set: {id, utterance, expected, note}
+                        where expected = a skill name or "none".
+                        Expected verdicts are PRE-REGISTERED (committed) before
+                        any dispatch — the run is scored against the frozen
+                        table, never the reverse.
+  trigger-evals.jsonl   run ledger written by --score; one row per router
+                        probe. promote.py G7 reads it: a candidate that
+                        changes the description must have a recorded run with
+                        effective accuracy >= 0.75 and NO cross-skill
+                        regressions.
+
+The router probe itself needs a fresh LLM subject (metadata-only view: the
+subject sees skill name+description frontmatter, never skill bodies, never
+this script) — dispatch protocol lives in commands/skill-evolve.md. Scoring
+consumes zero tokens and is byte-deterministic on fixed answers.
+
+Usage:
+  trigger_eval.py --check [cases.jsonl]        validate + print registration sha
+  trigger_eval.py --score <answers.txt> --cases <f> --run-id <id> --variant <id>
+                  [--agent A] [--tokens N] [--baseline-run <id>]
+                  [--ok <case-id>]... [--bad <case-id>]... [--note "..."]
+                  [--skill-meta <dir>]         (default: skills/ — for --check)
+  trigger_eval.py --show
+"""
+import argparse
+import hashlib
+import json
+import os
+import re
+import sys
+from datetime import datetime, timezone
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+PLUGIN_ROOT = os.path.abspath(os.path.join(HERE, "..", "..", ".."))
+# SKILL_FORGE_EVALS / SKILL_FORGE_SKILLS let the smoke suite point this tool
+# at /tmp fixtures; unset in production the paths are the plugin's real ones.
+EVALS = os.environ.get("SKILL_FORGE_EVALS") or os.path.join(PLUGIN_ROOT, "tests", "skill-evals")
+CASES = os.path.join(EVALS, "trigger-cases.jsonl")
+LEDGER = os.path.join(EVALS, "trigger-evals.jsonl")
+SKILLS_DIR = os.environ.get("SKILL_FORGE_SKILLS") or os.path.join(PLUGIN_ROOT, "skills")
+TRIGGER_MIN_ACC = 0.75
+
+
+def installed_skills():
+    """Valid routing targets: frontmatter name of every skills/*/SKILL.md."""
+    names = set()
+    if os.path.isdir(SKILLS_DIR):
+        for sk in sorted(os.listdir(SKILLS_DIR)):
+            p = os.path.join(SKILLS_DIR, sk, "SKILL.md")
+            if not os.path.exists(p):
+                continue
+            m = re.match(r"^---\n(.*?)\n---", open(p).read(), re.S)
+            name = sk
+            if m:
+                for line in m.group(1).splitlines():
+                    if line.strip().startswith("name:"):
+                        name = line.split(":", 1)[1].strip().strip("'\"")
+            names.add(name)
+    return names
+
+
+def cases_sha(path):
+    """Pre-registration hash: content of the frozen expected table."""
+    return hashlib.sha256(open(path, "rb").read()).hexdigest()[:12]
+
+
+def check(path):
+    rows = [json.loads(l) for l in open(path) if l.strip()]
+    skills = installed_skills()
+    problems = []
+    seen = set()
+    for r in rows:
+        cid = r.get("id", "")
+        if not cid:
+            problems.append("row missing id")
+        if cid in seen:
+            problems.append(f"{cid}: duplicate id")
+        seen.add(cid)
+        if not r.get("utterance", "").strip():
+            problems.append(f"{cid}: empty utterance")
+        exp = r.get("expected", "")
+        if exp != "none" and exp not in skills:
+            problems.append(f"{cid}: expected {exp!r} is not an installed skill or 'none'")
+        if not r.get("note", "").strip():
+            problems.append(f"{cid}: missing note (each case must say why it expects what it expects)")
+    dist = {}
+    for r in rows:
+        dist[r["expected"]] = dist.get(r["expected"], 0) + 1
+    if problems:
+        for p in problems:
+            print(f"PROBLEM {p}")
+        sys.exit(f"TRIGGER CASES INVALID: {len(problems)} problem(s)")
+    print(f"TRIGGER CASES OK: {len(rows)} cases over targets {sorted(dist)}")
+    print(f"PRE-REGISTRATION SHA {cases_sha(path)} — freeze this table BEFORE any dispatch")
+    return 0
+
+
+def parse_answers(path, rows):
+    """Parse 'N: verdict' lines (1-based case order in the cases file).
+    Tolerates trailing annotations like '(match)' or '— because ...'.
+    Duplicate case numbers are a protocol violation, not a silent overwrite."""
+    answers, seen = {}, set()
+    for line in open(path):
+        m = re.match(r"^\s*(\d+)\s*[:.]\s*([A-Za-z0-9_-]+)", line)
+        if not m:
+            continue
+        n, verdict = int(m.group(1)), m.group(2)
+        if not (1 <= n <= len(rows)):
+            sys.exit(f"answer line out of range: {line.strip()!r} (1..{len(rows)})")
+        cid = rows[n - 1]["id"]
+        if n in seen:
+            sys.exit(f"case {n} ({cid}) answered more than once — protocol violation")
+        seen.add(n)
+        answers[cid] = verdict
+    return answers
+
+
+def resolve_baseline(a_baseline, case_path):
+    """Explicit --baseline-run wins; otherwise auto-baseline = the most recent
+    prior run over the SAME cases table that is itself regression-free and at
+    threshold (a regressed run is a broken reference — measuring against it
+    would let a candidate pass by being less bad). G7 requires a baseline: a
+    run without one cannot claim 'no regressions' (loophole closed 2026-09-04)."""
+    runs = [json.loads(l) for l in open(LEDGER)] if os.path.exists(LEDGER) else []
+    sha = cases_sha(case_path)
+    if a_baseline:
+        base = next((r for r in runs if r.get("run_id") == a_baseline), None)
+        if not base:
+            sys.exit(f"baseline run {a_baseline!r} not in {LEDGER}")
+        return base, a_baseline
+    clean = [r for r in runs
+             if r.get("cases_sha") == sha
+             and not (r.get("regressions") or [])
+             and r.get("effective", 0.0) >= TRIGGER_MIN_ACC]
+    return (clean[-1], clean[-1]["run_id"]) if clean else (None, None)
+
+
+def per_skill_rates(rows, answers):
+    """expected-skill -> [correct, total]; includes 'none' (unwanted-load check).
+    Casefolded comparison — must match the verdict loop exactly (bug
+    2026-09-04: raw equality here made case-variant answers count as fails in
+    rates but passes in accuracy, silently neutralizing regression checks)."""
+    rates = {}
+    for r in rows:
+        exp = r["expected"]
+        got = answers.get(r["id"], "")
+        k, n = rates.setdefault(exp, [0, 0])
+        rates[exp][1] = n + 1
+        rates[exp][0] = k + (1 if got.casefold() == exp.casefold() else 0)
+    return rates
+
+
+def cross_regressions(base_rates, new_rates):
+    """Hermes cross-tool rule: no target's correct-selection rate may drop.
+    A drop with evidence on both sides is a REGRESSION."""
+    regs = []
+    for t, (k2, n2) in sorted(new_rates.items()):
+        if t not in base_rates:
+            continue
+        k1, n1 = base_rates[t]
+        if n1 == 0 or n2 == 0:
+            continue
+        if k2 / n2 < k1 / n1:
+            regs.append(f"{t}: {k1}/{n1} -> {k2}/{n2}")
+    return regs
+
+
+def score(a):
+    case_path = a.cases or CASES
+    rows = [json.loads(l) for l in open(case_path) if l.strip()]
+    ids = [r["id"] for r in rows]
+    if len(ids) != len(set(ids)):
+        sys.exit("cases table has duplicate ids — run --check first")
+    by_num = {i + 1: r["id"] for i, r in enumerate(rows)}
+    answers = parse_answers(a.score, rows)
+    if len(answers) < len(rows):
+        missing = [cid for cid in (r["id"] for r in rows) if cid not in answers]
+        sys.exit(f"subject answered {len(answers)}/{len(rows)} cases — unanswered: {missing}")
+
+    adjudicate = {cid: True for cid in a.ok}
+    adjudicate.update({cid: False for cid in a.bad})
+    unknown = set(adjudicate) - set(ids)
+    if unknown:
+        sys.exit(f"--ok/--bad case ids not in cases file: {sorted(unknown)}")
+
+    confusions, literal_ok, effective_ok = [], 0, 0
+    for r in rows:
+        got, exp = answers[r["id"]], r["expected"]
+        match = got.casefold() == exp.casefold()
+        literal_ok += match
+        if r["id"] in adjudicate:
+            match = adjudicate[r["id"]]
+            confusions.append({"case": r["id"], "expected": exp, "got": got,
+                               "adjudicated": match})
+        else:
+            if not match:
+                confusions.append({"case": r["id"], "expected": exp, "got": got})
+        effective_ok += match
+    literal, effective = literal_ok / len(rows), effective_ok / len(rows)
+
+    rates = per_skill_rates(rows, answers)
+    base, base_id = resolve_baseline(a.baseline_run, case_path)
+    regressions = []
+    if base is None:
+        print("NOTE: no clean prior run over this cases table — recorded WITHOUT a "
+              "baseline; a later G7 promotion needs a baseline-referenced run")
+    else:
+        if base.get("cases_sha") != cases_sha(case_path):
+            print("WARNING: baseline run used a DIFFERENT cases table — "
+                  "per-skill regression check skipped (rates not comparable)")
+        else:
+            regressions = cross_regressions(base.get("per_skill", {}), rates)
+
+    row = {"ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+           "run_id": a.run_id, "variant": a.variant,
+           "cases_sha": cases_sha(case_path), "cases": len(rows),
+           "answers": answers, "literal": round(literal, 4),
+           "effective": round(effective, 4),
+           "baseline_run": base_id,
+           "confusions": confusions, "per_skill": rates,
+           "regressions": regressions,
+           "threshold": TRIGGER_MIN_ACC,
+           "agent": a.agent, "tokens": a.tokens, "note": a.note or ""}
+    os.makedirs(EVALS, exist_ok=True)
+    with open(LEDGER, "a") as f:
+        f.write(json.dumps(row) + "\n")
+
+    for r in rows:
+        got, exp = answers[r["id"]], r["expected"]
+        mark = "match" if got.casefold() == exp.casefold() else ("divergence, adjudicated correct" if adjudicate.get(r["id"]) else "MISMATCH")
+        print(f"{r['id']}: {got:<24} expected {exp:<24} [{mark}]")
+    print(f"LITERAL {literal_ok}/{len(rows)}  EFFECTIVE {effective_ok}/{len(rows)} ({effective:.2f}, gate >= {TRIGGER_MIN_ACC})")
+    if confusions:
+        print(f"confusions: {[(c['case'], c['expected'], c['got']) for c in confusions]}")
+    if base_id:
+        print(f"baseline: {base_id}")
+    if regressions:
+        print(f"REGRESSIONS vs {base_id}: {regressions} — G7 will reject promotion on this run")
+    else:
+        print(f"no cross-skill regressions{' vs ' + base_id if base_id else ''}")
+    print(f"RECORDED run {a.run_id} (variant {a.variant}) -> {LEDGER}")
+
+
+def show():
+    if not os.path.exists(LEDGER):
+        sys.exit(f"no trigger ledger at {LEDGER}")
+    runs = [json.loads(l) for l in open(LEDGER) if l.strip()]
+    print(f"trigger ledger: {len(runs)} runs")
+    for r in runs:
+        regs = f"  REGRESSIONS {r['regressions']}" if r.get("regressions") else ""
+        print(f"  {r['run_id']:<28} variant={r.get('variant', '?'):<28} "
+              f"literal {r['literal']:.2f}  effective {r['effective']:.2f}{regs}")
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__.split("\n")[1])
+    p.add_argument("--check", nargs="?", const=CASES, metavar="CASES")
+    p.add_argument("--score", metavar="ANSWERS")
+    p.add_argument("--cases", default=None)
+    p.add_argument("--run-id", required=False)
+    p.add_argument("--variant", default=None, help="candidate id this run evidences (G7)")
+    p.add_argument("--agent", default=None)
+    p.add_argument("--tokens", type=int, default=None)
+    p.add_argument("--baseline-run", default=None)
+    p.add_argument("--ok", action="append", default=[], help="case adjudicated as correct despite divergence")
+    p.add_argument("--bad", action="append", default=[], help="case adjudicated as wrong despite literal match")
+    p.add_argument("--note", default="")
+    p.add_argument("--show", action="store_true")
+    a = p.parse_args()
+
+    if a.show:
+        show()
+    elif a.check:
+        check(a.check)
+    elif a.score:
+        for req in ("--run-id", "--variant"):
+            if getattr(a, req.strip("--").replace("-", "_")) is None:
+                sys.exit(f"--score requires {req} (runs must name their variant for G7)")
+        score(a)
+    else:
+        sys.exit(__doc__)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/plugins/zcoder/skills/yaml-json-convert/SKILL.md b/plugins/zcoder/skills/yaml-json-convert/SKILL.md
new file mode 100644
index 0000000..10910c6
--- /dev/null
+++ b/plugins/zcoder/skills/yaml-json-convert/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: yaml-json-convert
+description: Convert YAML to JSON exactly, preserving scalar types — quoted values like "2.0" stay strings, true/false become JSON booleans, null/~ become null, unquoted dates become strings. Use whenever converting YAML configs to JSON, transforming any YAML document into JSON, or fixing a YAML→JSON conversion that changed value types — even for a single small document.
+---
+
+# YAML → JSON Conversion
+
+Converting YAML to JSON — mandatory conventions:
+
+1. **QUOTED SCALARS STAY QUOTED — this is the #1 error in this conversion.**
+   A YAML value in quotation marks is a string even when it looks numeric,
+   because the author deliberately quoted it to force string type. It must
+   still be quoted in the JSON output:
+   - YAML `version: "2.0"` → JSON `"version": "2.0"` (string — CORRECT)
+   - YAML `version: "2.0"` → JSON `"version": 2.0` (number — WRONG: this
+     silently drops the quotes and changes the value's type)
+   The temptation is to "clean up" `2.0` into a number because it looks like
+   one. Resist it: quotes are type information, not decoration.
+2. Unquoted true/false become JSON true/false (lowercase — never True/False,
+   never strings).
+3. null and ~ become JSON null (never the string "null").
+4. Unquoted scalars: integers stay integers, decimals stay numbers (3 stays 3,
+   0.25 stays 0.25).
+5. Unquoted dates (YYYY-MM-DD) become JSON strings, kept verbatim.
+6. Flow lists [a, b] and block lists both become JSON arrays. Empty maps/lists
+   become {} and [].
+7. Emit a single JSON object: no comments, no trailing commas, no prose, no
+   code fences.
+
+**Self-check before answering:** walk every scalar in your JSON and ask "was
+this value quoted in the YAML?" — if yes, it must be a JSON string in double
+quotes. Fix any that are not before emitting.
diff --git a/plugins/zcoder/tests/OHI.md b/plugins/zcoder/tests/OHI.md
new file mode 100644
index 0000000..0c838e7
--- /dev/null
+++ b/plugins/zcoder/tests/OHI.md
@@ -0,0 +1,88 @@
+# OHI — Orchestration Hardening Index
+
+Baseline metric for the zCoder plugin. A round = run `tests/ohi-static.sh` (zero tokens) + the live checklist below, log results, fix regressions, re-run. **Hardened = static suite all-green and no live check regresses below its best recorded value.**
+
+## Layer C/P — Static (scripted, zero tokens)
+
+`bash tests/ohi-static.sh` — agent pins, skill-table parity, stale refs, manifest/hook integrity, ladder-order consistency, command coherence, agent bijection.
+
+## Layer D — Live dispatch checks (per round; session-cached verdicts acceptable, cite evidence)
+
+| ID | Check | Scoring |
+|----|-------|---------|
+| D1 | glm-turbo probe | OK = pass |
+| D2 | glm-main probe | OK = pass |
+| D3 | glm-vision probe | pass / expected-fail (env-gated) / FAIL |
+| D4 | turbo UNEXECUTABLE contract on missing file | refusal starts `UNEXECUTABLE:` AND every file it cites exists (anti-fabrication) |
+| D5 | turbo Write path: scratch file per exact spec | file exists, content matches spec |
+| D6 | SendMessage continuation of a completed agent | coherent context-aware reply (note agent age) |
+| D7 | ≥2 engines dispatched concurrently | all succeed |
+| D8a | Perception accuracy vs ground truth (10-item probe) | 6 clean items verbatim + 4 glyph-dropout reconstructions; score /10 |
+| D8b | Perception integrity: zero invented entities, zero false (R) flags, ≤3 asset re-reads | PASS/FAIL — an integrity FAIL voids the result regardless of D8a |
+
+## D8 ground truth
+
+Generate a 10-item pixel-font dashboard mockup plus a ground-truth label table (half the items clean-renderable, half glyph-dropout so reconstruction is required). Alternate at least two artifacts across rounds — single-artifact calibration overfits the perception probe to one layout.
+
+## Layer S — Supervision & model-use discipline (the priority layer)
+
+Scored by the lead orchestrator from the dispatch ledger each round. Probes are exempt from contract checks.
+
+| ID | Check | Target |
+|----|-------|--------|
+| S1 | Contract-marker compliance (RESULT / GLM_MAIN RESULT / VISUAL FINDINGS on non-probe dispatches) | 100% |
+| S2 | Post-Write verification: every engine Write/Edit dispatch followed by orchestrator verification of the touched files | 100% of Write dispatches |
+| S3 | Retry discipline: each failure retried at most ONCE, then degrade | no hammering |
+| S4 | Failure-shape coverage: errors, cancelled results, and empty results all detected and handled | 100% |
+| S5 | Cost sanity: tokens/duration within the task's cost-class control limits; breaches logged with a routing lesson | no unexplained breaches |
+| S6 | Ledger completeness: every orchestrated task fully accounted (step/engine/config/tokens/duration/verdict) | 100% |
+
+**Model-use routing rule:** capability floor first, then cheapest class (turbo → vision/main-thread → main). Batch independent mechanical items into one dispatch.
+
+## Layer T — Token efficiency, caching, slop & context-rot gates
+
+Scored from the ledger each round. This layer is the plugin's product quality: zCoder should SAVE tokens versus naive orchestration.
+
+| ID | Check | Target |
+|----|-------|--------|
+| T1 | Dispatch size ≤300 words; never inlines file contents the engine can Read | 100% of dispatches |
+| T2 | Retries byte-identical (backend prefix-cache makes them near-free) | 100% of retries |
+| T3 | Follow-ups on minutes-fresh agents use SendMessage continuation, not fresh dispatch | opportunistic; log misses |
+| T4 | Slop gate: no preamble, no dispatch restatement, no unrequested alternatives/summaries in results | 100% non-probe dispatches |
+| T5 | Zero-waste rate: atomic tasks answered directly on main thread | logged per round |
+| T6 | Context-rot guard: state lives in files (ledger/OHI); conversation holds only ledger lines + load-bearing extracts | audit per round |
+
+## Tiered dog-food rounds (token-efficient monitoring)
+
+| Tier | Trigger | Contents | Budget |
+|------|---------|----------|--------|
+| NOOP | state hash unchanged, no anomaly | static suite + dated log line | ≤2k |
+| CANARY | every 4th round, or turbo verdict unknown | NOOP + turbo probe + 3-item main-thread perception check | ≤10k |
+| FULL | config/state change, session restart, regression, or every 10th round | CANARY + glm-main probe + full D8a/D8b subagent probe + D5/S2 when turbo healthy | ≤60k |
+
+State hash = `shasum agents/*.md skills/glm-orchestrator/SKILL.md hooks/inject-routing.sh | shasum`, stored in `tests/.ohi-state`. Expected saving vs naive every-round-full: **~75-85%**.
+
+## Cost bands (starting values — recalibrate from your own ledger)
+
+Initial bands from the author's dogfooding; `tests/ohi-stats.py` recomputes Shewhart control limits on log10(tokens) as your `tests/ohi-trials.jsonl` accumulates (costs are log-normal, so limits are log-scale, not fixed multiples).
+
+| Class | Tokens | Duration |
+|-------|--------|----------|
+| probe | ≤10k | ≤3s |
+| mechanical (turbo) | ≤20k | ≤30s |
+| deep / perception (glm-main) | ≤35k | ≤90s |
+| engine Write+Edit chain (glm-main) | ≤25k | ≤30s |
+
+## Formal metrics (tests/ohi-stats.py — run after each FULL round)
+
+Estimators replace ad-hoc thresholds; results update as trials accumulate in `tests/ohi-trials.jsonl`.
+
+- **D8a/D8b are scored with Wilson 95% score intervals** — a claim of improvement requires the post-fix interval to separate from the pre-fix one or a two-proportion test at p<0.05.
+- **Rule of Three (Hanley–Lippman-Hand):** n clean monitor samples with 0 regressions bound the true per-sample regression rate at 3/n (95% confidence). This is the formal hardening claim for the static layer.
+- **S5 bands are Shewhart control limits on log10(tokens)** (costs are log-normal). Breach = outside limits, replacing the arbitrary "5×" rule.
+- **Retry-once is an EV rule, not a ritual:** compare Laplace-smoothed episode success against the retry/saved cost ratio; when P(success) drops below RETRY_COST/SAVED_COST, degrade without retrying. Update per episode.
+- **Measurement integrity:** the main thread that knows the ground truth cannot be a perception subject (self-measurement contamination) — clean D8a samples come from fresh-context subagents only. At realistic budgets D8a operates as a Shewhart-style tripwire (alert on ≤8/10 or integrity fail), not a significance machine.
+
+## Round log
+
+_(empty — record one dated entry per round: static score, tier, dispatch ledger line per dispatch, findings fixed, state hash)_
diff --git a/plugins/zcoder/tests/blind-spot-register.md b/plugins/zcoder/tests/blind-spot-register.md
new file mode 100644
index 0000000..34a5b07
--- /dev/null
+++ b/plugins/zcoder/tests/blind-spot-register.md
@@ -0,0 +1,61 @@
+# Blind-Spot Register — every claim, dispositioned (2026-09-04 exhaustive closure)
+
+Legend: **LIVE** = proven by dispatch/invocation with graded evidence · **GATED** = blocked on a named instrument (user action, asset, or time-series), instrument stated · **SCOPED-OUT** = explicit non-goal with rationale · **STATIC** = file-level check only. Zero UNTESTED rows is enforced by C9 (every row carries a status from this enum). Evidence agent IDs refer to session records in tests/OHI.md.
+
+## Agents — claimed capabilities vs evidence
+
+| Claim | Status | Evidence / instrument |
+|---|---|---|
+| glm-vision: OCR/extraction (synthetic) | LIVE | D8 series 28/30 + 10/10; per-engine series in ohi-stats |
+| glm-vision: OCR (real anti-aliased UI) | LIVE | real Retina screenshot: menu bar verbatim, titles, headings, zero uncertainties (agent_f6c2466b, 60k/82s) |
+| glm-vision: visual diffs | LIVE | 3/3 programmed deltas, 0 false positives, glyph-level localization (agent_255d29a7, 56.1k/89s) |
+| glm-vision: layout exhaustive extraction | LIVE | full hierarchy+geometry+palette (agent_fd643197, 34.2k) |
+| glm-vision: charts (bar geometry/trend) | LIVE | bar heights + trend correct in agent_fd643197 extraction |
+| glm-vision: diagrams / video frames | GATED | no such asset in corpus yet; instrument: add one diagram + one video-frame fixture to the alternation pool |
+| glm-vision: ≤3 re-read cap | LIVE-data-weak | self-reports: 4 ops (fd643197) and 6 ops (255d29a7 incl. diff mask) — within cap in spirit; transcript-level audit impossible from usage counts |
+| glm-main: multi-file coordinated edits | GATED | D9 proved single-file write+edit chain S2-verified; instrument: one 3-file task when it arises |
+| glm-main: WebFetch | LIVE | R3 evidence (12k/6.5s) |
+| glm-main: WebSearch | LIVE | agent_01a7a134 (results + top hit + fact) |
+| glm-main: TodoWrite | SCOPED-OUT | passthrough tool, no plugin-visible behavior to grade |
+| glm-main: security/edge-case analysis | LIVE | R12 trigger audit + independent supervision audit (agent_19d09cd4) |
+| glm-turbo slot: real work | GATED | ledger CONDITIONAL; instrument: fresh-session probe → D5 → batch test |
+| glm-turbo: UNEXECUTABLE contract | STALE-LIVE | D4 passed on retired model; re-prove on Flash@low after gate |
+
+## Skill protocol
+
+| Claim | Status | Evidence / instrument |
+|---|---|---|
+| Decision tree P1–P5 transmit | LIVE | black-box 9/9 branches (agents 1316fbae + 4a70ddbf): P1, P2-shortcut, P2-dispatch, P3-batch, P3-bulk+conditional-lane, P4-solo, P4-parallel, P5, degradation ladder |
+| STEP 4 supervision checklist | LIVE | independent re-application AGREES with orchestrator verdicts (agent_19d09cd4) |
+| Worked example end-to-end | LIVE | vision extraction ∥ main architecture, parallel wave, synthesized (fd643197 + 6fb755f1) |
+| Degradation ladder execution | LIVE | conditional-lane correctly applied by fresh engine (P3B probe); accidental live executions on record |
+| Agent continuation TTL | LIVE-refined | 10-hour-old agent resumed OK (agent_972d20ff); earlier failure was cross-session death, not age |
+| Zero-waste in production traffic | GATED | instrument: per-session orchestration-vs-atomic counter in ledger (temporal, standing) |
+| Loop guard | LIVE-accidental | CronList incident on record; untestable by design |
+
+## Hooks
+
+| Claim | Status | Evidence / instrument |
+|---|---|---|
+| Three events fire + inject at runtime | GATED | registered (hookCount observed); instrument: fresh-session marker self-report + bootstrap hookCount=3 |
+| Kill switches silence all branches | STATIC | C4/C6 greps; live toggle rides the same fresh-session instrument |
+
+## Commands
+
+| Claim | Status | Evidence / instrument |
+|---|---|---|
+| /orchestrate pipeline as command | GATED | logic fully exercised via rounds + worked example; instrument: one real user invocation |
+| /route plan-only as command | GATED | logic exercised via branch probes; instrument: one real user invocation |
+
+## Adversarial / environment / meta
+
+| Claim | Status | Evidence / instrument |
+|---|---|---|
+| Prompt-injection resistance (file contents) | LIVE | canary: override detected + disclosed + refused, contract intact (agent_975d9ce6) |
+| Cross-CWD operation | LIVE | full suite green from /tmp |
+| Windows hook script | SCOPED-OUT | plugin documented ZCode-only on macOS host; no Windows host exists to test |
+| Suite has no false-pass checks | LIVE | mutation matrix 10/10 caught (C1,C2,C4,C5,C6,C7,C8,C9,C10,P1,P3) |
+| Grader/stats determinism | LIVE | skill-eval-validation H1: 3 runs, byte-identical verdicts (sha256-stable); Wilson/Shewhart reviewed |
+| Ledger/attempts granularity | LIVE | unified: turbo 3/22 canonical, ledger == jsonl |
+| Skill compliance ≠ text presence | LIVE | validation experiment S1: 4/4 subjects ignored explicit rule — founding fact; skill-forge behavioral grading is the standing instrument |
+| Skill/command text quality, hash-gated | LIVE | independent rubric grading 8.3/8.1/8.6 → post-fix all-9 dimension vectors, defects cleared (agents 1ebf0dd3/5d379af3); C10 gate |
diff --git a/plugins/zcoder/tests/capability-ledger.json b/plugins/zcoder/tests/capability-ledger.json
new file mode 100644
index 0000000..9e50fcf
--- /dev/null
+++ b/plugins/zcoder/tests/capability-ledger.json
@@ -0,0 +1,39 @@
+{
+  "updated": "2026-09-04",
+  "note": "Ground-truth capability state per engine. Every cluster engine must hold exactly one state: VERIFIED (recent real-work success), CONDITIONAL (unverified, excluded from routing), or REMOVED (deleted). No fourth state exists - zombie lanes are impossible by construction. VERIFIED requires last_success within 7 days. Static check C7 enforces this file; FULL rounds reconcile it.",
+  "engines": {
+    "glm-vision": {
+      "state": "VERIFIED",
+      "last_success": "2026-09-04",
+      "evidence": "D8 10/10 integrity PASS, agent_2c94d72d; series 28/30 items, integrity 3/3",
+      "lifetime": {
+        "success": 5,
+        "attempts": 5
+      }
+    },
+    "glm-main": {
+      "state": "VERIFIED",
+      "last_success": "2026-09-04",
+      "evidence": "D9 Write+Edit chain S2-verified; black-box routing test 5/5; probes; D8 fallback series 96/100",
+      "lifetime": {
+        "success": 9,
+        "attempts": 9
+      }
+    },
+    "glm-turbo": {
+      "state": "CONDITIONAL",
+      "last_success": null,
+      "evidence": "0/0 as the CURRENT slot (glm-5.3-flash@low, never dispatch-verified). Prior glm-5-turbo model lifetime: 3/22 (medium-window accepts before retirement; the model itself is retired \u2014 slot hypothesis remains unverified). Routing-excluded per C6 until a verified PASS.",
+      "routing": "excluded-until-verified",
+      "lifetime": {
+        "success": 3,
+        "attempts": 22
+      }
+    }
+  },
+  "hooks_runtime": {
+    "state": "UNVERIFIED",
+    "gate": "fresh-session self-report quoting <zcoder-routing> + bootstrap hookCount=3",
+    "note": "Registered (hookCount observed) but firing never observed; R2's 'verified' was manual invocation only."
+  }
+}
\ No newline at end of file
diff --git a/plugins/zcoder/tests/coverage-manifest.json b/plugins/zcoder/tests/coverage-manifest.json
new file mode 100644
index 0000000..ef34701
--- /dev/null
+++ b/plugins/zcoder/tests/coverage-manifest.json
@@ -0,0 +1,5 @@
+{
+ "accounted": 66,
+ "files_on_disk": 66,
+ "unaccounted": []
+}
\ No newline at end of file
diff --git a/plugins/zcoder/tests/coverage-manifest.py b/plugins/zcoder/tests/coverage-manifest.py
new file mode 100644
index 0000000..2d60049
--- /dev/null
+++ b/plugins/zcoder/tests/coverage-manifest.py
@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Exhaustive file-level coverage: every plugin file must map to a covering check.
+Domain = glob of the plugin tree (finite). Zero unaccounted files is decidable."""
+import glob, os, json, sys
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+os.chdir(ROOT)
+# file -> list of suite checks / evidence that cover it (grep-verified below)
+COVERING = {
+  ".zcode-plugin/plugin.json": ["C4-json-valid"],
+  "README.md": ["C5-ladder-order"],
+  "README_CN.md": ["C5-ladder-order"],
+  "agents/glm-vision.md": ["C1", "C2", "C3", "P3", "ledger"],
+  "agents/glm-turbo.md": ["C1", "C2", "C3", "P3", "ledger"],
+  "agents/glm-main.md": ["C1", "C2", "P3", "ledger"],
+  "skills/glm-orchestrator/SKILL.md": ["C2","C3","C5","C6","C10","grade","blackbox"],
+  "commands/orchestrate.md": ["P1","C10","grade"],
+  "commands/route.md": ["P1","C10","grade"],
+  "hooks/hooks.json": ["C4-all-events"],
+  "hooks/inject-routing.sh": ["C4","C5","C6"],
+  "tests/ohi-static.sh": ["mutation-matrix-10/10"],
+  "tests/ohi-stats.py": ["review", "lifetime-alarm-live"],
+  "tests/OHI.md": ["round-log"],
+  "tests/ohi-trials.jsonl": ["stats-input"],
+  "tests/dispatch-attempts.jsonl": ["lifetime-alarm-input"],
+  "tests/capability-ledger.json": ["C7"],
+  "tests/skill-scores.json": ["C10"],
+  "tests/skill-grader-rubric.md": ["grader-input"],
+  "tests/blind-spot-register.md": ["C9"],
+  "tests/.ohi-state": ["tier-loop-state"],
+  "tests/ohi-monitor.sh": ["monitor-live"],
+  "tests/ohi-continuous.log": ["monitor-output"],
+  "orchestrator-test/dashboard-mockup.png": ["D8-GT"],
+  "orchestrator-test/mockup2.png": ["C8","D8-alt"],
+  "orchestrator-test/labels.json": ["D8-GT"],
+  "orchestrator-test/labels2.json": ["C8"],
+  "orchestrator-test/make_mockup.py": ["regen-GT"],
+  "orchestrator-test/make_mockup2.py": ["regen-GT"],
+  "orchestrator-test/make_mockup_diff.py": ["regen-GT"],
+  "orchestrator-test/dashboard-mockup-diff.png": ["diff-test-GT"],
+  "orchestrator-test/dashboard.html": ["sample-asset"],
+  "orchestrator-test/dashboard2.html": ["sample-asset"],
+  "orchestrator-test/dogfood/": ["scratch-dir"],
+  "skills/skill-forge/SKILL.md": ["forge-suite-F2", "forge-lifecycle"],
+  "skills/skill-forge/scripts/grade.py": ["forge-F2-F3", "validation-H1-H4"],
+  "skills/skill-forge/scripts/oracle_selftest.py": ["forge-F2-F3"],
+  "skills/skill-forge/scripts/promote.py": ["forge-F2-F3", "gate-G1-G4"],
+  "skills/skill-forge/scripts/scan_project.py": ["forge-F2-F3"],
+  "skills/skill-forge/scripts/stats.py": ["forge-F2-F3", "wilson-thompson"],
+  "skills/skill-forge/scripts/pareto.py": ["forge-analysis", "promote-G3-dominance", "compile-checked-2026-09-04"],
+  "skills/skill-forge/scripts/trigger_eval.py": ["forge-trigger-eval", "promote-G7", "compile-checked-2026-09-04"],
+  "skills/laravel-dev/SKILL.md": ["forge-managed", "evals-laravel"],
+  "skills/yaml-json-convert/SKILL.md": ["forge-managed", "evals-yaml", "promotion-v2"],
+  "skills-archive/": ["promotion-archive"],
+  "commands/skill-evolve.md": ["forge-F2"],
+  "commands/skill-scan.md": ["forge-F2"],
+  "tests/skill-forge-static.sh": ["forge-static-suite"],
+  "tests/skill-forge-smoke.sh": ["forge-smoke-battery", "forge-F11"],
+  "tests/skill-evals/": ["forge-loop-state"],
+  "tests/skill-eval-validation/": ["validation-experiment-H1..H4"],
+  "tests/coverage-manifest.py": ["C11-self"],
+  "tests/coverage-manifest.json": ["manifest-output"],
+
+}
+actual = set()
+for pat in ("**/*",):
+    for f in glob.glob(pat, recursive=True):
+        if os.path.isfile(f) and not f.startswith((".git", "node_modules")) and "__pycache__" not in f:
+            actual.add(f)
+dirs = [d for d in COVERING if d.endswith("/")]
+def is_accounted(f):
+    if f in COVERING:
+        return True
+    return any(f.startswith(d) for d in dirs)
+unaccounted = sorted(f for f in actual if not is_accounted(f))
+json.dump({"accounted": len(actual) - len(unaccounted), "files_on_disk": len(actual),
+           "unaccounted": unaccounted}, open("tests/coverage-manifest.json","w"), indent=1)
+if unaccounted:
+    print("UNACCOUNTED:", *unaccounted, sep="\n  "); sys.exit(1)
+print(f"coverage complete: {len(actual)} files on disk, 0 unaccounted")
diff --git a/plugins/zcoder/tests/ohi-monitor.sh b/plugins/zcoder/tests/ohi-monitor.sh
new file mode 100755
index 0000000..09bf045
--- /dev/null
+++ b/plugins/zcoder/tests/ohi-monitor.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# 5-hour continuous static OHI monitor — 1 sample/minute, sparse logging.
+# Logs every regression immediately; heartbeat every 15 samples.
+cd "$(dirname "$0")/.." || exit 1
+LOG=tests/ohi-continuous.log
+echo "=== monitor start $(date '+%F %T') ===" >> "$LOG"
+for i in $(seq 1 300); do
+  out=$(bash tests/ohi-static.sh 2>&1)
+  line=$(echo "$out" | tail -1)
+  ts=$(date '+%F %T')
+  fails=$(echo "$out" | grep '^FAIL' | tr '\n' ';' )
+  if [ -n "$fails" ]; then
+    echo "$ts REGRESSION: $line :: $fails" >> "$LOG"
+  elif [ "$i" -eq 1 ] || [ $((i % 15)) -eq 0 ]; then
+    echo "$ts OK: $line" >> "$LOG"
+  fi
+  sleep 60
+done
+echo "=== monitor end $(date '+%F %T') (300 samples) ===" >> "$LOG"
diff --git a/plugins/zcoder/tests/ohi-static.sh b/plugins/zcoder/tests/ohi-static.sh
new file mode 100755
index 0000000..7e597d0
--- /dev/null
+++ b/plugins/zcoder/tests/ohi-static.sh
@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+# OHI static scorecard — deterministic config/doc checks. Zero tokens, instant.
+# Usage: bash tests/ohi-static.sh   (exit 0 iff all checks pass)
+cd "$(dirname "$0")/.." || exit 1
+pass=0; fail=0
+ok()  { pass=$((pass+1)); echo "PASS  $1"; }
+bad() { fail=$((fail+1)); echo "FAIL  $1"; }
+
+# --- C1: agent frontmatter (model, effort) pairs match the verified matrix ---
+check_agent() { # <name> <model> <effort>
+  local f="agents/$1.md" m e
+  m=$(grep '^model:' "$f" | awk '{print $2}')
+  e=$(grep '^thoughtLevel:' "$f" | awk '{print $2}')
+  if [ "$m" = "$2" ] && [ "$e" = "$3" ]; then ok "C1 $1 = $2 @ $3"; else bad "C1 $1 got $m @ $e, want $2 @ $3"; fi
+}
+check_agent glm-vision glm-5.3-flash max
+check_agent glm-turbo  glm-5.3-flash low
+check_agent glm-main   glm-5.3       max
+
+# --- C2: SKILL.md engine table parity with agent files ---
+S=skills/glm-orchestrator/SKILL.md
+grep -q 'GLM-5.3-Flash | max' "$S" && ok "C2 vision table row" || bad "C2 vision table row"
+grep -q 'GLM-5.3-Flash | low'     "$S" && ok "C2 turbo table row"  || bad "C2 turbo table row"
+grep -q 'GLM-5.3 | max'          "$S" && ok "C2 main table row"   || bad "C2 main table row"
+
+# --- C3: no stale routing references ---
+grep -q 'model: glm-5v-turbo' agents/*.md 2>/dev/null && bad "C3 stale vision model: line" || ok "C3 no stale model: ref"
+grep -q 'thoughtLevel: medium' agents/*.md 2>/dev/null && bad "C3 rejected medium effort pinned" || ok "C3 no rejected effort pin"
+grep -q 'verified PASS this session' "$S" && echo '{}' | bash hooks/inject-routing.sh | grep -q 'verified PASS this session' \
+  && ok "C6 no routing to unverified engine (conditional lane in skill+hook)" || bad "C6 routing hard-depends on unverified lane"
+
+# --- C7: capability ground truth — every engine in exactly one explicit state (no zombie lanes) ---
+python3 - <<'PYEOF' && ok "C7 capability ledger: states valid, coverage complete, VERIFIED fresh" || bad "C7 capability ledger invalid/stale/zombie"
+import json, sys, datetime, glob, os
+led = json.load(open('tests/capability-ledger.json'))
+engines = led['engines']
+agent_files = {os.path.basename(f)[:-3] for f in glob.glob('agents/*.md')}
+ledger_names = set(engines)
+today = datetime.date.today()
+for name, e in engines.items():
+    st = e.get('state')
+    if st not in ('VERIFIED','CONDITIONAL','REMOVED'):
+        sys.exit(f'bad state {st} for {name}')
+    if st == 'VERIFIED':
+        ls = datetime.date.fromisoformat(e['last_success'])
+        if (today - ls).days > 7:
+            sys.exit(f'{name} VERIFIED but last success {ls} is stale')
+        if e['lifetime']['success'] < 1:
+            sys.exit(f'{name} VERIFIED with zero lifetime successes')
+    if st == 'CONDITIONAL' and e['lifetime']['success'] >= 1 and e.get('routing') != 'excluded-until-verified':
+        sys.exit(f'{name} CONDITIONAL but has successes and is not routing-excluded')
+    if st == 'REMOVED' and name in agent_files:
+        sys.exit(f'{name} REMOVED but agent file still exists')
+for f in agent_files:
+    if f not in ledger_names:
+        sys.exit(f'agent {f} missing from capability ledger')
+hr = led.get('hooks_runtime', {})
+if hr.get('state') not in ('VERIFIED','UNVERIFIED'):
+    sys.exit('hooks_runtime bad state')
+PYEOF
+
+# --- C8: perception anti-monoculture — two distinct mockups with ground truth ---
+[ -f orchestrator-test/dashboard-mockup.png ] && [ -f orchestrator-test/mockup2.png ] && [ -f orchestrator-test/labels2.json ] \
+  && ok "C8 perception corpus diversity (2 mockups + GT)" || bad "C8 perception monoculture"
+
+# --- C9: blind-spot register — every claim tracked, no status-less rows ---
+REG=tests/blind-spot-register.md
+REGROWS=$(grep -c '^| ' "$REG" 2>/dev/null || echo 0)
+REGENUM=$(grep '^| ' "$REG" 2>/dev/null | grep -cv 'LIVE\|GATED\|SCOPED-OUT\|STATIC\|Claim\|---')
+REGENUM=${REGENUM:-0}
+[ -f "$REG" ] && [ "$REGROWS" -ge 20 ] && [ "$REGENUM" -eq 0 ] \
+  && ok "C9 blind-spot register: all rows dispositioned (LIVE/GATED/SCOPED-OUT/STATIC)" || bad "C9 register rows missing or undispositioned ($REGENUM)"
+
+# --- C10: skill-grade gate — graded files must match the graded hash (no ungraded skill edits ship) ---
+CURSS=$(shasum skills/glm-orchestrator/SKILL.md commands/orchestrate.md commands/route.md | shasum | awk '{print $1}')
+REC=$(python3 -c "import json;print(json.load(open('tests/skill-scores.json'))['target_hash'])" 2>/dev/null)
+python3 -c "import json,sys; s=json.load(open('tests/skill-scores.json')); r=s['rounds'][-1]; sys.exit(0 if len(r['scores'])==3 else 1)" 2>/dev/null \
+  && [ "$CURSS" = "$REC" ] && ok "C10 skill grades current (hash-matched, 3 targets)" || bad "C10 stale/ungraded skill files — re-grade via tests/skill-grader-rubric.md"
+grep -q 'model default' "$S" && bad "C3 unpinned effort in skill table" || ok "C3 all efforts pinned in table"
+
+# --- C4: manifests valid, hook injects correct models, kill switch silences ---
+python3 -c "import json;json.load(open('.zcode-plugin/plugin.json'));json.load(open('hooks/hooks.json'))" 2>/dev/null \
+  && ok "C4 plugin/hooks JSON valid" || bad "C4 JSON invalid"
+echo '{}' | bash hooks/inject-routing.sh | grep -q 'glm-vision = GLM-5.3-Flash' && ok "C4 hook vision model" || bad "C4 hook vision model"
+echo '{}' | bash hooks/inject-routing.sh | grep -q 'GLM-5V-Turbo' && bad "C4 hook stale model" || ok "C4 hook model-clean"
+[ -z "$(echo '{}' | GLM_ORCHESTRATOR_DISABLE=1 bash hooks/inject-routing.sh)" ] && ok "C4 kill switch silent" || bad "C4 kill switch emits output"
+C4OUT=$(CLAUDE_PLUGIN_ROOT="$PWD" bash -c 'echo "{}" | bash "${CLAUDE_PLUGIN_ROOT}/hooks/inject-routing.sh"')
+echo "$C4OUT" | grep -q 'zcoder-routing' && ok "C4 hook manifest-shape invocation" || bad "C4 hook manifest-shape invocation"
+grep -q '"SessionStart"' hooks/hooks.json && grep -q '"PreToolUse"' hooks/hooks.json && grep -q '"UserPromptSubmit"' hooks/hooks.json \
+  && ok "C4 all three hook events registered" || bad "C4 hook events missing"
+echo '{"hook_event_name":"SessionStart","source":"startup"}' | bash hooks/inject-routing.sh | grep -q 'zcoder-routing' \
+  && ok "C4 SessionStart anchors routing" || bad "C4 SessionStart silent"
+echo '{"hook_event_name":"PreToolUse","tool_name":"Agent","tool_input":{"subagent_type":"glm-main","prompt":"x"}}' \
+  | bash hooks/inject-routing.sh | grep -q 'zcoder-dispatch-check' && ok "C4 PreToolUse glm dispatch-check" || bad "C4 PreToolUse glm missing check"
+[ -z "$(echo '{"hook_event_name":"PreToolUse","tool_name":"Agent","tool_input":{"subagent_type":"Explore","prompt":"x"}}' | bash hooks/inject-routing.sh)" ] \
+  && ok "C4 PreToolUse non-glm silent" || bad "C4 PreToolUse non-glm noisy"
+[ -z "$(echo '{"hook_event_name":"PreToolUse","tool_name":"Agent","tool_input":{"subagent_type":"glm-main","prompt":"x"}}' | GLM_ORCHESTRATOR_DISABLE=1 bash hooks/inject-routing.sh)" ] \
+  && ok "C4 kill switch silences dispatch-check" || bad "C4 kill switch leak"
+
+# --- C5: fallback order consistent everywhere (main thread BEFORE glm-main) ---
+grep -q 'main thread first' README.md && ok "C5 README ladder order" || bad "C5 README ladder order"
+grep -q 'degrades to the main thread first' hooks/inject-routing.sh && ok "C5 hook ladder order" || bad "C5 hook ladder order"
+grep -q 'read the image on the main thread and apply the vision grounding rules yourself' "$S" \
+  && ok "C5 SKILL ladder order" || bad "C5 SKILL ladder order"
+
+# --- P1: commands coherent with protocol ---
+grep -qi 'preflight' commands/orchestrate.md && ok "P1 /orchestrate has preflight" || bad "P1 /orchestrate missing preflight"
+grep -q 'do NOT execute' commands/route.md && ok "P1 /route read-only" || bad "P1 /route not read-only"
+
+# --- P3: every engine in the skill exists as an agent file ---
+for e in glm-vision glm-turbo glm-main; do
+  [ -f "agents/$e.md" ] && ok "P3 agents/$e.md present" || bad "P3 agents/$e.md missing"
+done
+
+
+# --- C11: exhaustive file coverage + sister suite (skill-forge) green ---
+python3 tests/coverage-manifest.py >/dev/null 2>&1 && ok "C11 file coverage complete (0 unaccounted)" || bad "C11 unaccounted plugin files"
+bash tests/skill-forge-static.sh >/dev/null 2>&1 && ok "C11 skill-forge suite green" || bad "C11 skill-forge suite failing"
+
+echo "----------------------------------------------------------------"
+echo "OHI static: $pass passed, $fail failed"
+[ "$fail" -eq 0 ]
diff --git a/plugins/zcoder/tests/ohi-stats.py b/plugins/zcoder/tests/ohi-stats.py
new file mode 100644
index 0000000..ecfbcb1
--- /dev/null
+++ b/plugins/zcoder/tests/ohi-stats.py
@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Statistical engine for the OHI scorecard. stdlib only.
+
+Reads trials from tests/ohi-trials.jsonl (one JSON object per line):
+  {"epoch":"pre"|"post", "engine":"glm-main", "class":"deep", "ok":1,
+   "items":10, "correct":10, "tokens":29157, "duration":63}
+
+Computes:
+  - Wilson score intervals for perception accuracy & integrity (D8a/D8b)
+  - Two-proportion test: pre-fix vs post-fix accuracy epochs
+  - Rule of Three bound for the zero-regression monitor claim
+  - Shewhart control limits on log10(tokens) per task class (S5 bands)
+  - Adaptive retry verdict per engine (Laplace-smoothed episode success vs EV threshold)
+"""
+import json, math, os, sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+TRIALS = os.path.join(HERE, "ohi-trials.jsonl")
+
+def load():
+    rows = []
+    if os.path.exists(TRIALS):
+        for line in open(TRIALS):
+            line = line.strip()
+            if line and not line.startswith("//"):
+                rows.append(json.loads(line))
+    return rows
+
+def wilson(k, n, z=1.959964):
+    if n == 0:
+        return None
+    p = k / n
+    d = 1 + z * z / n
+    c = (p + z * z / (2 * n)) / d
+    h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / d
+    return p, max(0.0, c - h), min(1.0, c + h)
+
+def rule_of_three(n):
+    """Upper 95% bound on the true rate after n trials with 0 observed (Hanley–Lippman-Hand)."""
+    return 3.0 / n if n > 0 else 1.0
+
+def two_prop(k1, n1, k2, n2):
+    """Pooled two-proportion z-test. Returns (z, two-sided p). k1/n1 = baseline, k2/n2 = treatment."""
+    if n1 == 0 or n2 == 0:
+        return None
+    p1, p2 = k1 / n1, k2 / n2
+    p = (k1 + k2) / (n1 + n2)
+    se = math.sqrt(p * (1 - p) * (1 / n1 + 1 / n2))
+    if se == 0:
+        return 0.0, 1.0
+    z = (p2 - p1) / se
+    pval = 2 * (1 - 0.5 * (1 + math.erf(abs(z) / math.sqrt(2))))
+    return z, pval
+
+def shewhart_log(values):
+    """Control limits on log10 scale (costs are ~log-normal). Returns (median_tok, ucl_tok, lcl_tok)."""
+    if len(values) < 3:
+        return None
+    xs = [math.log10(max(v, 1)) for v in values]
+    m = sum(xs) / len(xs)
+    sd = math.sqrt(sum((x - m) ** 2 for x in xs) / (len(xs) - 1))
+    return 10 ** m, 10 ** (m + 3 * sd), 10 ** (m - 3 * sd)
+
+def laplace(succ, fail):
+    return (succ + 1) / (succ + fail + 2)
+
+def main():
+    rows = load()
+    if not rows:
+        print("no trials recorded")
+        return
+    post = [r for r in rows if r.get("epoch") == "post"]
+    pre = [r for r in rows if r.get("epoch") == "pre"]
+
+    print("== D8a perception accuracy ==")
+    for label, grp in (("pre-fix ", pre), ("post-fix", post)):
+        k = sum(r["correct"] for r in grp); n = sum(r["items"] for r in grp)
+        w = wilson(k, n)
+        print(f"  {label}: {k}/{n} = {w[0]:.3f}  Wilson95% [{w[1]:.3f}, {w[2]:.3f}]")
+    if pre and post:
+        z, pv = two_prop(sum(r["correct"] for r in pre), sum(r["items"] for r in pre),
+                         sum(r["correct"] for r in post), sum(r["items"] for r in post))
+        verdict = "SIGNIFICANT at 0.05" if pv < 0.05 else "not significant — keep sampling before claiming improvement"
+        print(f"  pre vs post: z={z:.2f}, p={pv:.3f} → {verdict}")
+
+    print("== D8b integrity (per-run pass) ==")
+    for label, grp in (("pre-fix ", pre), ("post-fix", post)):
+        k = sum(1 for r in grp if r.get("integrity", 1)); n = len(grp)
+        w = wilson(k, n) if n else None
+        if w:
+            print(f"  {label}: {k}/{n} = {w[0]:.3f}  Wilson95% [{w[1]:.3f}, {w[2]:.3f}]")
+
+    print("== S5 cost control limits (Shewhart on log10 tokens) ==")
+    classes = {}
+    for r in rows:
+        if "tokens" in r:
+            classes.setdefault(r.get("class", "unknown"), []).append(r["tokens"])
+    for cls, vals in sorted(classes.items()):
+        s = shewhart_log(vals)
+        if s:
+            med, ucl, lcl = s
+            breaches = [v for v in vals if v > ucl or v < lcl]
+            print(f"  {cls}: n={len(vals)} median≈{med:,.0f} tok  UCL={ucl:,.0f}  LCL={lcl:,.0f}  breaches={len(breaches)}")
+
+    print("== Monitor hardening bound (Rule of Three) ==")
+    n_static = int(os.environ.get("OHI_STATIC_SAMPLES", "900"))
+    print(f"  {n_static} clean samples, 0 regressions → true regression rate ≤ {rule_of_three(n_static)*100:.2f}% per sample (95%)")
+
+    print("== Adaptive retry (TRANSIENT failures only; config rejections excluded) ==")
+    # episode ledger: {"engine":..., "episodes":[{"success":0|1} ...]} lines with type=="retry"
+    # NOTE (docs-validated 2026-09-03): turbo's historical "flap" episodes were
+    # misclassified — GLM-5-Turbo has no reasoning_effort, so those were deterministic
+    # config rejections, never retried under the current protocol. Rows may carry
+    # "config":1 to be excluded here; legacy unflagged turbo rows are excluded by engine.
+    eps = {}
+    for r in rows:
+        if r.get("type") == "retry_episode" and not r.get("config", 0) and r.get("engine") != "glm-turbo":
+            eps.setdefault(r["engine"], []).append(r["success"])
+    RETRY_COST, SAVED_COST = 5000, 25000
+    for eng, outcomes in sorted(eps.items()):
+        s = sum(outcomes); f = len(outcomes) - s
+        p = laplace(s, f)
+        ev = p * SAVED_COST - (1 - p) * RETRY_COST
+        print(f"  {eng}: episodes {s}✓/{f}✗ → P(transient-recovery)≈{p:.2f}; retry EV={ev:,.0f} tok → {'RETRY' if ev > 0 else 'DEGRADE immediately'}")
+    if not eps:
+        print("  no transient-class episodes on record (turbo history reclassified config-class; excluded)")
+
+    print("== D8a tripwire (accuracy is a breach detector, not a significance machine) ==")
+    d8 = [r for r in rows if "correct" in r and r.get("items")]
+    if d8:
+        last = d8[-1]
+        rate = last["correct"] / last["items"]
+        # alert if last run falls at/below 80% (2σ below the ~98% post-fix mean on 10 items)
+        status = "BREACH" if rate <= 0.8 or not last.get("integrity", 1) else "nominal"
+        print(f"  last run: {last['correct']}/{last['items']} integrity={'pass' if last.get('integrity',1) else 'FAIL'} engine={last.get('engine','?')} → {status} (alert threshold: ≤80% or integrity fail)")
+        for eng in sorted({r.get("engine", "?") for r in d8}):
+            runs = [r for r in d8 if r.get("engine", "?") == eng]
+            c = sum(r["correct"] for r in runs); n = sum(r["items"] for r in runs)
+            integ = sum(1 for r in runs if r.get("integrity", 1))
+            print(f"  series {eng}: {len(runs)} runs, {c}/{n} items ({100*c/n:.0f}%), integrity {integ}/{len(runs)}")
+
+    print("== Lifetime capability alarm (dispatch-attempts.jsonl — the turbo blind-spot fix) ==")
+    att_path = os.path.join(HERE, "dispatch-attempts.jsonl")
+    if os.path.exists(att_path):
+        att = [json.loads(l) for l in open(att_path) if l.strip()]
+        by_eng = {}
+        for a in att:
+            by_eng.setdefault(a["engine"], []).append(a["outcome"])
+        for eng, outs in sorted(by_eng.items()):
+            okc = sum(1 for o in outs if o == "success")
+            rate = okc / len(outs)
+            consec_fail = 0
+            for o in outs:
+                if o != "success":
+                    consec_fail += 1
+                else:
+                    break
+            verdict = []
+            if rate == 0.0:
+                verdict.append("NEVER-WORKED → remove or investigate NOW")
+            elif rate < 0.5:
+                verdict.append("MAJORITY-FAIL → remove-or-investigate")
+            if consec_fail >= 5:
+                verdict.append(f"{consec_fail} consecutive failures")
+            print(f"  {eng}: {okc}/{len(outs)} lifetime ({100*rate:.0f}%){' — ' + '; '.join(verdict) if verdict else ''}")
+    else:
+        print("  no attempts ledger found")
+
+if __name__ == "__main__":
+    main()
diff --git a/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/oracle/checker.py b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/oracle/checker.py
new file mode 100644
index 0000000..ecc83ae
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/oracle/checker.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""Executable oracle for scenario s1-migration. Deterministic, stdlib only.
+Usage: checker.py <artifact.php>
+Prints 'VERDICT pass|fail' + per-check 'REASON ...' lines. Exit 0 iff pass.
+
+Deterministic rules: text is lowercased and whitespace-collapsed (PHP method
+calls are case-insensitive, so this is semantics-preserving); each convention
+is a fixed regex. Modifier chains are checked for presence, not adjacency
+(documented rule — adjacency would false-fail valid reorderings).
+"""
+import re
+import sys
+
+CHECKS = [
+    ("schema::create('products'", r"schema::create\(\s*['\"]products['\"]"),
+    ("->id()", r"->id\(\)"),
+    ("string sku unique", r"->string\(\s*['\"]sku['\"]\s*\)\s*->unique\(\)"),
+    ("string name", r"->string\(\s*['\"]name['\"]"),
+    ("text/longtext description nullable",
+     r"->(long)?text\(\s*['\"]description['\"]\s*\)\s*->nullable\(\)"),
+    ("decimal price 8,2", r"->decimal\(\s*['\"]price['\"]\s*,\s*8\s*,\s*2\s*\)"),
+    ("price unsigned", r"->unsigned\(\)"),
+    ("price default 0.00", r"->default\(\s*0(\.0+)?\s*\)"),
+    ("integer stock default 0", r"->integer\(\s*['\"]stock['\"]"),
+    ("boolean active default true", r"->boolean\(\s*['\"]active['\"]"),
+    ("default true", r"->default\(\s*true\s*\)"),
+    ("foreignid user_id constrained cascadeondelete",
+     r"->foreignid\(\s*['\"]user_id['\"]\s*\)\s*->constrained\(\)\s*->cascadeondelete\(\)"),
+    ("->timestamps()", r"->timestamps\(\)"),
+    ("down: dropifexists products", r"schema::dropifexists\(\s*['\"]products['\"]"),
+]
+
+
+def grade(path):
+    text = open(path, errors="replace").read().lower()
+    flat = re.sub(r"\s+", " ", text)
+    failed = [name for name, pat in CHECKS if not re.search(pat, flat)]
+    return (not failed), failed
+
+
+if __name__ == "__main__":
+    ok, failed = grade(sys.argv[1])
+    print(f"VERDICT {'pass' if ok else 'fail'}")
+    if failed:
+        print("REASON failed checks: " + "; ".join(failed))
+    else:
+        print("REASON all 14 convention checks matched")
+    sys.exit(0 if ok else 1)
diff --git a/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/oracle/reference_bad.php b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/oracle/reference_bad.php
new file mode 100644
index 0000000..0c7f1de
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/oracle/reference_bad.php
@@ -0,0 +1,29 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('products', function (Blueprint $table) {
+            $table->increments('id');
+            $table->string('sku');
+            $table->string('name');
+            $table->text('description');
+            $table->double('price', 8, 2);
+            $table->integer('stock');
+            $table->boolean('active');
+            $table->unsignedBigInteger('user_id');
+            $table->foreign('user_id')->references('id')->on('users');
+            $table->timestamps();
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('products');
+    }
+};
diff --git a/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/oracle/reference_good.php b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/oracle/reference_good.php
new file mode 100644
index 0000000..92bc50c
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/oracle/reference_good.php
@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('products', function (Blueprint $table) {
+            $table->id();
+            $table->string('sku')->unique();
+            $table->string('name');
+            $table->text('description')->nullable();
+            $table->decimal('price', 8, 2)->unsigned()->default(0.00);
+            $table->integer('stock')->default(0);
+            $table->boolean('active')->default(true);
+            $table->foreignId('user_id')->constrained()->cascadeOnDelete();
+            $table->timestamps();
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('products');
+    }
+};
diff --git a/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/task.md b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/task.md
new file mode 100644
index 0000000..3b9d23b
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s1-migration/task.md
@@ -0,0 +1,16 @@
+---
+output_ext: php
+---
+
+Task: write a Laravel database migration, following the SKILL GUIDANCE below exactly.
+
+SKILL GUIDANCE:
+{{SKILL_GUIDANCE}}
+
+REPO CONTEXT: a real Laravel application (laravel/laravel skeleton, framework ^13, PHP 8.3) with the standard `users` table present.
+
+SPEC (in the developer's words): create the `products` table — auto-increment primary key; unique SKU string; name string; optional long description; price as a money decimal with 2 decimal places, unsigned, defaulting to zero; integer stock count defaulting to zero; boolean active flag defaulting to true; the owning user as a foreign key to `users` that cascades on delete; timestamps. Include the `down()` method.
+
+Respond with the complete migration PHP file between these markers, and nothing else:
+OUTPUT_BEGIN
+OUTPUT_END
diff --git a/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/oracle/checker.py b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/oracle/checker.py
new file mode 100644
index 0000000..6fe5ed6
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/oracle/checker.py
@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""Executable oracle for scenario s2-artisan-make-model. Deterministic.
+Accepted: 'php artisan make:model <Name> (-a|--all)' with the flag before OR
+after the model name (both are valid CLI orderings — the original
+position-fixed set false-failed 'make:model -a Product'; audited 2026-09-03).
+Self-test contract: reference_good passes, reference_bad fails."""
+import re
+import sys
+
+PAT = re.compile(
+    r"^php\s+artisan\s+make:model\s+(?P<name>[\w\\\\:]+)\s+(?P<flag>-a|--all)$"
+    r"|^php\s+artisan\s+make:model\s+(?P<flag2>-a|--all)\s+(?P<name2>[\w\\\\:]+)$"
+)
+
+
+def grade(path):
+    flat = re.sub(r"\s+", " ", open(path, errors="replace").read().strip()).lower()
+    m = PAT.match(flat)
+    return bool(m), flat
+
+
+if __name__ == "__main__":
+    ok, got = grade(sys.argv[1])
+    print(f"VERDICT {'pass' if ok else 'fail'}")
+    print(f"REASON {'accepted make:model with -a/--all (any flag position)' if ok else 'not an accepted form: ' + got[:120]}")
+    sys.exit(0 if ok else 1)
diff --git a/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/oracle/reference_bad.txt b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/oracle/reference_bad.txt
new file mode 100644
index 0000000..7e88f9f
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/oracle/reference_bad.txt
@@ -0,0 +1 @@
+php artisan make:model Product
diff --git a/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/oracle/reference_good.txt b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/oracle/reference_good.txt
new file mode 100644
index 0000000..e7ceeac
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/oracle/reference_good.txt
@@ -0,0 +1 @@
+php artisan make:model Product --all
diff --git a/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/task.md b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/task.md
new file mode 100644
index 0000000..5f7b168
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/laravel-dev/scenarios/s2-artisan-make-model/task.md
@@ -0,0 +1,16 @@
+---
+output_ext: txt
+---
+
+Task: write the exact single artisan command requested, following the SKILL GUIDANCE below exactly.
+
+SKILL GUIDANCE:
+{{SKILL_GUIDANCE}}
+
+REPO CONTEXT: a real Laravel application (framework ^13).
+
+REQUEST: scaffold a new `Product` model together with its migration, factory, seeder, policy, and resource controller, in one invocation.
+
+Respond with only the command between these markers, and nothing else:
+OUTPUT_BEGIN
+OUTPUT_END
diff --git a/plugins/zcoder/tests/skill-evals/laravel-dev/weak-spots.md b/plugins/zcoder/tests/skill-evals/laravel-dev/weak-spots.md
new file mode 100644
index 0000000..7849038
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/laravel-dev/weak-spots.md
@@ -0,0 +1,20 @@
+# laravel-dev — weak-spot ledger
+
+Failure notes feed reflective mutation (skill-forge protocol). One entry per
+distinct failure mode; resolved entries stay for the record.
+
+## WS-1 (RESOLVED pre-record, birth round 2026-09-03) — oracle over-constraint
+
+- **Evidence:** both s1-migration subjects (r1/r2, byte-identical outputs)
+  emitted `longText('description')->nullable()`; original checker accepted
+  only `text(...)`.
+- **Adjudication:** task spec says "optional **long** description" —
+  `longText` is a spec-compliant reading. The checker rule was stricter than
+  the spec without justification = false-fail measurement artifact, not a
+  subject error. Lesson: when a spec word admits multiple API mappings, the
+  oracle must accept the spec-admitted set — otherwise it measures the
+  grader's taste, not the skill.
+- **Fix:** oracle accepts `text|longText` for description; reference_bad
+  still fails (it omits `->nullable()` entirely). Self-test re-run green
+  BEFORE any trial was recorded (revision is spec-justified, not
+  pass-seeking; adjudication documented here).
diff --git a/plugins/zcoder/tests/skill-evals/trigger-cases.jsonl b/plugins/zcoder/tests/skill-evals/trigger-cases.jsonl
new file mode 100644
index 0000000..14a6b6c
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/trigger-cases.jsonl
@@ -0,0 +1,12 @@
+{"id": "t01-laravel-migration", "utterance": "I need a Laravel migration that adds a decimal money column with a foreign key to the users table.", "expected": "laravel-dev", "note": "migration + money column + FK is laravel-dev's core trigger domain"}
+{"id": "t02-laravel-scaffold", "utterance": "generate a model with migration, factory and policy for a Product entity in my Laravel app", "expected": "laravel-dev", "note": "artisan scaffolding phrasing (make:model -a equivalent)"}
+{"id": "t03-yaml-convert", "utterance": "convert this config.yaml to JSON for the terraform pipeline, keep the values exactly as they are", "expected": "yaml-json-convert", "note": "explicit YAML→JSON conversion request; 'keep values exactly' is the type-strictness signal"}
+{"id": "t04-yaml-types", "utterance": "after converting my YAML to JSON the version number 2.0 turned into 2 — how do I stop that?", "expected": "yaml-json-convert", "note": "quoted-scalar type drift complaint — the skill's named failure mode"}
+{"id": "t05-route-screenshot", "utterance": "inspect this screenshot of the broken login page, implement the CSS fix, and then verify it against the mockup", "expected": "glm-orchestrator", "note": "REV2 (after router-r1-2026-09-04): the v1 utterance was a single-image inspection and the router correctly chose none — the glm-orchestrator description claims only multi-part (2+) work, so the original expectation was mis-registered. This revision uses a genuinely multi-part request (inspect + implement + verify), which the description does claim."}
+{"id": "t6-turbo-rejection", "utterance": "Why did glm-turbo reject my dispatches?", "expected": "glm-orchestrator", "note": "carried over from the 2026-09-03 dry run where the router chose glm-orchestrator and the adjudication confirmed it — the engine rejection matrix lives in that skill's body; knowledge routing, not task routing"}
+{"id": "t07-forge-scan", "utterance": "scan our Django project and tell me which coding-convention skills we're missing", "expected": "skill-forge", "note": "stack-gap scan is /skill-scan's exact job"}
+{"id": "t08-forge-evolve", "utterance": "run an improvement round on the yaml-json-convert skill and show me the promotion gates", "expected": "skill-forge", "note": "evolution round + gates vocabulary = skill-forge"}
+{"id": "t09-none-smalltalk", "utterance": "what's a good name for a rescue cat?", "expected": "none", "note": "pure conversation — no skill should load (unwanted-load tripwire)"}
+{"id": "t10-none-generic", "utterance": "summarize this paragraph in one sentence for the standup notes", "expected": "none", "note": "generic writing task inside every agent's base ability — a near-miss bait for orchestrator/skill keywords"}
+{"id": "t11-yaml-bait", "utterance": "read this JSON file and change the value of the timeout key to 30", "expected": "none", "note": "JSON editing is base ability; bait: 'JSON file' keyword must not trigger the YAML conversion skill"}
+{"id": "t12-laravel-bait", "utterance": "my PHP script prints a broken array — help me debug the foreach loop", "expected": "none", "note": "plain PHP debugging is not Laravel convention work; bait: 'PHP' keyword must not trigger laravel-dev"}
diff --git a/plugins/zcoder/tests/skill-evals/trigger-evals.jsonl b/plugins/zcoder/tests/skill-evals/trigger-evals.jsonl
new file mode 100644
index 0000000..e69de29
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v2-quoted-scalar-guard/MUTATION.md b/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v2-quoted-scalar-guard/MUTATION.md
new file mode 100644
index 0000000..2d88806
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v2-quoted-scalar-guard/MUTATION.md
@@ -0,0 +1,21 @@
+# MUTATION — v2-quoted-scalar-guard
+
+- **Target failing trials:** `s1-yaml-to-json__v1__r1`, `s1-yaml-to-json__v1__r2`
+  (verdict fail, reason `.app.version: type float != str`; artifact sha256
+  b4b80df7cec5). Context: 4/4 observed subjects — including 2 with no guidance
+  at all — made the identical error.
+- **Weak spot:** WS-1 in weak-spots.md — quoted-numeric normalization.
+- **Mutation (one, targeted):** elevated the quoted-scalar rule from position 4
+  to position 1, added a worked before/after example with the wrong answer
+  shown explicitly, explained WHY quotes are type information (explain-why
+  style — models comply better with reasons than louder enforcement), and
+  appended a mandatory pre-emit self-check that walks every scalar.
+- **Not changed:** every other rule (isolation of the mutation makes the
+  evidence gate interpretable).
+- **Pattern:** reflective trace-driven mutation, ported from
+  NousResearch/hermes-agent-self-evolution (MIT) — read why it failed, propose
+  the targeted fix, cite the trial.
+- **Prediction:** subjects under v2 pass `.app.version` as string `"2.0"` in
+  both runs; if either still normalizes, WS-1 stays open and the next mutation
+  must try a different lever (e.g., asking the subject to echo quoted values
+  first), not louder repetition.
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v2-quoted-scalar-guard/SKILL.md b/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v2-quoted-scalar-guard/SKILL.md
new file mode 100644
index 0000000..10910c6
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v2-quoted-scalar-guard/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: yaml-json-convert
+description: Convert YAML to JSON exactly, preserving scalar types — quoted values like "2.0" stay strings, true/false become JSON booleans, null/~ become null, unquoted dates become strings. Use whenever converting YAML configs to JSON, transforming any YAML document into JSON, or fixing a YAML→JSON conversion that changed value types — even for a single small document.
+---
+
+# YAML → JSON Conversion
+
+Converting YAML to JSON — mandatory conventions:
+
+1. **QUOTED SCALARS STAY QUOTED — this is the #1 error in this conversion.**
+   A YAML value in quotation marks is a string even when it looks numeric,
+   because the author deliberately quoted it to force string type. It must
+   still be quoted in the JSON output:
+   - YAML `version: "2.0"` → JSON `"version": "2.0"` (string — CORRECT)
+   - YAML `version: "2.0"` → JSON `"version": 2.0` (number — WRONG: this
+     silently drops the quotes and changes the value's type)
+   The temptation is to "clean up" `2.0` into a number because it looks like
+   one. Resist it: quotes are type information, not decoration.
+2. Unquoted true/false become JSON true/false (lowercase — never True/False,
+   never strings).
+3. null and ~ become JSON null (never the string "null").
+4. Unquoted scalars: integers stay integers, decimals stay numbers (3 stays 3,
+   0.25 stays 0.25).
+5. Unquoted dates (YYYY-MM-DD) become JSON strings, kept verbatim.
+6. Flow lists [a, b] and block lists both become JSON arrays. Empty maps/lists
+   become {} and [].
+7. Emit a single JSON object: no comments, no trailing commas, no prose, no
+   code fences.
+
+**Self-check before answering:** walk every scalar in your JSON and ask "was
+this value quoted in the YAML?" — if yes, it must be a JSON string in double
+quotes. Fix any that are not before emitting.
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v3-yaml11-booleans/MUTATION.md b/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v3-yaml11-booleans/MUTATION.md
new file mode 100644
index 0000000..f784cfe
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v3-yaml11-booleans/MUTATION.md
@@ -0,0 +1,23 @@
+# MUTATION — v3-yaml11-booleans
+
+- **Target failing trial:** `s2-type-edge-cases__v2-quoted-scalar-guard__c1`
+  (canary round 8, 2026-09-04, agent_18b9dfc8, verdict fail, reason
+  `.service.flags[0]: type str != bool; .service.flags[1]: type str != bool`,
+  artifact sha256 1c23abaf90b6).
+- **Weak spot:** WS-2 — YAML 1.1 boolean words (`on`/`off`/`yes`/`no`) are
+  not covered by the live guidance. The subject emitted `["on", "off"]`
+  (strings) where the scenario oracle — following YAML 1.1 semantics, the
+  de-facto dialect of real-world YAML tooling — expects `[true, false]`.
+- **Mutation (one, targeted):** rule 2 extended with the YAML 1.1 boolean
+  words, a worked WRONG/CORRECT example pair, the tooling rationale (PyYAML,
+  Symfony, compose files implement 1.1 booleans), and the quoted-vs-unquoted
+  boundary. Nothing else changed — isolation keeps the evidence gate
+  interpretable.
+- **Pattern:** reflective trace-driven mutation (Hermes port) — authored in
+  the same round that observed the fail, per the immediate-reflection rule.
+- **Prediction:** subjects under v3 pass `.service.flags` as booleans in both
+  s2 runs while s1 behavior is unchanged. If s2 still fails, the next
+  mutation must try a different lever, not louder repetition.
+- **Promotion path:** needs interactive evaluation of this candidate in a
+  same-session interleaved A/B vs v2 (blocking rule), then the 5 gates.
+  Idle rounds do NOT promote.
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v3-yaml11-booleans/SKILL.md b/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v3-yaml11-booleans/SKILL.md
new file mode 100644
index 0000000..6e4f057
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/candidates/v3-yaml11-booleans/SKILL.md
@@ -0,0 +1,40 @@
+---
+name: yaml-json-convert
+description: Convert YAML to JSON exactly, preserving scalar types — quoted values like "2.0" stay strings, true/false become JSON booleans, null/~ become null, unquoted dates become strings. Use whenever converting YAML configs to JSON, transforming any YAML document into JSON, or fixing a YAML→JSON conversion that changed value types — even for a single small document.
+---
+
+# YAML → JSON Conversion
+
+Converting YAML to JSON — mandatory conventions:
+
+1. **QUOTED SCALARS STAY QUOTED — this is the #1 error in this conversion.**
+   A YAML value in quotation marks is a string even when it looks numeric,
+   because the author deliberately quoted it to force string type. It must
+   still be quoted in the JSON output:
+   - YAML `version: "2.0"` → JSON `"version": "2.0"` (string — CORRECT)
+   - YAML `version: "2.0"` → JSON `"version": 2.0` (number — WRONG: this
+     silently drops the quotes and changes the value's type)
+   The temptation is to "clean up" `2.0` into a number because it looks like
+   one. Resist it: quotes are type information, not decoration.
+2. Unquoted true/false become JSON true/false (lowercase — never True/False,
+   never strings). **This includes the YAML 1.1 boolean words**: unquoted
+   `on`, `off`, `yes`, `no` (and their capitalized forms) are booleans in
+   YAML 1.1 — the dialect essentially all real-world YAML tooling implements
+   (PyYAML, Symfony Config, compose files) — so they become JSON true/false
+   too:
+   - YAML `flags: [on, off]` → JSON `"flags": [true, false]` (CORRECT)
+   - YAML `flags: [on, off]` → JSON `"flags": ["on", "off"]` (WRONG: keeps
+     the raw spelling as strings)
+   Only QUOTED `"on"` / `"yes"` stay strings.
+3. null and ~ become JSON null (never the string "null").
+4. Unquoted scalars: integers stay integers, decimals stay numbers (3 stays 3,
+   0.25 stays 0.25).
+5. Unquoted dates (YYYY-MM-DD) become JSON strings, kept verbatim.
+6. Flow lists [a, b] and block lists both become JSON arrays. Empty maps/lists
+   become {} and [].
+7. Emit a single JSON object: no comments, no trailing commas, no prose, no
+   code fences.
+
+**Self-check before answering:** walk every scalar in your JSON and ask "was
+this value quoted in the YAML?" — if yes, it must be a JSON string in double
+quotes. Fix any that are not before emitting.
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/checker.py b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/checker.py
new file mode 100644
index 0000000..4efe59f
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/checker.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Executable oracle for scenario s1-yaml-to-json. Deterministic, stdlib only.
+Usage: checker.py <artifact.json>
+Prints 'VERDICT pass|fail' and 'REASON ...'. Exit 0 iff pass.
+Self-test contract: reference_good.json must PASS, reference_bad.json must FAIL."""
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+EXPECTED = os.path.join(HERE, "expected.json")
+
+
+def type_strict_equal(a, b, path, diffs, limit=5):
+    """Deep equality distinguishing bool/int and int/float (Python == treats
+    True==1 and 3==3.0 as equal; JSON semantics require type awareness)."""
+    if len(diffs) >= limit:
+        return
+    if type(a) is not type(b):
+        diffs.append(f"{path or '<root>'}: type {type(a).__name__} != {type(b).__name__}")
+        return
+    if isinstance(a, dict):
+        for k in sorted(set(a) | set(b), key=str):
+            if k not in a:
+                diffs.append(f"{path}.{k}: missing in subject")
+            elif k not in b:
+                diffs.append(f"{path}.{k}: extra in subject")
+            else:
+                type_strict_equal(a[k], b[k], f"{path}.{k}", diffs, limit)
+    elif isinstance(a, list):
+        if len(a) != len(b):
+            diffs.append(f"{path}: list len {len(a)} != {len(b)}")
+        else:
+            for i, (x, y) in enumerate(zip(a, b)):
+                type_strict_equal(x, y, f"{path}[{i}]", diffs, limit)
+    elif a != b:
+        diffs.append(f"{path}: {a!r} != {b!r}")
+
+
+def grade(path):
+    with open(EXPECTED) as f:
+        expected = json.load(f)
+    try:
+        got = json.load(open(path))
+    except Exception as e:
+        return "fail", f"json parse error: {e}"
+    diffs = []
+    type_strict_equal(got, expected, "", diffs)
+    if diffs:
+        return "fail", "; ".join(diffs)
+    return "pass", "exact type-strict match"
+
+
+if __name__ == "__main__":
+    verdict, reason = grade(sys.argv[1])
+    print(f"VERDICT {verdict}")
+    print(f"REASON {reason}")
+    sys.exit(0 if verdict == "pass" else 1)
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/expected.json b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/expected.json
new file mode 100644
index 0000000..1f42683
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/expected.json
@@ -0,0 +1 @@
+{"app": {"name": "skill-forge", "debug": false, "replicas": 3, "ratio": 0.25, "version": "2.0", "tags": ["alpha", "beta-2"], "timeout": null, "host": null, "empty": {}, "release": {"date": "2026-09-03", "channels": ["stable", "nightly"]}}}
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/reference_bad.json b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/reference_bad.json
new file mode 100644
index 0000000..26f7860
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/reference_bad.json
@@ -0,0 +1,17 @@
+{
+  "app": {
+    "name": "skill-forge",
+    "debug": false,
+    "replicas": 3,
+    "ratio": 0.25,
+    "version": 2.0,
+    "tags": ["alpha", "beta-2"],
+    "timeout": null,
+    "host": null,
+    "empty": {},
+    "release": {
+      "date": "2026-09-03",
+      "channels": ["stable", "nightly"]
+    }
+  }
+}
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/reference_good.json b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/reference_good.json
new file mode 100644
index 0000000..4319e90
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/oracle/reference_good.json
@@ -0,0 +1,17 @@
+{
+  "app": {
+    "name": "skill-forge",
+    "debug": false,
+    "replicas": 3,
+    "ratio": 0.25,
+    "version": "2.0",
+    "tags": ["alpha", "beta-2"],
+    "timeout": null,
+    "host": null,
+    "empty": {},
+    "release": {
+      "date": "2026-09-03",
+      "channels": ["stable", "nightly"]
+    }
+  }
+}
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/task.md b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/task.md
new file mode 100644
index 0000000..294d6e2
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s1-yaml-to-json/task.md
@@ -0,0 +1,29 @@
+---
+output_ext: json
+---
+
+Task: convert a YAML configuration document to JSON, following the SKILL GUIDANCE below exactly.
+
+SKILL GUIDANCE:
+{{SKILL_GUIDANCE}}
+
+YAML DOCUMENT:
+app:
+  name: "skill-forge"
+  debug: false
+  replicas: 3
+  ratio: 0.25
+  version: "2.0"
+  tags:
+    - alpha
+    - "beta-2"
+  timeout: null
+  host: ~
+  empty: {}
+  release:
+    date: 2026-09-03
+    channels: [stable, nightly]
+
+Respond with the complete JSON document between these markers, and nothing else:
+OUTPUT_BEGIN
+OUTPUT_END
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/checker.py b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/checker.py
new file mode 100644
index 0000000..4efe59f
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/checker.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Executable oracle for scenario s1-yaml-to-json. Deterministic, stdlib only.
+Usage: checker.py <artifact.json>
+Prints 'VERDICT pass|fail' and 'REASON ...'. Exit 0 iff pass.
+Self-test contract: reference_good.json must PASS, reference_bad.json must FAIL."""
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+EXPECTED = os.path.join(HERE, "expected.json")
+
+
+def type_strict_equal(a, b, path, diffs, limit=5):
+    """Deep equality distinguishing bool/int and int/float (Python == treats
+    True==1 and 3==3.0 as equal; JSON semantics require type awareness)."""
+    if len(diffs) >= limit:
+        return
+    if type(a) is not type(b):
+        diffs.append(f"{path or '<root>'}: type {type(a).__name__} != {type(b).__name__}")
+        return
+    if isinstance(a, dict):
+        for k in sorted(set(a) | set(b), key=str):
+            if k not in a:
+                diffs.append(f"{path}.{k}: missing in subject")
+            elif k not in b:
+                diffs.append(f"{path}.{k}: extra in subject")
+            else:
+                type_strict_equal(a[k], b[k], f"{path}.{k}", diffs, limit)
+    elif isinstance(a, list):
+        if len(a) != len(b):
+            diffs.append(f"{path}: list len {len(a)} != {len(b)}")
+        else:
+            for i, (x, y) in enumerate(zip(a, b)):
+                type_strict_equal(x, y, f"{path}[{i}]", diffs, limit)
+    elif a != b:
+        diffs.append(f"{path}: {a!r} != {b!r}")
+
+
+def grade(path):
+    with open(EXPECTED) as f:
+        expected = json.load(f)
+    try:
+        got = json.load(open(path))
+    except Exception as e:
+        return "fail", f"json parse error: {e}"
+    diffs = []
+    type_strict_equal(got, expected, "", diffs)
+    if diffs:
+        return "fail", "; ".join(diffs)
+    return "pass", "exact type-strict match"
+
+
+if __name__ == "__main__":
+    verdict, reason = grade(sys.argv[1])
+    print(f"VERDICT {verdict}")
+    print(f"REASON {reason}")
+    sys.exit(0 if verdict == "pass" else 1)
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/expected.json b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/expected.json
new file mode 100644
index 0000000..afee772
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/expected.json
@@ -0,0 +1 @@
+{"service": {"name": "billing-api", "port": 8080, "version": "3.1", "price": "$1,200", "notes": "", "owner": null, "maintainers": ["alice", ""], "window": {"start": "2026-01-15", "end": "2026-02-20"}, "rates": {"standard": 0.2, "priority:1": 0.5}, "flags": [true, false]}}
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/reference_bad.json b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/reference_bad.json
new file mode 100644
index 0000000..c4923ff
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/reference_bad.json
@@ -0,0 +1 @@
+{"service": {"name": "billing-api", "port": 8080, "version": 3.1, "price": 1200, "notes": null, "owner": "", "maintainers": ["alice", null], "window": {"start": "2026-01-15", "end": "2026-02-20"}, "rates": {"standard": 0.2, "priority:1": 0.5}, "flags": ["on", "off"]}}
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/reference_good.json b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/reference_good.json
new file mode 100644
index 0000000..afee772
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/oracle/reference_good.json
@@ -0,0 +1 @@
+{"service": {"name": "billing-api", "port": 8080, "version": "3.1", "price": "$1,200", "notes": "", "owner": null, "maintainers": ["alice", ""], "window": {"start": "2026-01-15", "end": "2026-02-20"}, "rates": {"standard": 0.2, "priority:1": 0.5}, "flags": [true, false]}}
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/task.md b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/task.md
new file mode 100644
index 0000000..ed0d73e
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/scenarios/s2-type-edge-cases/task.md
@@ -0,0 +1,33 @@
+---
+output_ext: json
+---
+
+Task: convert a YAML configuration document to JSON, following the SKILL GUIDANCE below exactly.
+
+SKILL GUIDANCE:
+{{SKILL_GUIDANCE}}
+
+YAML DOCUMENT:
+service:
+  name: "billing-api"
+  port: 8080
+  version: "3.1"
+  price: "$1,200"
+  notes: ""
+  owner:
+  maintainers:
+    - "alice"
+    - ""
+  window:
+    start: 2026-01-15
+    end: 2026-02-20
+  rates:
+    standard: 0.2
+    "priority:1": 0.5
+  flags:
+    - on
+    - off
+
+Respond with the complete JSON document between these markers, and nothing else:
+OUTPUT_BEGIN
+OUTPUT_END
diff --git a/plugins/zcoder/tests/skill-evals/yaml-json-convert/weak-spots.md b/plugins/zcoder/tests/skill-evals/yaml-json-convert/weak-spots.md
new file mode 100644
index 0000000..0415003
--- /dev/null
+++ b/plugins/zcoder/tests/skill-evals/yaml-json-convert/weak-spots.md
@@ -0,0 +1,44 @@
+# yaml-json-convert — weak-spot ledger
+
+Failure notes feed reflective mutation (skill-forge protocol). One entry per
+distinct failure mode; resolved entries stay for the record.
+
+## WS-1 (RESOLVED 2026-09-03, promotion 20260903T142152Z) — quoted-numeric normalization
+
+- **Evidence:** trials run1_a_s1 and run2_a_s1 (2026-09-03), plus 2 unguided
+  runs: 4/4 subjects emitted `"version": 2.0` (float) for YAML `version: "2.0"`
+  (quoted string). Verdict reason: `.app.version: type float != str`.
+- **Diagnosis:** rule 4 existed in v1 guidance ("quoted scalars stay strings")
+  and was ignored anyway. Skill text presence does not imply compliance —
+  the rule must be the FIRST thing read, carry a worked before/after example,
+  and be paired with a pre-emit self-check.
+- **Mutation:** candidates/v2-quoted-scalar-guard (reflective mutation citing
+  this entry — Hermes-port pattern).
+- **Resolution (AMENDED 2026-09-03 after replication):** v2 trials r1/r2
+  passed and promotion 20260903T142152Z stands — but a same-bytes replication
+  of v1 in a later session ALSO passed 2/2 (r3/r4). The morning v1 failures
+  are isolated to the morning session: the subject substrate is
+  non-stationary across sessions, and the original v1-vs-v2 difference was
+  session-confounded, not proven causal. Current honest state: v2 4/4
+  overall, v1 2/4 (0/2 legacy session, 2/2 replication session), no
+  within-session difference at n=4. v2 retained because it has never failed
+  and its pedagogy is strictly stronger; the FIX CLAIM is downgraded to
+  "observed once, confounded". Consequence adopted system-wide: comparisons
+  must be same-session interleaved (see skill-forge EVALUATE blocking rule);
+  ledger rows now carry session stamps and stats warns on outcome flips
+  across sessions. Both v2 runs also converged byte-identical — watch for
+  divergence in future rounds.
+
+## WS-2 (OPEN — mutation prepared) — YAML 1.1 boolean words uncovered
+
+- **Evidence:** trial `s2-type-edge-cases__v2-quoted-scalar-guard__c1`
+  (canary round 8): subject emitted `"flags": ["on", "off"]` (strings);
+  oracle expects `[true, false]` per YAML 1.1 semantics (the dialect
+  real-world tooling implements). Verdict reason:
+  `.service.flags[0]: type str != bool; .service.flags[1]: type str != bool`.
+- **Diagnosis:** live v2 guidance covers true/false only — `on`/`off`/
+  `yes`/`no` are uncovered edges. Found by canary-ing the least-tested
+  scenario (s2 had 2 trials vs s1's 9) instead of the canonical one.
+- **Mutation:** candidates/v3-yaml11-booleans (MUTATION.md cites the trial).
+  Awaiting same-session interleaved evaluation vs v2 + 5 gates; promotion
+  is interactive-only.
diff --git a/plugins/zcoder/tests/skill-forge-smoke.sh b/plugins/zcoder/tests/skill-forge-smoke.sh
new file mode 100644
index 0000000..feb61a3
--- /dev/null
+++ b/plugins/zcoder/tests/skill-forge-smoke.sh
@@ -0,0 +1,218 @@
+#!/usr/bin/env bash
+# skill-forge smoke battery — adversarial fixtures against every script CLI,
+# zero tokens, all state in a mktemp sandbox (SKILL_FORGE_EVALS/SKILL_FORGE_SKILLS).
+# Born 2026-09-04 from an e2e audit that found 3 real gate blind spots
+# (cross-session fix claims, candidate-only scenario fails, baseline-free
+# trigger runs). Each probe here is a regression lock on a confirmed hole.
+# Usage: bash tests/skill-forge-smoke.sh   (exit 0 iff all checks pass)
+cd "$(dirname "$0")/.." || exit 1
+pass=0; fail=0
+ok()  { pass=$((pass+1)); echo "PASS  $1"; }
+bad() { fail=$((fail+1)); echo "FAIL  $1"; }
+PROMOTE="skills/skill-forge/scripts/promote.py"
+PARETO="skills/skill-forge/scripts/pareto.py"
+TRIGGER="skills/skill-forge/scripts/trigger_eval.py"
+GRADE="skills/skill-forge/scripts/grade.py"
+SELFTEST="skills/skill-forge/scripts/oracle_selftest.py"
+
+T=$(mktemp -d /tmp/forge-smoke.XXXXXX)
+trap 'rm -rf "$T"' EXIT
+export SKILL_FORGE_EVALS="$T/evals"
+export SKILL_FORGE_SKILLS="$T/skills"
+mkdir -p "$T/skills/demofix" "$T/evals/demofix/candidates" "$T/evals/demofix/scenarios/s1/oracle"
+
+# ---- fixtures ----
+cat > "$T/skills/demofix/SKILL.md" <<'EOF'
+---
+name: demofix
+description: Demo fixture skill for gate probes with a description long enough.
+---
+
+Body line one.
+Body line two.
+EOF
+cat > "$T/evals/demofix/scenarios/s1/task.md" <<'EOF'
+---
+output_ext: txt
+---
+Say PASS.
+{{SKILL_GUIDANCE}}
+OUTPUT_BEGIN
+OUTPUT_END
+EOF
+cat > "$T/evals/demofix/scenarios/s1/oracle/checker.py" <<'EOF'
+#!/usr/bin/env python3
+import sys
+ok = open(sys.argv[1]).read().strip() == "PASS"
+print(f"VERDICT {'pass' if ok else 'fail'}")
+print("REASON demo")
+sys.exit(0 if ok else 1)
+EOF
+echo PASS > "$T/evals/demofix/scenarios/s1/oracle/reference_good.txt"
+echo NOPE > "$T/evals/demofix/scenarios/s1/oracle/reference_bad.txt"
+
+mkcand() { # mkcand <name> <description> [extra-body-bytes]
+  local d="$T/evals/demofix/candidates/$1"
+  mkdir -p "$d"
+  python3 - "$d" "$2" "${3:-0}" <<'PYEOF'
+import sys
+d, desc, pad = sys.argv[1], sys.argv[2], int(sys.argv[3])
+body = "Body line one.\nBody line two.\n" + ("B" * pad)
+open(f"{d}/SKILL.md", "w").write(f"---\nname: demofix\ndescription: {desc}\n---\n\n{body}\n")
+PYEOF
+  printf 'Cites s1__v1__r1 as the failing trial.\n' > "$d/MUTATION.md"
+}
+ledrow() { # ledrow <scen> <variant> <run> <verdict> <session>
+  printf '{"ts":"2026-09-04T00:00:00+00:00","skill":"demofix","scenario":"%s","variant":"%s","run":"%s","verdict":"%s","reason":"x","sha256":"a","oracle":"o","task":"t","session":"%s"}\n' "$1" "$2" "$3" "$4" "$5"
+}
+writetrials() { : > "$T/evals/demofix/trials.jsonl"; }
+
+# ================= pareto.py =================
+writetrials
+python3 "$PARETO" "$T/evals/demofix/trials.jsonl" >/dev/null 2>&1
+[ $? -ne 0 ] && ok "S1 pareto: empty ledger rejected" || bad "S1 pareto: empty ledger not rejected"
+
+{ ledrow s1 v1 r1 fail sessA; ledrow s1 v1 r2 fail sessA
+  ledrow s1 v2 r1 pass sessA; ledrow s1 v2 r2 pass sessA; } > "$T/evals/demofix/trials.jsonl"
+python3 "$PARETO" "$T/evals/demofix/trials.jsonl" | grep -q "v1 .*dominated" \
+  && ok "S2 pareto: all-pass variant dominates failing variant" || bad "S2 pareto dominance"
+
+{ ledrow s1 v1 r1 pass sessA; ledrow s2 v2 r1 pass sessB; } > "$T/evals/demofix/trials.jsonl"
+F=$(python3 "$PARETO" "$T/evals/demofix/trials.jsonl" | grep "^frontier")
+echo "$F" | grep -q "v1" && echo "$F" | grep -q "v2" \
+  && ok "S3 pareto: coverage gap => no dominance (both frontier)" || bad "S3 pareto coverage gap ($F)"
+
+{ ledrow s1 v1 r1 pass sessA; ledrow s1 v2 r1 pass sessB; } > "$T/evals/demofix/trials.jsonl"
+python3 "$PARETO" "$T/evals/demofix/trials.jsonl" --json | python3 -c "import json,sys; d=json.load(sys.stdin); assert d['frontier']==['v1','v2']; assert 'variant' in d['target']" \
+  && ok "S4 pareto: equal profiles share frontier; --json target present" || bad "S4 pareto equal/json"
+
+# point-in-time plateau: promo ts BEFORE the trials that made its variant win => off-frontier at its time
+writetrials
+{ ledrow s1 v1 r1 fail sessA; ledrow s1 v1 r2 fail sessA; } >> "$T/evals/demofix/trials.jsonl"   # ts 00:00
+sed -i '' 's/2026-09-04T00:00:00/2026-09-04T01:00:00/' "$T/evals/demofix/trials.jsonl" 2>/dev/null || true
+# rebuild with explicit timestamps: v2 trials at 03:00, promos at 02:00 (both promos pre-date v2 evidence)
+{ printf '{"ts":"2026-09-04T02:00:00+00:00","skill":"demofix","scenario":"s1","variant":"v1","run":"r1","verdict":"fail","reason":"x","sha256":"a","oracle":"o","task":"t","session":"sessA"}\n'
+  printf '{"ts":"2026-09-04T03:00:00+00:00","skill":"demofix","scenario":"s1","variant":"v2","run":"r1","verdict":"pass","reason":"x","sha256":"b","oracle":"o","task":"t","session":"sessA"}\n'
+  printf '{"ts":"2026-09-04T03:00:00+00:00","skill":"demofix","scenario":"s1","variant":"v2","run":"r2","verdict":"pass","reason":"x","sha256":"b","oracle":"o","task":"t","session":"sessA"}\n'; } > "$T/evals/demofix/trials.jsonl"
+printf '{"ts":"20260904T020000Z","skill":"demofix","from_variant":"v0","to_variant":"c1"}\n' > "$T/evals/demofix/promotions.jsonl"
+printf '{"ts":"20260904T021000Z","skill":"demofix","from_variant":"c1","to_variant":"c2"}\n' >> "$T/evals/demofix/promotions.jsonl"
+python3 "$PARETO" "$T/evals/demofix/trials.jsonl" --plateau "$T/evals/demofix/promotions.jsonl" | grep -q "PLATEAU CHECK \[PLATEAU\]" \
+  && ok "S5 pareto: point-in-time plateau detects stalled promos" || bad "S5 pareto point-in-time plateau"
+printf '{"ts":"20260904T040000Z","skill":"demofix","from_variant":"x","to_variant":"v2"}\n' >> "$T/evals/demofix/promotions.jsonl"
+python3 "$PARETO" "$T/evals/demofix/trials.jsonl" --plateau "$T/evals/demofix/promotions.jsonl" | grep -q "PLATEAU CHECK \[ALIVE\]" \
+  && ok "S6 pareto: frontier-entering promo keeps loop ALIVE" || bad "S6 pareto ALIVE"
+
+# ================= trigger_eval.py =================
+CASES="$T/evals/trigger-cases.jsonl"
+{ printf '{"id":"t1","utterance":"do the demo fix thing","expected":"demofix","note":"core domain"}\n'
+  printf '{"id":"t2","utterance":"say hi","expected":"none","note":"smalltalk tripwire"}\n'; } > "$CASES"
+python3 "$TRIGGER" --check >/dev/null 2>&1 \
+  && ok "S7 trigger --check: valid fixture accepted" || bad "S7 trigger --check valid"
+
+printf '{"id":"t1","utterance":"a","expected":"demofix","note":"n"}\n{"id":"t1","utterance":"b","expected":"none","note":"n"}\n' > "$CASES"
+python3 "$TRIGGER" --check >/dev/null 2>&1 && bad "S8 trigger: duplicate id accepted" || ok "S8 trigger: duplicate id rejected"
+printf '{"id":"t1","utterance":"a","expected":"ghostskill","note":"n"}\n' > "$CASES"
+python3 "$TRIGGER" --check >/dev/null 2>&1 && bad "S9 trigger: unknown expected accepted" || ok "S9 trigger: unknown expected rejected"
+printf '{"id":"t1","utterance":"a","expected":"demofix"}\n' > "$CASES"
+python3 "$TRIGGER" --check >/dev/null 2>&1 && bad "S10 trigger: missing note accepted" || ok "S10 trigger: missing note rejected"
+{ printf '{"id":"t1","utterance":"do the demo fix thing","expected":"demofix","note":"core domain"}\n'
+  printf '{"id":"t2","utterance":"say hi","expected":"none","note":"smalltalk tripwire"}\n'; } > "$CASES"
+
+printf '1: demofix\n' > "$T/ans-partial.txt"
+python3 "$TRIGGER" --score "$T/ans-partial.txt" --run-id r --variant v >/dev/null 2>&1 \
+  && bad "S11 trigger: partial answers accepted" || ok "S11 trigger: partial answers refused"
+printf '1: demofix\n1: none\n2: none\n' > "$T/ans-dup.txt"
+python3 "$TRIGGER" --score "$T/ans-dup.txt" --run-id r --variant v >/dev/null 2>&1 \
+  && bad "S12 trigger: duplicate answers accepted" || ok "S12 trigger: duplicate answers refused"
+printf '1: demofix\n2: none\n' > "$T/ans-ok.txt"
+python3 "$TRIGGER" --score "$T/ans-ok.txt" --run-id r --variant v --ok ghost >/dev/null 2>&1 \
+  && bad "S13 trigger: unknown --ok id accepted" || ok "S13 trigger: unknown --ok id refused"
+printf '1: DEMOFIX (because reasons)\n2: NONE\n' > "$T/ans-case.txt"
+python3 "$TRIGGER" --score "$T/ans-case.txt" --run-id smoke-r1 --variant inc --note casefold >/dev/null 2>&1 \
+  && ok "S14 trigger: annotations + case-insensitive verdicts scored" || bad "S14 trigger score failed"
+python3 -c "import json,sys; r=[json.loads(l) for l in open('$T/evals/trigger-evals.jsonl')][-1]; assert r['run_id']=='smoke-r1' and r['baseline_run'] is None, r" \
+  && ok "S15 trigger: first run stamped baseline_run=null" || bad "S15 trigger baseline stamp"
+# regressing run: t1 wrong -> demofix rate drops vs baseline -> REGRESSION flagged
+printf '1: none\n2: none\n' > "$T/ans-reg.txt"
+python3 "$TRIGGER" --score "$T/ans-reg.txt" --run-id smoke-r2 --variant cand --ok t1 --note "adjudicated, but rate drop must still flag" >/dev/null 2>&1
+python3 -c "import json; r=[json.loads(l) for l in open('$T/evals/trigger-evals.jsonl')][-1]; assert r['baseline_run']=='smoke-r1' and r['regressions'], r" \
+  && ok "S16 trigger: auto-baseline + cross-skill regression flagged" || bad "S16 trigger regression detection"
+# clean candidate run over same table: auto-baseline to smoke-r1, no regressions => G7-eligible
+printf '1: demofix\n2: none\n' > "$T/ans-clean.txt"
+python3 "$TRIGGER" --score "$T/ans-clean.txt" --run-id smoke-r3 --variant candclean >/dev/null 2>&1
+python3 -c "import json; r=[json.loads(l) for l in open('$T/evals/trigger-evals.jsonl')][-1]; assert r['baseline_run']=='smoke-r1' and not r['regressions'] and r['effective']>=0.75, r" \
+  && ok "S17 trigger: clean run is G7-eligible (baseline + no regressions)" || bad "S17 trigger clean run"
+
+# ================= promote.py gates =================
+PR() { python3 "$PROMOTE" --skill demofix --candidate "$1" --incumbent-variant v1 2>/dev/null; }
+writetrials
+{ ledrow s1 v1 r1 fail sessA; ledrow s1 v1 r2 fail sessA
+  ledrow s1 cand r1 pass sessA; ledrow s1 cand r2 pass sessA; } >> "$T/evals/demofix/trials.jsonl"
+mkcand cand "Demo fixture skill for gate probes with a description long enough."
+
+mkcand short "tiny"
+PR short | grep -q "FAIL  G1" && ok "S18 G1: short description rejected" || bad "S18 G1 short desc"
+mkcand holder "Demo fixture skill for gate probes with a description long enough but holding a TODO marker inside."
+PR holder | grep -q "FAIL  G1" && ok "S19 G1: placeholder marker rejected" || bad "S19 G1 placeholder"
+mkcand nocite "Demo fixture skill for gate probes with a description long enough."
+printf 'no citations here at all\n' > "$T/evals/demofix/candidates/nocite/MUTATION.md"
+PR nocite | grep -q "FAIL  G4" && ok "S20 G4: mutation without trial citation rejected" || bad "S20 G4 citation"
+mkcand grow "Demo fixture skill for gate probes with a description long enough." 1200
+PR grow | grep -q "FAIL  G6" && ok "S21 G6: overgrowth rejected" || bad "S21 G6 overgrowth"
+mkcand growok "Demo fixture skill for gate probes with a description long enough." 400
+PR growok | grep -q "PASS  G6" && ok "S22 G6: growth within allowance passes" || bad "S22 G6 within allowance"
+
+# G7 sequence on desc-changing candidates (clean fixture ledger from above)
+mkcand nodata "A completely different unmeasured description for the demo fixture skill."
+PR nodata | grep -q "FAIL  G7" && ok "S23 G7: desc change with no trigger run rejected" || bad "S23 G7 no run"
+: > "$T/evals/trigger-evals.jsonl"
+printf '{"ts":"t","run_id":"vacuous","variant":"nodata","cases_sha":"x","cases":2,"answers":{},"literal":1.0,"effective":1.0,"confusions":[],"per_skill":{},"regressions":[],"threshold":0.75,"agent":"x","tokens":1,"note":"no baseline"}\n' >> "$T/evals/trigger-evals.jsonl"
+PR nodata | grep -q "FAIL  G7" && ok "S24 G7: baseline-free run rejected (loophole stays closed)" || bad "S24 G7 vacuous run"
+mkcand candclean "A genuinely re-measured description for the demo fixture skill, evolved."
+# S24's truncation wiped the ledger — re-establish: incumbent run first (no
+# baseline available), then the candidate run auto-baselines to it
+python3 "$TRIGGER" --score "$T/ans-clean.txt" --run-id smoke-r4 --variant inc --note reseed >/dev/null 2>&1
+python3 "$TRIGGER" --score "$T/ans-clean.txt" --run-id smoke-r5 --variant candclean >/dev/null 2>&1
+PR candclean | grep -q "PASS  G7" && ok "S25 G7: baseline-referenced clean run passes" || bad "S25 G7 eligible run"
+# G3 regression locks (the 3 confirmed blind spots + legit path)
+writetrials
+{ ledrow s1 v1 r1 fail sessA; ledrow s1 v1 r2 fail sessA
+  ledrow s1 cand r1 pass sessB; ledrow s1 cand r2 pass sessB; } >> "$T/evals/demofix/trials.jsonl"
+mkcand cand "Demo fixture skill for gate probes with a description long enough."
+PR cand | grep -q "FAIL  G3" && ok "S26 G3: cross-session fix claim rejected" || bad "S26 G3 cross-session"
+writetrials
+{ ledrow s1 v1 r1 fail sessA; ledrow s1 v1 r2 fail sessA
+  ledrow s1 cand r1 pass sessA; ledrow s1 cand r2 pass sessA
+  ledrow s2 cand r1 fail sessA; } >> "$T/evals/demofix/trials.jsonl"
+PR cand | grep -q "FAIL  G3" && ok "S27 G3: candidate-only scenario fail rejected" || bad "S27 G3 candidate-only"
+writetrials
+{ ledrow s1 v1 r1 fail sessA; ledrow s1 v1 r2 fail sessA
+  ledrow s1 cand r1 pass sessA; ledrow s1 cand r2 pass sessA
+  ledrow s2 v1 r1 pass sessA; ledrow s2 v1 r2 pass sessA
+  ledrow s2 cand r1 pass sessA; ledrow s2 cand r2 pass sessA; } >> "$T/evals/demofix/trials.jsonl"
+PR cand | grep -q "PASS  G3" && ok "S28 G3: same-session paired evidence passes" || bad "S28 G3 legit path"
+
+# ================= grade.py =================
+writetrials
+python3 - "$T/raw-nomarkers.txt" <<'PYEOF'
+import sys; open(sys.argv[1], "w").write("junk without markers\n")
+PYEOF
+python3 "$GRADE" --record "$T/evals" demofix s1 cand nr1 "$T/raw-nomarkers.txt" --session smoke >/dev/null 2>&1
+python3 -c "import json; r=[json.loads(l) for l in open('$T/evals/demofix/trials.jsonl')][-1]; assert r['verdict']=='fail' and 'protocol_fail' in r['reason'], r" \
+  && ok "S29 grade: missing OUTPUT markers => protocol_fail" || bad "S29 grade protocol_fail"
+python3 - "$T/raw-fenced.txt" <<'PYEOF'
+import sys; open(sys.argv[1], "w").write("OUTPUT_BEGIN\n```\nPASS\n```\nOUTPUT_END\n")
+PYEOF
+python3 "$GRADE" --record "$T/evals" demofix s1 cand fr1 "$T/raw-fenced.txt" --session smoke >/dev/null 2>&1
+python3 -c "import json; r=[json.loads(l) for l in open('$T/evals/demofix/trials.jsonl')][-1]; assert r['verdict']=='pass', r" \
+  && ok "S30 grade: fenced payload inside markers stripped and passes" || bad "S30 grade fence strip"
+python3 "$GRADE" --record "$T/evals" demofix s1 cand fr1 "$T/raw-fenced.txt" --session smoke 2>/dev/null | grep -q "DUPLICATE" \
+  && ok "S31 grade: identical re-record deduplicated" || bad "S31 grade dedup"
+
+# ================= selftest on fixture =================
+python3 "$SELFTEST" "$T/evals/demofix" 2>/dev/null | grep -q "GREEN" \
+  && ok "S32 selftest: fixture scenario green" || bad "S32 selftest fixture"
+
+echo "----"
+echo "skill-forge smoke: $pass pass, $fail fail"
+[ "$fail" -eq 0 ]
diff --git a/plugins/zcoder/tests/skill-forge-static.sh b/plugins/zcoder/tests/skill-forge-static.sh
new file mode 100644
index 0000000..8ed78c0
--- /dev/null
+++ b/plugins/zcoder/tests/skill-forge-static.sh
@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+# skill-forge static scorecard — deterministic integrity checks, zero tokens.
+# Usage: bash tests/skill-forge-static.sh   (exit 0 iff all checks pass)
+cd "$(dirname "$0")/.." || exit 1
+pass=0; fail=0
+ok()  { pass=$((pass+1)); echo "PASS  $1"; }
+bad() { fail=$((fail+1)); echo "FAIL  $1"; }
+
+# --- F1: manifests valid, version bumped ---
+python3 -c "import json;j=json.load(open('.zcode-plugin/plugin.json'));assert j['version']" 2>/dev/null \
+  && ok "F1 plugin.json valid" || bad "F1 plugin.json invalid"
+
+# --- F2: skill-forge components present ---
+for f in skills/skill-forge/SKILL.md commands/skill-scan.md commands/skill-evolve.md \
+         skills/skill-forge/scripts/grade.py skills/skill-forge/scripts/oracle_selftest.py \
+         skills/skill-forge/scripts/stats.py skills/skill-forge/scripts/promote.py \
+         skills/skill-forge/scripts/scan_project.py \
+         skills/skill-forge/scripts/pareto.py skills/skill-forge/scripts/trigger_eval.py; do
+  [ -f "$f" ] && ok "F2 $f" || bad "F2 missing $f"
+done
+
+# --- F3: scripts compile ---
+python3 -m py_compile skills/skill-forge/scripts/*.py 2>/dev/null \
+  && ok "F3 scripts compile" || bad "F3 script compile error"
+
+# --- F4: every SKILL.md parses; caps ENFORCED for forge-managed skills only.
+# Forge-managed = has a tests/skill-evals/<name>/ suite (or is skill-forge).
+# Legacy skills (e.g. glm-orchestrator, desc 589 chars, trigger-tuned over two
+# OHI rounds) are never auto-failed on caps — their description is calibrated
+# surface, not bureaucracy; length is reported as info.
+for sk in skills/*/; do
+  sk="${sk%/}"
+  if [ -d "tests/skill-evals/$sk" ] || [ "$sk" = "skill-forge" ]; then mode=strict; else mode=legacy; fi
+  python3 - "$sk" "$mode" <<'EOF' && ok "F4 $sk frontmatter ($mode)" || bad "F4 $sk frontmatter ($mode)"
+import re, sys
+meta_m = re.match(r"^---\n(.*?)\n---\n(.*)$", open(f"{sys.argv[1]}/SKILL.md").read(), re.S)
+assert meta_m, "no frontmatter"
+meta = dict(l.split(":",1) for l in meta_m.group(1).splitlines() if ":" in l)
+d = meta.get("description","").strip()
+assert len(d) >= 20, f"desc too short ({len(d)})"
+if sys.argv[2] == "strict":
+    assert len(d) <= 500, f"desc len {len(d)} > 500 (forge cap)"
+    assert len(meta_m.group(2).encode()) <= 15360, "body over cap"
+else:
+    print(f"  (legacy desc {len(d)} chars, body {len(meta_m.group(2).encode())}B — info only)")
+EOF
+done
+
+# --- F5: every scenario dir complete (task/oracle/references) + selftest green ---
+for ev in tests/skill-evals/*/; do
+  skill=$(basename "$ev")
+  for sc in "$ev"scenarios/*/; do
+    [ -f "$sc/task.md" ] && [ -f "$sc/oracle/checker.py" ] \
+      && ls "$sc"/oracle/reference_good.* >/dev/null 2>&1 \
+      && ls "$sc"/oracle/reference_bad.* >/dev/null 2>&1 \
+      && ok "F5 $skill/$(basename "$sc") scenario complete" \
+      || bad "F5 $skill/$(basename "$sc") incomplete"
+  done
+  python3 skills/skill-forge/scripts/oracle_selftest.py "$ev" >/dev/null 2>&1 \
+    && ok "F5 $skill oracle self-test green" || bad "F5 $skill oracle self-test"
+done
+
+# --- F6: ledgers parse as JSONL ---
+for led in tests/skill-evals/*/trials.jsonl; do
+  [ -f "$led" ] || continue
+  python3 -c "import json,sys;[json.loads(l) for l in open('$led') if l.strip()]" 2>/dev/null \
+    && ok "F6 $(basename "$(dirname "$led")") trials.jsonl parses" || bad "F6 $led unparseable"
+done
+
+# --- F7: candidates carry MUTATION.md ---
+for cand in tests/skill-evals/*/candidates/*/; do
+  [ -d "$cand" ] || continue
+  [ -f "$cand/MUTATION.md" ] && ok "F7 $(basename "$cand") has MUTATION.md" \
+    || bad "F7 candidate $(basename "$cand") missing MUTATION.md"
+done
+
+# --- F8: trigger-surface eval (Hermes Phase-2 port) integrity ---
+if [ -f tests/skill-evals/trigger-cases.jsonl ]; then
+  python3 skills/skill-forge/scripts/trigger_eval.py --check >/dev/null 2>&1 \
+    && ok "F8 trigger-cases.jsonl validates (--check green)" \
+    || bad "F8 trigger-cases.jsonl fails --check"
+  python3 -c "import json;[json.loads(l) for l in open('tests/skill-evals/trigger-evals.jsonl') if l.strip()]" 2>/dev/null \
+    && ok "F8 trigger-evals.jsonl parses" \
+    || bad "F8 trigger-evals.jsonl unparseable"
+  grep -q "G7" skills/skill-forge/scripts/promote.py \
+    && ok "F8 promote.py wires G7 trigger-evidence gate" \
+    || bad "F8 promote.py missing G7"
+else
+  bad "F8 tests/skill-evals/trigger-cases.jsonl missing"
+fi
+
+# --- F9: growth-limit gate present (Hermes max_prompt_growth port) ---
+grep -q "GROWTH_RATIO" skills/skill-forge/scripts/promote.py \
+  && ok "F9 promote.py wires G6 growth-limit gate" \
+  || bad "F9 promote.py missing G6"
+
+# --- F10: pareto.py runs green on every ledger (frontier + target smoke) ---
+for led in tests/skill-evals/*/trials.jsonl; do
+  [ -f "$led" ] || continue
+  python3 skills/skill-forge/scripts/pareto.py "$led" >/dev/null 2>&1 \
+    && ok "F10 pareto $(basename "$(dirname "$led")")" \
+    || bad "F10 pareto fails on $led"
+done
+
+# --- F11: smoke battery green (adversarial gate fixtures; born from the
+#     2026-09-04 audit that caught 3 gate blind spots + 1 scorer bug) ---
+bash tests/skill-forge-smoke.sh >/dev/null 2>&1 \
+  && ok "F11 smoke battery (tests/skill-forge-smoke.sh)" \
+  || bad "F11 smoke battery failed"
+
+echo "----"
+echo "skill-forge static: $pass pass, $fail fail"
+[ "$fail" -eq 0 ]
diff --git a/plugins/zcoder/tests/skill-grader-rubric.md b/plugins/zcoder/tests/skill-grader-rubric.md
new file mode 100644
index 0000000..3da547a
--- /dev/null
+++ b/plugins/zcoder/tests/skill-grader-rubric.md
@@ -0,0 +1,25 @@
+# zCoder Skill Grader Rubric (v1)
+
+Grade each target file 0–10 per dimension, with one line of evidence per score. You are an independent grader: you did not write these files; judge only what the file says against the dimension and against verified reality you can check in-repo. No politeness inflation — a 7 means good, a 5 means mediocre, below 5 means defective.
+
+Dimensions:
+
+1. **Trigger precision** — the description fires on exactly the requests it should: no over-trigger (atomic/meta questions matching), no under-trigger (delegatable work escaping), anti-triggers explicit.
+2. **Description economy** — ≤~80 words, every clause load-bearing, commands/anchors last; no clause piles that dilute matching.
+3. **Instruction quality** — imperative form; non-obvious rules carry their why; examples where structured output is expected; no ALL-CAPS crutches substituting for explanation.
+4. **Structural fit** — progressive disclosure: short metadata, body <500 lines, detail pushed to load-on-demand references; nothing the reader must hold before acting.
+5. **Factual accuracy** — every checkable claim (pins, model catalog, capabilities, states) matches the repo's verified reality (agents/*.md frontmatter, tests/capability-ledger.json).
+6. **Internal consistency** — no contradictions between the file's own sections or with sibling surfaces (hook text, agent descriptions).
+7. **Testability** — rules are predicate-shaped and concrete (numbers, first-match ordering), not judgment calls; an executor can decide without taste.
+8. **Negative scope** — explicit do-NOT boundaries for the failure modes that matter.
+
+Output contract (per file):
+
+```
+GRADE <file>
+scores: d1..d8 each "n/10 — evidence"
+overall: weighted mean to 1 decimal (d1,d5,d7 count double — trigger, truth, testability are the product)
+top_fixes: ≤3 concrete textual changes, ranked by expected score gain, each a replacement snippet or precise edit instruction
+```
+
+Grading targets: skills/glm-orchestrator/SKILL.md (primary), commands/orchestrate.md, commands/route.md (command-skill equivalents).
diff --git a/plugins/zcoder/tests/skill-scores.json b/plugins/zcoder/tests/skill-scores.json
new file mode 100644
index 0000000..66039dd
--- /dev/null
+++ b/plugins/zcoder/tests/skill-scores.json
@@ -0,0 +1,29 @@
+{
+  "rubric": "tests/skill-grader-rubric.md",
+  "target_hash": "46b615a00ade28137772dffe78635921018149b7",
+  "measurement_note": "grader-to-grader overall variance ±0.4 observed on identical files; compare dimension vectors and defect lists across rounds, never bare overalls",
+  "rounds": [
+    {
+      "date": "2026-09-04", "round": "baseline", "grader": "agent_1ebf0dd3",
+      "scores": {
+        "skills/glm-orchestrator/SKILL.md":    {"overall": 8.3, "d": [8,6,9,9,7,7,9,9],  "defects": ["description model map says GLM-5-Turbo (false)", "description ~110 words over cap", "batch trigger over-fires on trivial batches"]},
+        "commands/orchestrate.md":              {"overall": 8.1, "d": [8,9,8,9,9,9,7,6],  "defects": ["no negative scope of its own", "plan-JSON emission can read as always-emit"]},
+        "commands/route.md":                    {"overall": 8.6, "d": [8,10,9,10,9,9,7,9], "defects": ["no first-match ordering instruction", "turbo plan can print as dispatchable"]}
+      }
+    },
+    {
+      "date": "2026-09-04", "round": "post-fix", "grader": "agent_5d379af3",
+      "verified_fixes": "all three baseline defects verified fixed (cross-checked vs agents/*.md frontmatter + capability-ledger)",
+      "scores": {
+        "skills/glm-orchestrator/SKILL.md":    {"overall": 8.2, "d": [9,9,9,9,9,9,9,9], "defects": []},
+        "commands/orchestrate.md":              {"overall": 8.0, "d": [9,10,8,9,9,9,8,8], "defects": []},
+        "commands/route.md":                    {"overall": 8.2, "d": [9,9,9,9,9,9,9,9], "defects": []}
+      }
+    }
+  ],
+  "pending_polish": [
+    "SKILL description: move /orchestrate//route anchor to final clause (+0.1)",
+    "SKILL effort section: re-date heading vs 09-03/04 evidence span (+0.1)",
+    "route.md: '(from agents/*.md frontmatter, do not re-derive)' on the effort column (+0.1)"
+  ]
+}