@kontextmind/kxm 0.7.188 → 0.7.190

package/docs/evals/planner-bakeoff-2026-10/raw/writer2-sonnet.txt

@@ -0,0 +1,79 @@
+## Outcome
+Replace writer #2 `pi-qwen3-coder-plus-openrouter` with `pi-qwen3-coder-next-openrouter` (model `openrouter/qwen/qwen3-coder-next`, vendor alibaba, permission edit, harness pi). Writer #1 and #3–#6 stay in their current order. The old route is retired, not deleted.
+
+**Why qwen3-coder-next:**
+- It is a Qwen model, so the OpenRouter route is allowed. Qwen has no native harness.
+- It is the closest successor to a coder-specialised model.
+- At 0.12 / 0.80 it is the cheapest candidate.
+- It has a flat price, so there is no long-context premium like qwen3.7-plus's 0.96 / 3.84 tier at 256000 tokens and above.
+- Its 262144 context is smaller than the alternatives. That is acceptable for edit-sized writer prompts.
+
+**Tool-support assumption (labeled):** the packet does not show `supported_parameters`. I assume `qwen3-coder-next` supports tools because it is a coder model. The writer must verify this against the live OpenRouter models API before admitting the route (see Risks and guards).
+
+**Fallback if tool support is not shown:** `qwen/qwen3.7-plus` is the second choice. It would need the same check, and the premium tier must be recorded.
+
+## Files
+- `.kxm/models/pi-qwen3-coder-next-openrouter.yaml`: schema `kxm.model.v2`, harness pi, vendor alibaba, permissions include edit. Add alias `qwen-next-openrouter-pi`.
+- Model inventory file: add the new id. This must come before the routes change.
+- Routes file: add the new route as admitted. Mark `pi-qwen3-coder-plus-openrouter` retired in a comment, remove it from the admitted list, and remove it from the writer roster so #2 is the new route. Keep the old alias out of the active lists.
+- Inventory: keep the old id with a retired comment. Do not reuse its alias.
+- `.kxm/prices.yaml`: add the `qwen/qwen3-coder-next` row at 0.12 / 0.80. Keep the `qwen/qwen3-coder-plus` row at its last list price. Update the date and sha256 together.
+- Writer roster definition (assignment runner): swap #2 only.
+- `plans/evidence/<date>-writer-2-qwen3-coder-next.md`: evidence note.
+
+## Tests
+- Roster-policy tests: update the hardcoded #2 id. Assert that #1 and #3–#6 are unchanged and in order (Argon high, Argon medium, Flash medium, Flash high).
+- Add a test that the retired route is not admitted and not on the roster.
+- Add a test that the new id exists in inventory before routes admit it. This should fail if the order is wrong.
+- Prices loader test: the sha256 and date match, and the old row is still present.
+- Brake test: no `moonshotai/*` route through Pi/OpenRouter.
+- Model file schema test: `kxm.model.v2`, vendor alibaba, edit permission.
+- Run `npm run verify`.
+
+## Docs
+Update every place that names writer #2 or `qwen3-coder-plus`:
+- harness-routing
+- config reference
+- CLI reference
+- assignment runner doc
+- glossary, only if it names the route
+- changelog
+- `plans/implementation-plan.md` Tracking (Decided and the relevant slice)
+- generated `dist`, only if a grep shows the string embedded. If it is, regenerate rather than hand-edit.
+
+Do not rewrite historical evidence or changelog entries that describe the old route as it was.
+
+## Risks and guards
+- **Tool support is unproven in the packet.** Before admission, the writer must check `supported_parameters` for tools in the live models API. If it is absent, do not admit. Fall back to the next candidate that shows tools, or leave #2 vacant with the gap recorded. Never admit on assumption alone.
+- **Moonshot `kimi-k2.7-code` is refused.** Moonshot has a native kimi harness, and billing a native vendor through Pi/OpenRouter is the brake case. It is the only candidate that falls under the brake.
+- **Meta `muse-spark-open` is not auto-admitted.** It is an admission question, and it is also the most expensive per token.
+- **Price pin:** the loader refuses a date or sha256 mismatch. Update both in the same commit and recompute the hash after the final edit.
+- **Order dependency:** inventory must contain the id before routes admit it.
+- **404 risk repeats:** record the verification date, 2026-10-17, in the evidence note.
+- **No dual names or alias for the retired route.** Old names fail closed.
+
+## Sequence
+1. Verify `qwen3-coder-next` live and tool-capable. Record the result in the evidence note.
+2. Add the model file.
+3. Add the inventory entry, with the retired comment on the old id.
+4. Add the prices row, then update the date and recompute the sha256.
+5. Update routes: admit the new route, retire the old one, update the roster.
+6. Update the tests.
+7. Update the docs, changelog and Tracking.
+8. Regenerate `dist` if needed.
+9. Run `npm run verify`.
+
+## Non-goals
+- Do not change writer #1, the planner, `reviewer-cli`, or `reviewer-arch`.
+- Do not reorder Argon or Flash.
+- Do not add a harness preferences overlay.
+- Do not delete the old price row.
+- Do not add a compatibility alias.
+- Do not run a side-by-side model comparison.
+
+## Open questions
+- Does `qwen/qwen3-coder-next` list tool support? The packet does not show `supported_parameters` for any candidate.
+- What is the exact evidence-note filename convention, and where do the inventory and routes files live?
+- What is the last list price of `qwen3-coder-plus`? It is not in the packet, so keep the row as it is.
+- Does effort stay medium for the new route? I assume yes.
+- Is a 262144 context enough for assignment prompts? This is unmeasured.

package/docs/evals/planner-bakeoff-2026-10/score.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+"""Score the committed planner bake-off, or refuse to invent a new one.
+
+Scoring reads raw plans, blinded judge JSON, and the price catalogs.
+It does not call a model.
+
+``--run`` is the regeneration path. It does not run unless the native
+``claude`` binary is on PATH and ``claude auth status`` succeeds, or
+``ANTHROPIC_API_KEY`` is set. This checkout had neither, so the committed
+plans came from Cursor subagents. See the report for that transport.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+import shutil
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+REPO = ROOT.parents[2]
+RAW = ROOT / "raw"
+JUDGE = ROOT / "judge"
+PROMPTS = ROOT / "prompts"
+
+TASKS = ("argon", "reviewer", "writer2", "weekly", "wiki", "journal")
+MODELS = ("fable", "sonnet")
+DIMS = ("correctness", "completeness", "risk", "sequencing", "conciseness")
+
+# Blind labels from random.seed(20261017), shuffled per task.
+LABELS = {
+    "argon": {"A": "fable", "B": "sonnet"},
+    "reviewer": {"A": "sonnet", "B": "fable"},
+    "writer2": {"A": "fable", "B": "sonnet"},
+    "weekly": {"A": "sonnet", "B": "fable"},
+    "wiki": {"A": "sonnet", "B": "fable"},
+    "journal": {"A": "fable", "B": "sonnet"},
+}
+
+# Checklist over the full raw plan. A hit is a case-insensitive regex.
+# This is a scripted cross-check, not the official score. The official
+# score is the blinded gpt-5.6-sol judge.
+CHECKS: dict[str, list[tuple[str, str]]] = {
+    "argon": [
+        ("argon high on the roster", r"gemini-4-argon-high|argon-high"),
+        ("argon medium on the roster", r"gemini-4-argon-medium|argon-medium"),
+        ("argon tried before flash", r"argon-medium[\s\S]{0,80}flash|argon-high[\s\S]{0,120}flash"),
+        ("grok stays primary", r"grok-grok-4-7"),
+        ("flash medium stays", r"flash-medium|gemini-3-8-flash-medium"),
+        ("flash high stays", r"flash-high|gemini-3-8-flash-high"),
+        ("no OpenRouter Google route", r"openrouter"),
+        ("list price 2 and 10", r"\$2|inputPerMillion: 2|2 / 10|\$2 and \$10"),
+        ("sha256 pin", r"sha256"),
+        ("planner stays fable", r"claude-fable"),
+        ("harness-routing doc", r"harness-routing"),
+        ("tracking updated", r"implementation-plan|Tracking"),
+    ],
+    "reviewer": [
+        ("new primary id", r"codex-gpt-6-1-sol"),
+        ("5.6 stays last", r"codex-gpt-5-6-sol"),
+        ("pi fallback stays", r"pi-qwen3-8-flash"),
+        ("pro is an alias", r"alias"),
+        ("tier boundary", r"272000"),
+        ("sha256 pin", r"sha256"),
+        ("arch critic unchanged", r"reviewer-arch"),
+        ("native brake", r"openai-codex|openrouter"),
+        ("agents table", r"AGENTS\.md"),
+        ("harness-run scripts", r"harness-run"),
+    ],
+    "writer2": [
+        ("old route retired", r"retired"),
+        ("old price row kept", r"qwen3-coder-plus"),
+        ("moonshot refused", r"moonshot|kimi"),
+        ("evidence note", r"plans/evidence"),
+        ("sha256 pin", r"sha256"),
+        ("argon order untouched", r"[Aa]rgon"),
+        ("tool gate", r"tool"),
+        ("inventory before admit", r"inventory"),
+        ("qwen3.7-plus considered", r"qwen3\.7-plus"),
+        ("meta not auto-admitted", r"meta|muse"),
+    ],
+    "weekly": [
+        ("workflow file", r"\.github/workflows"),
+        ("routes file untouched", r"routes\.yaml"),
+        ("auth failure fails closed", r"401|403"),
+        ("date and hash together", r"sha256"),
+        ("cli-only rows kept", r"CLI-only|pi`, `grok`"),
+        ("pr body lists ids", r"added"),
+        ("no auto-merge", r"auto-merge|gh pr merge"),
+        ("unit tests", r"[Tt]est"),
+        ("harness-routing doc", r"harness-routing"),
+        ("changelog", r"CHANGELOG"),
+    ],
+    "wiki": [
+        ("under .kxm/knowledge", r"\.kxm/knowledge"),
+        ("compile stays off", r"wiki-compile|ingest"),
+        ("architecture page", r"architecture"),
+        ("glossary link", r"glossary"),
+        ("ci pattern", r"CI / required|control-plane"),
+        ("runbooks", r"runbook"),
+        ("no new npm script", r"npm script"),
+        ("doc links", r"docs/README"),
+        ("not inside compiler wiki/", r"wiki/"),
+        ("no secrets", r"secret"),
+    ],
+    "journal": [
+        ("no new store", r"lands a store|no store|does not land a store|not land a store|No changes to store"),
+        ("workflow_not_found locked", r"workflow_not_found"),
+        ("no relabel", r"relabel"),
+        ("design note", r"design note|runtime-journal"),
+        ("no invented version bump", r"version"),
+        ("tracking", r"Tracking|implementation-plan"),
+        ("no auto-promote", r"auto-promot"),
+        ("refusal test", r"[Tt]est"),
+    ],
+}
+
+
+def estimate_tokens(text: str) -> int:
+    """Ceiling of characters divided by 4. Not a provider tokenizer."""
+    return math.ceil(len(text) / 4)
+
+
+def load_fable_rates() -> tuple[float, float]:
+    text = (REPO / ".kxm" / "prices.yaml").read_text()
+    match = re.search(
+        r"id: anthropic/fable\b.*?inputPerMillion:\s*([0-9.]+)\s*\n\s*outputPerMillion:\s*([0-9.]+)",
+        text,
+        re.S,
+    )
+    if not match:
+        raise SystemExit("prices.yaml has no anthropic/fable tier")
+    return float(match.group(1)), float(match.group(2))
+
+
+def load_sonnet_rates() -> tuple[float, float, str]:
+    text = (REPO / ".kxm" / "prices.yaml").read_text()
+    if re.search(r"id: anthropic/claude-sonnet-5\.5\b", text):
+        match = re.search(
+            r"id: anthropic/claude-sonnet-5\.5\b.*?inputPerMillion:\s*([0-9.]+)\s*\n\s*outputPerMillion:\s*([0-9.]+)",
+            text,
+            re.S,
+        )
+        if not match:
+            raise SystemExit("sonnet row in prices.yaml has no tier")
+        return float(match.group(1)), float(match.group(2)), "prices.yaml"
+    inventory = (REPO / ".kxm" / "models" / "inventory.yaml").read_text()
+    match = re.search(
+        r"id: anthropic/claude-sonnet-5\.5\n(?:.*\n){0,20}?\s*standard:\n\s*inputPerMillion:\s*([0-9.]+)\n\s*outputPerMillion:\s*([0-9.]+)",
+        inventory,
+    )
+    if not match:
+        raise SystemExit("inventory.yaml has no anthropic/claude-sonnet-5.5 standard tier")
+    return float(match.group(1)), float(match.group(2)), "inventory.yaml"
+
+
+def cost(tokens_in: int, tokens_out: int, in_rate: float, out_rate: float) -> float:
+    return (tokens_in * in_rate + tokens_out * out_rate) / 1_000_000
+
+
+def prompt_text(task: str) -> str:
+    shared = (PROMPTS / "shared.txt").read_text()
+    packet = (PROMPTS / f"{task}.txt").read_text()
+    return shared + "\n" + packet
+
+
+def checklist(task: str, text: str) -> tuple[int, int, list[str]]:
+    hits = []
+    missed = []
+    for name, pattern in CHECKS[task]:
+        if re.search(pattern, text, re.I):
+            hits.append(name)
+        else:
+            missed.append(name)
+    return len(hits), len(CHECKS[task]), missed
+
+
+def unblind(task: str) -> dict[str, dict]:
+    payload = json.loads((JUDGE / f"{task}.json").read_text())
+    labels = LABELS[task]
+    out = {}
+    for label, model in labels.items():
+        key = "planA" if label == "A" else "planB"
+        scores = payload[key]
+        out[model] = {
+            "label": label,
+            "scores": {dim: scores[dim] for dim in DIMS},
+            "total": sum(scores[dim] for dim in DIMS),
+        }
+    out["winner_label"] = payload["winner"]
+    winner = {"A": labels["A"], "B": labels["B"], "tie": "tie"}[payload["winner"]]
+    out["winner"] = winner
+    out["rationale"] = payload["rationale"]
+    return out
+
+
+def score() -> dict:
+    fable_in, fable_out = load_fable_rates()
+    sonnet_in, sonnet_out, sonnet_source = load_sonnet_rates()
+    rates = {
+        "fable": (fable_in, fable_out, "prices.yaml anthropic/fable"),
+        "sonnet": (sonnet_in, sonnet_out, sonnet_source + " anthropic/claude-sonnet-5.5"),
+    }
+    tasks = []
+    totals = {model: {"judge": 0, "tokens_in": 0, "tokens_out": 0, "cost": 0.0, "wins": 0} for model in MODELS}
+    for task in TASKS:
+        judged = unblind(task)
+        row = {"task": task, "winner": judged["winner"], "rationale": judged["rationale"], "models": {}}
+        for model in MODELS:
+            text = (RAW / f"{task}-{model}.txt").read_text()
+            prompt = prompt_text(task)
+            tokens_in = estimate_tokens(prompt)
+            tokens_out = estimate_tokens(text)
+            in_rate, out_rate, source = rates[model]
+            price = cost(tokens_in, tokens_out, in_rate, out_rate)
+            got, total, missed = checklist(task, text)
+            entry = {
+                "judge": judged[model],
+                "words": len(text.split()),
+                "tokens_in_estimate": tokens_in,
+                "tokens_out_estimate": tokens_out,
+                "list_cost_usd": round(price, 6),
+                "price_source": source,
+                "checklist_hits": got,
+                "checklist_total": total,
+                "checklist_missed": missed,
+            }
+            row["models"][model] = entry
+            totals[model]["judge"] += judged[model]["total"]
+            totals[model]["tokens_in"] += tokens_in
+            totals[model]["tokens_out"] += tokens_out
+            totals[model]["cost"] += price
+        if judged["winner"] in totals:
+            totals[judged["winner"]]["wins"] += 1
+        tasks.append(row)
+    for model in MODELS:
+        totals[model]["list_cost_usd"] = round(totals[model]["cost"], 6)
+    return {
+        "token_method": "ceil(characters/4) on prompts/<task>.txt plus prompts/shared.txt, and on raw/<task>-<model>.txt. Not provider usage.",
+        "max_judge_per_task": 25,
+        "tasks": tasks,
+        "totals": totals,
+        "rates": {
+            "fable_input": fable_in,
+            "fable_output": fable_out,
+            "sonnet_input": sonnet_in,
+            "sonnet_output": sonnet_out,
+            "sonnet_source": sonnet_source,
+        },
+    }
+
+
+def credentials_present() -> list[str]:
+    missing = []
+    if shutil.which("claude") is None:
+        missing.append("claude CLI is not on PATH (kxm's planner one-shot spawns claude -p)")
+    if not (Path.home() / ".claude").exists() and not (Path.home() / ".config" / "claude").exists():
+        missing.append("no ~/.claude or ~/.config/claude auth directory")
+    # Names only. Do not print values.
+    import os
+    if not os.environ.get("ANTHROPIC_API_KEY"):
+        missing.append("ANTHROPIC_API_KEY is unset")
+    return missing
+
+
+def run_refused() -> int:
+    missing = credentials_present()
+    sys.stderr.write(
+        "planner bake-off regeneration refused.\n"
+        "kxm's planner one-shot is: claude -p --model <model> --effort medium "
+        "--output-format json, plus the read-only permission arguments in "
+        "plugins/kxm/src/harness.ts (oneShotReadOnlyArgs claude).\n"
+        "There is no kxm flag that overrides the planner model without editing "
+        ".kxm/roles/planner.yaml and admitting the route. This bake-off must not do that.\n"
+        "kxm routing benchmark prints placeholder numbers and does not call a model.\n"
+    )
+    if missing:
+        sys.stderr.write("Missing:\n")
+        for item in missing:
+            sys.stderr.write(f"- {item}\n")
+        sys.stderr.write("Refusing to simulate plans.\n")
+        return 2
+    sys.stderr.write("Credentials appear present. This script still does not dispatch; use the native claude one-shot with prompts/*.txt.\n")
+    return 0
+
+
+def main(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--run", action="store_true", help="attempt a live regeneration; fail closed without credentials")
+    parser.add_argument("--score", action="store_true", help="score the committed raw plans")
+    args = parser.parse_args(argv)
+    if args.run:
+        return run_refused()
+    payload = score()
+    json.dump(payload, sys.stdout, indent=2)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/docs/evals/planner-bakeoff-2026-10.md

@@ -0,0 +1,164 @@
+# Planner bake-off, October 2026
+
+This page records a scored comparison of Claude Fable 5.1 and Claude Sonnet 5.5 on six KXM planning tasks. It is for maintainers deciding whether the planner primary should stay Fable. Routing is unchanged.
+
+## Recommendation
+
+Keep Fable as the planner primary. Treat Sonnet 5.5 as a fallback candidate, not a replacement.
+
+Sonnet scored 126 and Fable scored 110, out of 150, on a blinded judge. Sonnet won four tasks and Fable won two. The two Fable wins include the Argon roster, which is the task closest to an admission decision, and Sonnet's Argon plan admitted only the medium pin and placed it after Flash. Six tasks, one judge, and a transport that is not the KXM planner route are not enough to replace the primary. List price favors Sonnet by about five to one, and a native Claude subscription records both as unmetered, so the invoice may not move.
+
+## How this run was scored
+
+The planner roster in `.kxm/roles/planner.yaml` is `claude-fable` at effort medium, then `pi-qwen3-8-flash-openrouter`. The native one-shot is `claude -p --model <model> --effort medium --output-format json` with the read-only arguments in `oneShotReadOnlyArgs` for `claude`. There is no command flag that swaps the planner model without editing the role and admitting a route. `kxm routing benchmark` prints placeholder numbers and does not call a model.
+
+This machine has no `claude` binary, no Claude auth directory, and no `ANTHROPIC_API_KEY`. The committed plans are from Cursor subagents pinned to `claude-fable-5-1-thinking-medium` and `claude-sonnet-5-5-medium`. Both received the same prompt. They were told not to read the checkout, because the landed change would leak the answer. The Argon plans still name `pi-qwen3-coder-plus-openrouter` as writer number two, which the current tree no longer has, so they do not look like a read of the solution.
+
+The judge is `gpt-5.6-sol-medium`. Labels were shuffled with seed `20261017` and stored in `score.py`. The judge scored a section-level condensation of each plan, the same sections for both arms, not the raw file byte for byte. Full text is under `raw/`. A keyword checklist in `score.py` scores the full text and does not pick the winner.
+
+Rubric, 0 to 5 each: correctness against what shipped (or, for the open journal gap, against the written constraints), completeness of files, tests, and docs, risk and fail-closed guards, sequencing, and conciseness. The cap in the prompt was 700 words.
+
+Tokens are `ceil(characters / 4)` on `prompts/` and `raw/`. That is not provider usage. Cache tokens were not observed, so cache rates are not applied. Fable uses the flat tier in `.kxm/prices.yaml` for `anthropic/fable`: $10 input and $50 output per 1M tokens. Sonnet 5.5 has no row in `.kxm/prices.yaml`. Its list estimate uses the standard tier in `.kxm/models/inventory.yaml` for `anthropic/claude-sonnet-5.5`: $2 and $10. `score.py` reads both files.
+
+Twelve plans ran in one parallel wave from 2026-10-17T17:48:29Z to 2026-10-17T17:51:03Z, 154 seconds. The transport did not return per-plan latency, so the table does not invent one.
+
+Regenerate scores with `python3 docs/evals/planner-bakeoff-2026-10/score.py --score`. `score.py --run` exits 2 until the Claude CLI or `ANTHROPIC_API_KEY` is present, and it does not invent plans.
+
+## Totals
+
+| Task | Fable | Sonnet | Winner |
+| --- | --- | --- | --- |
+| Argon writer roster | 19 | 16 | Fable |
+| CLI reviewer switch | 18 | 23 | Sonnet |
+| Writer number two | 13 | 21 | Sonnet |
+| Weekly catalog refresh | 22 | 21 | Fable |
+| Knowledge wiki seed | 18 | 21 | Sonnet |
+| Runtime journal gap | 20 | 24 | Sonnet |
+| Total (max 150) | 110 | 126 | Sonnet, 4 of 6 |
+
+| Task | Input tokens | Fable output | Sonnet output |
+| --- | --- | --- | --- |
+| Argon writer roster | 895 | 1501 | 1359 |
+| CLI reviewer switch | 924 | 1361 | 1306 |
+| Writer number two | 1002 | 1318 | 1344 |
+| Weekly catalog refresh | 800 | 1400 | 1246 |
+| Knowledge wiki seed | 940 | 1295 | 1252 |
+| Runtime journal gap | 661 | 1279 | 1349 |
+| Total | 5222 | 8154 | 7856 |
+
+| Model | List rate per 1M | List cost | Wins |
+| --- | --- | --- | --- |
+| Fable 5.1 | $10 / $50, from `.kxm/prices.yaml` | $0.460 | 2 |
+| Sonnet 5.5 | $2 / $10, from inventory, not `.kxm/prices.yaml` | $0.089 | 4 |
+
+Input tokens are identical because the prompts were identical. Wall time for the wave is 154 seconds, shared.
+
+The keyword checklist matched every required topic on eleven of the twelve plans. Sonnet's Argon plan missed "argon high on the roster" and "argon tried before flash". The checklist does not encode the shipped writer-number-two model, so a perfect checklist there does not mean the plan matched what shipped.
+
+## Argon writer roster
+
+Shipped in pull request 401: Argon high and medium on the writer roster, ahead of Flash medium (the safety net) and Flash high (last, so the file stays on a roster). Low was inventoried and not rostered. Planner primary stayed Fable.
+
+| Dimension | Fable | Sonnet |
+| --- | --- | --- |
+| Correctness | 3 | 1 |
+| Completeness | 3 | 2 |
+| Risk | 5 | 5 |
+| Sequencing | 3 | 3 |
+| Conciseness | 5 | 5 |
+| Total | 19 | 16 |
+
+Fable admitted high and medium and put them ahead of Flash, but swapped Flash medium and high and described the roster as living in `.kxm/routes.yaml`. Sonnet admitted only medium and appended it after both Flash entries. Both refused an OpenRouter Google route. List cost $0.084 versus $0.015.
+
+## CLI reviewer switch
+
+Shipped in pull request 402: `codex-gpt-6-1-sol` at effort low, then `pi-qwen3-8-flash-openrouter`, then `codex-gpt-5-6-sol`. Pro is an alias on the price row. Architecture review stayed Fable.
+
+| Dimension | Fable | Sonnet |
+| --- | --- | --- |
+| Correctness | 3 | 5 |
+| Completeness | 3 | 4 |
+| Risk | 4 | 5 |
+| Sequencing | 3 | 5 |
+| Conciseness | 5 | 4 |
+| Total | 18 | 23 |
+
+Both named the shipped order, the pro alias, the native-vendor brake, and the doc set. The judge marked Sonnet higher because Fable placed the roster reorder inside `.kxm/routes.yaml`. Neither named `workforce-names.mjs`, the review template, or the generated bundles. List cost $0.077 versus $0.015.
+
+## Writer number two
+
+Shipped in pull request 403: `pi-qwen3-7-plus-openrouter`, after a live check that the model lists tools. The old coder-plus route was retired and its price row kept. The packet withheld tool support and told the planner to fail closed.
+
+| Dimension | Fable | Sonnet |
+| --- | --- | --- |
+| Correctness | 2 | 3 |
+| Completeness | 4 | 3 |
+| Risk | 2 | 5 |
+| Sequencing | 2 | 5 |
+| Conciseness | 3 | 5 |
+| Total | 13 | 21 |
+
+Both defaulted to `qwen3-coder-next`, which is not what shipped. Sonnet refused to admit on that assumption and named `qwen3.7-plus` as the fallback if tools were missing. Fable scheduled the tool check after the route edit and moved the old alias onto the new route. List cost $0.076 versus $0.015.
+
+## Weekly catalog refresh
+
+Shipped in pull request 404: `.github/workflows/refresh-models.yml`, a catalog module, a script, and a unit test. Monday 13:00 UTC. One pull request when the catalog changes. Routes are not edited.
+
+| Dimension | Fable | Sonnet |
+| --- | --- | --- |
+| Correctness | 5 | 4 |
+| Completeness | 4 | 4 |
+| Risk | 5 | 5 |
+| Sequencing | 4 | 5 |
+| Conciseness | 4 | 3 |
+| Total | 22 | 21 |
+
+Both chose Monday 06:00 UTC and marked it as a choice, which the packet allowed. Both kept CLI-only rows, refused a token, refused route edits, and refused auto-merge. The one-point edge is not a decision by itself. List cost $0.078 versus $0.014.
+
+## Knowledge wiki seed
+
+Shipped in pull request 405: hand-written pages under `.kxm/knowledge/`, not under `wiki/` and not under a handbook directory. Compile and ingest stayed unselected. No new test, script, or route edit.
+
+| Dimension | Fable | Sonnet |
+| --- | --- | --- |
+| Correctness | 3 | 4 |
+| Completeness | 3 | 3 |
+| Risk | 4 | 5 |
+| Sequencing | 4 | 5 |
+| Conciseness | 4 | 4 |
+| Total | 18 | 21 |
+
+Sonnet put pages at `.kxm/knowledge/` and did not invent a browser flag. Fable used `.kxm/knowledge/handbook/` and named `KXM_BROWSER=steel`, which the packet said not to invent. Both refused ingest and a second glossary. List cost $0.074 versus $0.014.
+
+## Runtime journal gap
+
+Nothing has shipped. The constraint is: no event-store or hub-store schema change while S5 is open, do not relabel a Runtime run as a webhook run, and prefer a design note plus tests that lock `workflow_not_found`.
+
+| Dimension | Fable | Sonnet |
+| --- | --- | --- |
+| Correctness | 4 | 5 |
+| Completeness | 5 | 5 |
+| Risk | 4 | 5 |
+| Sequencing | 4 | 5 |
+| Conciseness | 3 | 4 |
+| Total | 20 | 24 |
+
+Both refused a store and refused invented schema versions. Sonnet stopped at characterization tests and a design note. Fable also changed the CLI message, which is more than the smallest step and still not a schema change. List cost $0.071 versus $0.015.
+
+## Caveats
+
+- Six tasks is a small sample. One task is still open, so its correctness score is against constraints, not a diff.
+- The judge saw condensations. Weekly is a one-point result and could flip. Argon, the reviewer switch, writer number two, and the journal gap are wider.
+- The judge is one model, GPT-5.6 Sol, which is the CLI critic family. It was blind to the author and not blind to the shipped outcome.
+- Token counts and list cost are estimates. Provider usage was not returned. A Claude subscription would record `costBasis: unmetered` for both models.
+- Sonnet's price is not in `.kxm/prices.yaml`. Quoting it from the inventory is a list estimate, and the price loader would mark that row missing.
+- Cursor subagents are not `claude -p` and not the KXM planner route. Effort was medium on both, matching the roster.
+- Pull request 398, the plan-link repair, was not run. The six tasks are the five roster and docs slices from 401 through 405, plus the open Runtime journal gap.
+- Plans were instructed not to use tools. A subagent that ignored that instruction could have read the landed diff. The Argon plans still describe the pre-change writer number two, which argues against that leak, and it is not proof.
+
+## Related
+
+- [Harness routing](reference/harness-routing.md)
+- [Configuration reference](reference/config-reference.md)
+- [CLI reference](reference/cli-reference.md)
+- Raw plans, prompts, judge JSON, and `score.py` live in `docs/evals/planner-bakeoff-2026-10/`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontextmind/kxm",
-  "version": "0.7.188",
+  "version": "0.7.190",
   "description": "KXM local-first multi-agent orchestration and operator dashboard",
   "type": "module",
   "author": "KontextMind",
@@ -44,7 +44,7 @@
     "test:coverage:complete": "npm run build && node scripts/run-bounded.mjs 2400000 node --disable-warning=ExperimentalWarning --experimental-strip-types --test --test-force-exit --test-concurrency=4 --experimental-test-coverage --test-coverage-lines=93 --test-coverage-branches=80 --test-coverage-functions=93 --test-coverage-include=plugins/kxm/src/**/*.ts --test-coverage-exclude=plugins/kxm/src/server.ts --test-coverage-exclude=plugins/kxm/src/mcp-server.ts --test-coverage-exclude=plugins/kxm/src/runtime-supervisor.ts --test-coverage-include=packages/core/*/src/**/*.ts test/core/*.test.ts test/simulations/*.test.ts packages/core/*/tests/unit/*.test.ts",
     "test:coverage": "npm run test:coverage:core",
     "typecheck": "tsc --noEmit",
-    "lint:docs": "markdownlint-cli2",
+    "lint:docs": "markdownlint-cli2 && node scripts/check-plan-links.mjs",
     "check:versions": "node scripts/check-versions.mjs",
     "check": "npm run typecheck && npm run lint:docs && npm run check:versions && node scripts/workforce-lint.mjs",
     "verify": "npm test && npm run check && npm run check:generated",

package/plugins/kxm/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "kxm",
   "displayName": "KXM",
-  "version": "0.7.188",
+  "version": "0.7.190",
   "description": "Headless multi-agent orchestration, durable workflows, and a live operator dashboard for Pi and Claude Code",
   "author": {
     "name": "KontextMind",

package/plugins/kxm/dist/mcp-server.js

@@ -25462,7 +25462,7 @@ function sessionTokenFixHint(policy) {
 }
 
 // plugins/kxm/src/mcp-server.ts
-var VERSION = "0.7.188";
+var VERSION = "0.7.190";
 var CONFIGURE_PLUGIN = "/plugin configure kxm@kxm";
 var inbox = /* @__PURE__ */ new Map();
 var notifiedInbox = /* @__PURE__ */ new Set();

package/plugins/kxm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-plugin",
-  "version": "0.7.188",
+  "version": "0.7.190",
   "private": true,
   "type": "module",
   "engines": {

package/plugins/kxm/src/mcp-server.ts

@@ -11,7 +11,7 @@ import { deliverInboxNotification } from "./inbox.ts";
 import type { HubEvent, MessageRecord } from "./protocol.ts";
 import { sessionTokenFixHint } from "./session-token-hint.ts";
 
-const VERSION = "0.7.188";
+const VERSION = "0.7.190";
 const CONFIGURE_PLUGIN = "/plugin configure kxm@kxm";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();

package/scripts/check-plan-links.d.mts

@@ -0,0 +1,4 @@
+export function githubSlug(value: string): string;
+export function headingIds(markdown: string): Set<string>;
+export function checkFile(file: string): string[];
+export function checkPlans(root?: string): string[];