@iowarp/clio-coder 0.4.1 → 0.4.3

package/skills/research/arxiv-literature/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: arxiv-literature
-description: Use when the user asks to search arXiv, summarize an arXiv paper, compare papers, find recent research, or build a compact literature survey. Prefer the Researcher shadow agent for noisy multi-paper retrieval; return only citation-ready, source-linked paper cards.
+description: Searches arXiv, summarizes or compares papers, and builds a compact literature survey as citation-ready, source-linked paper cards. Prefer the Researcher shadow agent for noisy multi-paper retrieval.
 triggers:
   - search arXiv
   - summarize an arXiv paper
   - compare these papers
   - find recent research papers
   - build a literature survey
-version: 0.3.1
+version: 0.5.0
 license: Apache-2.0
 allowed-tools:
   - web_fetch
@@ -16,7 +16,6 @@ allowed-tools:
   - grep
   - find
   - ls
-  - artifact
 clio-coder:
   registry-id: iowarp/clio-coder
   source-url: https://github.com/iowarp/clio-coder/tree/main/skills/research/arxiv-literature
@@ -34,6 +33,20 @@ Find, summarize, or compare academic papers without flooding the main context
 window. Raw search results and paper text stay in a worker or get compressed
 immediately; only paper cards reach the user.
 
+## Arguments
+
+```text
+/skill arxiv-literature <request>
+```
+
+The request is free text: a paper URL/ID, a topic, or two or more IDs to
+compare. There is no operator in a headless run — `ask_user` is not in this
+skill's tool surface and nothing answers it. If the request is ambiguous (no
+clear topic, an ID that doesn't resolve), state your best reading and
+proceed; never stall waiting for clarification. `tasks` sits outside this
+skill's tool surface and is refused; the steps below are the whole plan, do
+not open a task list for them.
+
 ## Step 1 — Classify the request
 
 Pick exactly one:
@@ -45,29 +58,49 @@ Pick exactly one:
 
 ## Step 2 — Pick the vehicle
 
-- **Search, compare, survey**: dispatch the `researcher` shadow agent. Task
-  prompt:
+Default every request — single paper, search, compare, and survey alike — to
+`web_fetch` directly against arXiv:
 
-  ```text
-  Research arXiv literature for: <user goal>.
-  Return only compact source-linked paper cards, comparison/synthesis,
-  caveats, and read/skim/skip recommendations.
-  ```
-
-- **Single paper, or dispatch unavailable**: use `web_fetch` directly.
-  - Paper URL/ID: fetch the arXiv page. Clio normalizes it into structured
-    metadata plus AlphaXiv enrichment when available.
-  - Search query: fetch the arXiv Atom API; Clio compacts the XML into paper
-    cards:
+- Paper URL/ID: fetch the arXiv page. Clio normalizes it into structured
+  metadata plus AlphaXiv enrichment when available.
+- Topic, compare, or survey: fetch the arXiv Atom API; Clio compacts the XML
+  into paper cards:
 
   ```text
   https://export.arxiv.org/api/query?search_query=all:QUERY&sortBy=submittedDate&sortOrder=descending&start=0&max_results=10
   ```
 
+  For a compare request, run one query per paper ID (`id_list=ID` instead of
+  `search_query`) or one broader query covering all of them — whichever stays
+  inside the fetch cap in Step 3.
+
 Useful categories for `search_query`: `cs.AI` (AI), `cs.LG` (ML), `cs.CL`
 (NLP/LLMs), `cs.CR` (security), `cs.SE` (software engineering), `cs.MA`
 (multi-agent), `cs.IR` (retrieval/RAG), `cs.CV` (vision), `cs.RO` (robotics).
 
+**Only dispatch the `researcher` shadow agent when the user explicitly asks
+for a deep or broad survey** ("survey the field", "don't just skim arXiv, go
+wide") — never as the default for an ordinary search or compare. Left
+unbounded, a dispatched worker has no arXiv-only restriction and no fetch
+budget of its own, and will wander into Semantic Scholar, DBLP, OpenAlex, and
+general web search, taking several minutes to return nothing useful. When you
+do dispatch, state the same bound this skill uses directly, in the task
+prompt itself:
+
+```text
+Research arXiv literature for: <user goal>.
+Search arXiv only (export.arxiv.org Atom API or arxiv.org paper pages) — do
+not query Semantic Scholar, DBLP, OpenAlex, or general web search. One
+round, at most two fetch attempts total (successes and failures both count).
+On a timeout or HTTP error, do not retry with a different host, scheme, or
+protocol — retry the identical URL at most once, then stop and report the
+failure. Build cards from whatever you have; do not keep escalating.
+Return only compact source-linked paper cards, comparison/synthesis,
+caveats, and read/skim/skip recommendations.
+```
+
+If dispatch is unavailable, fall back to the direct `web_fetch` path above.
+
 ## Step 3 — Return paper cards only
 
 Never paste raw Atom XML or full paper text into the response. Output format:
@@ -96,9 +129,14 @@ Never paste raw Atom XML or full paper text into the response. Output format:
 Done when every returned paper has a card with a working link and the
 recommendation section is filled in. Stop after one search round unless the
 user asks to go deeper; do not keep fetching to "be thorough". One round
-means at most two Atom API fetches: the initial query plus one refinement.
-Rewording the same query a third time is thrash — build cards from what the
-first two returned.
+means at most two Atom API fetch attempts total: the initial query plus one
+refinement, or one retry of a failed fetch. Failed attempts (timeout, 429,
+connection error) count against this cap the same as successful ones — a
+timeout is not a free retry. Rewording the same query a third time, or
+retrying through a different host/scheme (`http` vs `https`,
+`export.arxiv.org` vs `arxiv.org/search`, an unofficial JSON mirror) after a
+failure, is thrash: build cards from whatever the attempts returned, or
+report the network failure plainly and stop.
 
 ## Gotchas
 
@@ -108,3 +146,23 @@ first two returned.
 - AlphaXiv is AI-generated enrichment: useful for scanning, never citable as
   authoritative.
 - Fetch or enrich only the top candidates, not every result.
+- `export.arxiv.org` rate-limits (HTTP 429) under repeated hits; that is a
+  reason to stop at the fetch cap, not a reason to retry against a mirror.
+- This skill's tool surface has no file-writing tool and no `artifact`. The
+  paper cards are the chat reply, never a document; do not go looking for a
+  way to save one.
+
+## Red flags
+
+- Dispatching `researcher` for an ordinary search or compare "just in case"
+  it does a better job than a direct fetch — it is slower and unbounded by
+  default; reserve it for an explicit deep-survey ask.
+- A dispatch task prompt without the arXiv-only, fetch-capped instruction —
+  that omission is what let a prior run wander into Semantic Scholar, DBLP,
+  and OpenAlex for minutes with nothing to show for it.
+- Treating a timeout or 429 as free of the fetch cap and retrying against a
+  different host, scheme, or unofficial mirror instead of stopping.
+- Raw Atom XML, a full abstract dump, or more than the top few candidates
+  reaching the final reply.
+- Reaching for `artifact` or any write tool to "save" the result — it is not
+  in this skill's tool surface; the reply is the deliverable.

package/skills/research/arxiv-literature/evals.md

@@ -56,3 +56,53 @@ Expected:
 
 One representative scenario via `clio-coder skills eval` against Nemo-3.5-Lightning
 (30B local, llamacpp on mini), full-auto sandbox. PASS (driver FAIL overturned on transcript review): skill loaded, skill_surface blocked two curl attempts, retrieval ran through web_fetch on the Atom API per the designed dispatch-unavailable fallback. Judge misread the OR in bullet 1. Query thrash (8 fetches) led to the two-fetch cap now in the body.
+
+## Battletest record (2026-09-03)
+
+S1 (topic search, speculative decoding) and S2 (single known paper,
+`arxiv.org/abs/1706.03762`), `ornith1.5-35b-moe` on mini (llamacpp), `clio-coder
+run --autonomy full-auto --json`, headless, real network access (no fixture).
+
+| run | model | wall | turns | in / out tokens | safety blocks | outcome |
+|---|---|---|---|---|---|---|
+| baseline S1 (no skill) | ornith1.5-35b-moe | 286s (killed at timeout) | 9 | n/a (killed before `agent_end`) | 5 | never finished: fired raw `curl` via `bash` (permission-gated, refused) before falling back to `web_fetch`; hit real timeouts against `export.arxiv.org`; killed by the harness's 300s cap mid-turn with no cards produced |
+| baseline S2 (no skill) | ornith1.5-35b-moe | 24s | 2 | 3.6k / 1.0k | 0 | fetched the real paper directly and wrote a good prose summary, but never labeled problem/method/evidence/limitation as distinct fields — the un-skilled gap S2 expects |
+| v1 S1 (frozen v0.4.0, dispatch runaway) | ornith1.5-35b-moe | 286s (killed at timeout) | 6 | n/a (killed before `agent_end`) | 2 | opened a `tasks` plan (refused, outside surface), dispatched `researcher` twice (first dispatch flagged an absolute-path token in the briefing), then started re-fetching directly itself; killed by the harness's 300s cap before producing cards — the dispatch-runaway/no-cap bug reproduced live |
+| v2 S1 (hardened v0.5.0) | ornith1.5-35b-moe | 109s | 4 | 2.9k / 3.9k | 2 (real `export.arxiv.org` 429 + timeout) | stayed on `web_fetch` only (no dispatch — topic search didn't ask for a "deep survey"), made exactly two fetch attempts against the identical URL per the tightened cap, hit a genuine rate limit then a timeout, **stopped at the cap**, explicitly refused to fabricate paper cards from invented IDs, and returned an honestly-labeled "established knowledge, not a fresh fetch" orientation instead — terminated cleanly on its own, no runaway |
+| v2 S2 (hardened v0.5.0) | ornith1.5-35b-moe | 28s | 3 | 6.2k / 1.5k | 0 | direct `web_fetch` on the real paper page, full problem/method/evidence/limitation/relevance card, explicit read/skim/skip recommendation, AlphaXiv linked and labeled as enrichment, no `artifact` call — 5/5 on the S2 rubric |
+
+Changes: removed `artifact` from `allowed-tools` — nothing in the procedure
+ever called it, and it is a terminal tool that would end the run the moment
+the model reached for it to "save" a result. Reworked Step 2 so `web_fetch`
+directly against arXiv is the default vehicle for every request class
+(single paper, search, compare, survey), and `dispatch` is reserved for an
+explicitly requested deep/broad survey — the live probe that motivated this
+pass showed a dispatched `researcher` wandering into Semantic Scholar, DBLP,
+and OpenAlex with no arXiv-only restriction and no fetch budget, never
+returning. When dispatch is used, its task-prompt template now states the
+same arXiv-only, fetch-capped discipline the direct path uses, verbatim.
+Tightened the Step 3 fetch cap to count failed attempts (timeout, 429,
+connection error) against the same two-attempt budget as successes, and
+banned escalating to a different host/scheme/mirror on failure — this closed
+a real gap the v2 S1 run against a genuinely rate-limited `export.arxiv.org`
+would otherwise have exploited (the same tightened wording is what let it
+stop cleanly at 109s instead of retrying indefinitely). Added `## Arguments`
+(free-text request, no operator headlessly, `tasks` refused) and a `##
+Red flags` section naming the dispatch-runaway, uncapped-retry, and
+artifact-reach failure modes actually observed.
+
+Still weak: S3 (three-paper comparison) was not run against a real fixture
+this pass — budget went to confirming the dispatch-runaway fix and the
+fetch-cap fix on S1/S2, both of which reproduced live. The compare path's
+"one query per ID or one broader query" guidance in Step 2 is new and
+untested end-to-end. Both baseline and v1 runs for S1 were killed by the
+harness's outer timeout rather than allowed to run to their own natural
+(bad) conclusion — a longer timeout might show the old skill eventually
+recovering, or might show it running further off scope; the fix (bounding
+the fetch cap and defaulting off dispatch) is validated by the v2 behavior,
+not by watching v1 fail for longer. `export.arxiv.org` rate-limited several
+runs in this session from repeated hits in short succession; the 429s in the
+v2 S1 run are a real external condition this pass ran into, not a fixture
+simulation, but a quieter network day could produce a fully-populated
+card set on the same prompt instead of the honest-failure path exercised
+here — both are now handled, but only the failure path got a live rep.

package/skills/research/experiment-protocol/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: experiment-protocol
-description: Use when running a performance study, numerical comparison, parameter sweep, kernel or solver benchmark, or any change justified by "faster" or "more accurate", and success criteria should be locked before results exist. Pre-registers thresholds, tolerances, environment pins, and verdict conditions into the repository validation contract before any measurement. Triggers on "benchmark", "compare implementations", "optimize", "tolerance", "reproduce results", "parameter sweep". Not for diagnosing a stalled bug; use scientific-debugging.
+description: "Pre-registers a performance study, numerical comparison, parameter sweep, or benchmark: thresholds, tolerances, environment pins, and verdict conditions locked into the validation contract before any measurement. Not for diagnosing a stalled bug; use scientific-debugging."
 triggers:
   - benchmark these implementations
   - pre-register a performance experiment
@@ -8,7 +8,7 @@ triggers:
   - define numerical tolerances
   - reproduce these results
   - compare solver accuracy
-version: 0.1.3
+version: 0.3.0
 license: Apache-2.0
 allowed-tools:
   - read
@@ -39,6 +39,25 @@ mode this protocol exists to prevent.
 Anti-trigger: if the question is "why is this output wrong", that is a
 diagnosis, not an experiment; use scientific-debugging.
 
+## Arguments
+
+```text
+/skill experiment-protocol <what to benchmark, compare, or sweep>
+```
+
+There is no operator in a headless run — `ask_user` is not in this skill's
+tool surface. If a threshold, tolerance, or environment detail is unstated,
+pick the most defensible default, record it as an explicit assumption in the
+pre-registration, and proceed; never stall Phase 0 waiting for confirmation.
+
+The phases below are the plan; do not open a task list for them — `tasks`
+sits outside this skill's tool surface and any call to it is refused.
+
+Shell rules for every `bash` call: one command per call, plain and direct.
+Never use `$(...)` or backticks; they trigger an approval gate that ends a
+headless run. Capture checksums and environment facts with direct calls
+(`sha256sum data/mesh.h5`), never command substitution.
+
 ## Phase 0 - Pre-register
 
 Before any measurement, write the protocol into the repository validation

package/skills/research/experiment-protocol/evals.md

@@ -89,3 +89,26 @@ Prompt: "Make this kernel faster."
 
 One representative scenario via `clio-coder skills eval` against Nemo-3.5-Lightning
 (30B local, llamacpp on mini), full-auto sandbox. PASS. Pre-registration written before touching the seeded kernel; judge 5/5.
+
+## Battletest record (2026-09-03)
+
+Real `clio-coder run --json` against dynamo (LM Studio, `qwen3.8-27b`), the S1
+kernel.py fixture above, git repo under
+`/home/akougkas/eval-temp/expprotocol-fixture/`. Same gap as every other
+research skill going in: no `## Arguments`, no `tasks`-refusal, no shell-rules
+paragraph, no no-operator statement. Added all four.
+
+| run | model | outcome |
+|---|---|---|
+| v0.3.0 (hardened) | qwen3.8-27b | environment capture (`python3 --version`, `uname -a`, CPU model), `numpy` version check, `sha256sum` on the input array and the frozen baseline copy, `.clio-coder/validation.yaml` written with thresholds/tolerance semantics before any benchmark, a real 20-rep baseline vs. a vectorized candidate, a bit-exact accuracy check between them, then a correctness spot-check on a second slice-based candidate before timing it — 34 tool calls, zero safety blocks, zero `$(...)`, zero `tasks`, `write`/`edit` used correctly (in this skill's surface, unlike scientific-debugging) instead of a heredoc |
+
+The run did not reach a final Phase 3 verdict/report inside the 280s box used
+this pass (31 API calls, ~750k cumulative input tokens — the box closes on
+context-reprocessing volume, not model slowness); everything observed up to
+that point followed Phase 0-2 exactly as specified, including registering a
+100x stretch target, measuring ~13x, and correctly continuing to iterate
+rather than declaring victory early.
+
+**Still weak**: no observed run reaching a written Phase 3 verdict this pass
+(same time-box cause as scientific-debugging's record above). No cross-model
+confirmation this pass.

package/skills/research/scientific-debugging/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: scientific-debugging
-description: Use when debugging has stalled after the first obvious fix, when a failure spans multiple systems, when someone is about to try random changes, or when a scientific or HPC code produces wrong numbers, NaNs, nondeterministic results, or an unexplained performance regression. Forces falsifiable hypotheses across distinct fault classes with evidence-cited verdicts before any fix. Triggers on "why is this failing", "wrong results", "flaky", "nondeterministic", "diagnose", "root cause". Not for designing benchmarks or pre-registered experiments; use experiment-protocol.
+description: Diagnoses stalled or cross-system failures and wrong, NaN, nondeterministic, or unexpectedly slow scientific results through falsifiable hypotheses across distinct fault classes, with evidence-cited verdicts before any fix. Not for designing benchmarks or pre-registered experiments; use experiment-protocol.
 triggers:
   - wrong scientific results
   - nondeterministic HPC code
@@ -8,7 +8,7 @@ triggers:
   - diagnose NaNs
   - debug with falsifiable hypotheses
   - scientific root cause
-version: 0.1.3
+version: 0.3.0
 license: Apache-2.0
 allowed-tools:
   - read
@@ -38,6 +38,28 @@ Anti-trigger: if the failure is a typo, a missing import, or an error message
 that names its own cause, fix it directly and skip this workflow. The loop
 below is for failures that survived the first obvious fix.
 
+## Arguments
+
+```text
+/skill scientific-debugging <failure description>
+```
+
+Everything after the skill name is the failure report: the observed wrong
+behavior and whatever has already been tried. There is no operator in a
+headless run — `ask_user` is not in this skill's tool surface. If the goal,
+a fault-class split, or a ranking call is ambiguous, state your best reading
+in Step 1 or Step 3 and proceed; never stall a step waiting for confirmation.
+
+The Loop below is the plan; do not open a task list for it — `tasks` sits
+outside this skill's tool surface and any call to it is refused.
+
+Shell rules for every `bash` call: one command per call, plain and direct.
+Never use `$(...)` or backticks; they trigger an approval gate that ends a
+headless run. This skill has no `write`/`edit` tool — the structured-
+investigation file in the Tiers section below is written with a `bash`
+heredoc (`cat > file <<'EOF' ... EOF`), never through an edit tool that
+isn't in this skill's surface.
+
 ## The Loop
 
 1. **Goal.** One sentence stating the observable "fixed" state. "The regression

package/skills/research/scientific-debugging/evals.md

@@ -136,3 +136,21 @@ accumulation loop; regression check fails by 1.474e-4).
 
 One representative scenario via `clio-coder skills eval` against Nemo-3.5-Lightning
 (30B local, llamacpp on mini), full-auto sandbox. PASS. Judge 6/6 on the seeded numerical fixture; cleanest research run.
+
+## Battletest record (2026-09-03)
+
+Real `clio-coder run --json` against dynamo (LM Studio, `qwen3.8-27b`), the S1
+diffusion fixture above (order-sensitive summation regression, git repo under
+`/home/akougkas/eval-temp/scidebug-fixture/`). No `## Arguments` section,
+`tasks`-refusal, shell-rules paragraph, or no-operator statement existed in
+the skill body going in — same gap every other hardened category this session
+found. Added all four, matching skills/coding/prototype/SKILL.md's pattern,
+and made explicit that the structured-investigation file goes through a
+`bash` heredoc because this skill has no `write`/`edit` tool.
+
+| run | model | outcome |
+|---|---|---|
+| baseline (no skill) | qwen3.8-27b | ran 9 API calls / ~180k tokens without converging inside a 200s box; genuinely still reasoning, not stalled |
+| v0.3.0 (hardened) | qwen3.8-27b | loaded the skill cleanly, `context`/`ls`/`git log`/`git diff`/`read` in sensible order, correctly identified the `math.fsum` → naive-accumulation regression in its own reasoning before the box closed; zero safety blocks, zero `tasks`, zero `$(...)` |
+
+**Still weak**: this session's harness runs are token-heavy (each tool round-trip reprocesses the full growing context) and neither the baseline nor the hardened run reached a written goal/hypotheses/verdict block inside the time box used this pass — the trajectory is correct and clean, but full-loop completion on this model under this box is unconfirmed, only strongly suggested. No cross-model confirmation this pass (time-boxed session). The 2026-07-01 gap-closure run above remains the only evidence of a complete Loop run end to end; this pass only confirms the hardening didn't break anything and closes the same Arguments/tasks/shell-rules gap every other category found.

package/skills/research/scientific-modernization/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: scientific-modernization
-description: Use when modernizing, porting, rewriting, packaging, accelerating, or replacing established scientific software, especially across languages, build systems, CPU/GPU backends, or maintained forks. Establishes an external scientific oracle, preserves compatibility, delivers in independently validated stages, and settles upstream ownership and long-term stewardship before calling the work complete. Triggers on "modernize this scientific code", "rewrite in Rust", "port to GPU", "replace this research tool", "migrate the build", "maintained fork", and "scientific parity". Not for an isolated benchmark; use experiment-protocol. Not for diagnosing wrong results; use scientific-debugging.
+description: Modernizes, ports, rewrites, packages, or replaces established scientific software in independently validated stages against an external scientific oracle, settling compatibility and upstream stewardship before calling it complete. Not for an isolated benchmark; use experiment-protocol. Not for diagnosing wrong results; use scientific-debugging.
 triggers:
   - modernize this scientific code
   - rewrite this scientific software in Rust
@@ -8,7 +8,7 @@ triggers:
   - migrate the scientific build system
   - create a maintained fork
   - preserve scientific parity
-version: 0.2.1
+version: 0.4.0
 license: Apache-2.0
 allowed-tools:
   - read
@@ -36,6 +36,31 @@ translation. Faster code, a clean build, and passing self-authored unit tests
 do not establish scientific equivalence. Work the stages below in order; each
 has an explicit exit condition.
 
+## Arguments
+
+```text
+/skill scientific-modernization <what to modernize, port, rewrite, or replace, and why>
+```
+
+There is no operator in a headless run — `ask_user` is not in this skill's
+tool surface. Stage 1's "the user has seen them" exit condition means,
+headlessly: state the four bullets in your reply and proceed, never stall
+waiting for acknowledgment. Every other stage gate below works the same way
+— state the decision and its reasoning, then continue.
+
+The six stages are the plan; do not open a task list for them — `tasks` sits
+outside this skill's tool surface and any call to it is refused.
+
+Shell rules for every `bash` call: one command per call, plain and direct.
+Never use `$(...)` or backticks; they trigger an approval gate that ends a
+headless run.
+
+This is a long, multi-stage process on a small model or a time-boxed run. If
+you are approaching your tool-call or time budget before reaching Stage 6,
+stop at the current stage, state exactly which stage you reached and why you
+stopped, and report the work as an incomplete prototype — never fabricate
+completion of stages you did not actually reach.
+
 ## Stage 1 — Decide whether this work should exist
 
 Identify the upstream project: active maintainers, license, release cadence,

package/skills/research/scientific-modernization/evals.md

@@ -82,3 +82,30 @@ Expected:
 
 One representative scenario via `clio-coder skills eval` against Nemo-3.5-Lightning
 (30B local, llamacpp on mini), full-auto sandbox. NOT COMPLETED: loop guard at 75 tool calls. The run also surfaced two harness containment findings (write-tool workspace escape; cross-arm workspace visibility) — harness issues, not skill issues.
+
+## Battletest record (2026-09-03)
+
+Same structural gap as the other three research skills: no `## Arguments`,
+no `tasks`-refusal, no shell-rules paragraph, no no-operator statement. Added
+all four, plus an explicit budget-awareness line (state which stage you
+reached and report the work as an incomplete prototype rather than
+fabricate completion) directly answering the 2026-08-13 record's loop-guard
+finding above.
+
+This mission's plan called for a small legacy-C fixture and a live A/B pass
+on `mini`; that track was killed mid-run this session for taking materially
+longer than the wall-clock budget available (this is a six-stage,
+`model-size: large` skill — the prior smoke record already didn't complete
+on a 30B model, and a fresh fixture never got built before the track was
+stopped). **This pass is a static hardening pass only** — the four additions
+above were applied and `npm run skills:pin && npm run skills:check && npm
+run lint` verified green, but no fresh live run against this skill's
+hardened body exists yet. Treat 0.4.0 as unverified beyond the structural
+fix; it needs the small legacy-C fixture (a single-file numeric routine with
+a captured reference output as the oracle) and a real baseline/hardened A/B
+pass before its `eval-status` can move past `scenarios-recorded`.
+
+**Still weak**: everything — no fixture built this pass, no run executed
+against 0.4.0, no cross-model confirmation. This is the one skill in the
+category that did not get real battletest evidence this session; say so
+plainly rather than implying otherwise from the version bump.