@kontextmind/kxm 0.7.189 → 0.7.191

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.189",
+  "version": "0.7.191",
   "description": "KXM local-first multi-agent orchestration and operator dashboard",
   "type": "module",
   "author": "KontextMind",

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.189",
+  "version": "0.7.191",
   "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.189";
+var VERSION = "0.7.191";
 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.189",
+  "version": "0.7.191",
   "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.189";
+const VERSION = "0.7.191";
 const CONFIGURE_PLUGIN = "/plugin configure kxm@kxm";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();