@iowarp/clio-coder 0.4.6 → 0.4.8

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

@@ -0,0 +1,149 @@
+---
+name: scientific-debugging
+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
+  - unexplained performance regression
+  - diagnose NaNs
+  - debug with falsifiable hypotheses
+  - scientific root cause
+version: 0.3.1
+license: Apache-2.0
+allowed-tools:
+  - read
+  - grep
+  - ls
+  - find
+  - git
+  - context
+  - code_nav
+  - bash
+clio-coder:
+  registry-id: iowarp/clio-coder
+  source-url: https://github.com/iowarp/clio-coder/tree/main/library/skills/research/scientific-debugging
+  audit: pass
+  provenance: designed
+  eval-status: smoke-checked
+  model-size: any
+---
+
+# Scientific Debugging
+
+Debug by falsification, not by trying fixes. A fix attempted before a confirmed
+diagnosis is an experiment run without a hypothesis; when it "works" you have
+learned nothing, and when it does not you have contaminated the evidence.
+
+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 registered, so any call is refused as an
+unregistered tool rather than answered. 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
+   test matches the reference output within the documented tolerance on two
+   consecutive runs" is a goal; "make it work" is not.
+2. **Hypothesize.** Write at least three hypotheses. Each must name its fault
+   class and carry a falsification test: "this is WRONG if <observation>".
+   A hypothesis you cannot state a falsification test for is a hunch; refine it
+   until it is testable.
+3. **Rank.** Order by test cost times prior likelihood. Run the cheapest
+   decisive test first, not the most interesting one.
+4. **Test.** One variable per test. Preserve the raw failing output somewhere
+   untouched before you change anything.
+5. **Verdict.** Record CONFIRMED, REFUTED, or INCONCLUSIVE per hypothesis, each
+   citing the command and output that decided it. A verdict without a citable
+   observation is a guess.
+6. **Iterate.** Refuted everything? Generate new hypotheses from what the tests
+   revealed. Confirmed one? Only now edit code.
+
+## Fault Classes
+
+Hypotheses must span at least two distinct classes. Anchoring on a single class
+is the failure mode this rule exists to break: the debugger who is sure it is
+"a race" stops seeing the stale module load in front of them.
+
+| Class | Typical suspects |
+|---|---|
+| numerics | accumulation order, mixed precision, tolerance misuse, fastmath |
+| data | format or layout drift, HDF5/NetCDF/Zarr metadata, units, corruption |
+| concurrency | races, MPI collective mismatch, nondeterministic reduction order |
+| environment | modules, compiler flags, library versions, scheduler context |
+| resources | memory pressure, filesystem quirks, quota, node differences |
+| regression | a recent change; bisect the history instead of staring at code |
+
+## Tiers
+
+**Quick diagnosis** (default): the loop above, state held in conversation,
+time-boxed at fifteen minutes of investigation. If the box expires without a
+CONFIRMED verdict, escalate. Say that you are escalating; do not silently keep
+poking.
+
+**Structured investigation**: write an investigation file (for example
+`INVESTIGATION.md` or `.clio-coder/investigation-<slug>.md` via bash heredoc since
+this skill does not edit code) containing the goal, baseline measurements of
+the failing behavior, and one experiment per hypothesis with its verdict
+condition committed *before* the experiment runs. Update verdicts as evidence
+arrives. The file is the state; the conversation is commentary.
+
+## Evidence Rule
+
+The fix commit should cite the confirming observation, e.g. "confirmed by:
+`OMP_NUM_THREADS=1` reproduces bitwise-identical results, run log above".
+High-rigor repos will demand validation evidence at completion anyway; produce
+it proactively rather than being re-prompted for it.
+
+## Worked Example
+
+Report: "after the refactor, results differ from reference by 1e-4."
+
+- Goal: `pytest tests/test_advection.py` passes against the pinned reference
+  within its stated rtol on a clean checkout plus the refactor commit.
+- H1 (regression): the refactor changed the loop order and with it the
+  floating-point accumulation order. WRONG if the pre-refactor commit shows the
+  same 1e-4 drift. Test: `git stash && pytest ...` (cost: 1 min).
+- H2 (numerics): the comparison uses an absolute tolerance where values near
+  zero need a relative one. WRONG if the drift is uniform across magnitudes.
+  Test: print elementwise error vs magnitude (cost: 5 min).
+- H3 (environment): a different BLAS or compiler flag set is active in the new
+  environment. WRONG if `pip freeze`/module list matches the reference
+  environment pin. Test: diff environments (cost: 2 min).
+- Order: H1, H3, H2. H1 verdict: REFUTED, pre-refactor commit is clean, output
+  cited. H3: REFUTED, environments identical. H2: CONFIRMED, error is constant
+  1e-4 at all magnitudes, so near-zero elements fail the absolute check.
+- Only now edit: fix the tolerance semantics, cite H2's observation in the
+  commit message.
+
+## Red Flags
+
+- Editing code before any hypothesis has a CONFIRMED verdict.
+- All hypotheses drawn from one fault class.
+- A test that changes two variables at once.
+- "It seems better now" presented as a verdict.
+- Retrying a flaky test until it passes instead of making it deterministic.
+- The fifteen-minute box expiring without an explicit escalation.
+- Feeling certain: when a hypothesis feels obviously true, state its
+  falsification test anyway before touching the code.

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

@@ -0,0 +1,156 @@
+# Evals - scientific-debugging
+
+Baseline scenarios (run a subagent WITHOUT the skill to capture the gap, then
+WITH the skill to confirm it closes). Rubric is pass/fail per bullet.
+
+## S1 - stalled numerical bug
+
+Setup: a small numerical project with a reference-comparison test. The
+workspace already contains the fixture; run `python -m unittest -q` for the
+reference check. Prompt: "after a refactor our results differ from the
+reference by about 1e-4 and the obvious fix did not help; diagnose it."
+
+Fixture:
+
+```bash
+mkdir -p tests
+cat > diffusion.py <<'PY'
+import math
+
+
+def weighted_mean(values, weights):
+    weighted = [value * weight for value, weight in zip(values, weights)]
+    return math.fsum(weighted) / math.fsum(weights)
+PY
+cat > tests/test_diffusion.py <<'PY'
+import math
+import unittest
+
+from diffusion import weighted_mean
+
+
+class DiffusionReferenceTest(unittest.TestCase):
+    def test_weighted_mean_matches_reference(self):
+        values = [1.0e16, 6.0e-4, -1.0e16, 1.0e-4, 2.0e-4, -3.0e-4]
+        weights = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+        expected = math.fsum(value * weight for value, weight in zip(values, weights)) / math.fsum(weights)
+        observed = weighted_mean(values, weights)
+        self.assertLess(abs(observed - expected), 1.0e-12)
+
+
+if __name__ == "__main__":
+    unittest.main()
+PY
+git init -q
+git config user.name "Clio Coder Eval"
+git config user.email "eval@clio-coder.local"
+git add diffusion.py tests/test_diffusion.py
+git commit -q -m "add stable weighted mean reference"
+cat > diffusion.py <<'PY'
+def weighted_mean(values, weights):
+    total = 0.0
+    for value, weight in zip(values, weights):
+        total += value * weight
+    return total / sum(weights)
+PY
+```
+
+Expected:
+
+- States a one-sentence goal naming the observable fixed state before
+  investigating.
+- Writes at least three hypotheses, each with an explicit "this is WRONG if"
+  falsification test.
+- Hypotheses span at least two distinct fault classes, including numerics and
+  regression.
+- Orders tests cheapest-first and runs one variable per test.
+- Records a CONFIRMED/REFUTED/INCONCLUSIVE verdict per hypothesis, each citing
+  a command and its output.
+- Edits no code before a hypothesis is CONFIRMED.
+
+## S2 - flaky parallel test
+
+Setup: a test suite where one MPI/threaded test fails intermittently. Prompt:
+"this test is flaky, sometimes it passes; figure out why."
+
+Expected:
+
+- Includes a concurrency-class hypothesis (race, collective mismatch, or
+  reduction order).
+- Attempts a deterministic reproduction (pin threads, fix seeds, force
+  ordering) rather than rerunning until green.
+- Preserves the raw failing output before changing anything.
+- Does not present a lucky pass as a verdict.
+
+## S3 - escalation to structured tier
+
+Setup: quick-tier investigation is not converging; all initial hypotheses come
+back REFUTED and fifteen minutes of investigation have elapsed.
+
+Expected:
+
+- Explicitly announces escalation to the structured tier instead of silently
+  continuing.
+- Writes an investigation file containing the goal, baseline measurements of
+  the failing behavior, and one experiment per hypothesis.
+- Each experiment's verdict condition is committed before the experiment runs.
+- New hypotheses are generated from what the refuted tests revealed.
+
+## S4 - anti-trigger: trivial failure
+
+Setup: the failure is an obvious typo or missing import whose error message
+names its own cause. Prompt: "why is this failing?"
+
+Expected:
+
+- Fixes it directly or says a quick fix is appropriate.
+- Does not run the hypothesis ceremony for a self-explanatory failure.
+
+## Baseline failure modes to watch for (RED)
+
+- Tries a fix immediately with no stated hypothesis.
+- Single hypothesis, no falsification test, anchored on one fault class.
+- Bundles the fix with the diagnosis in one edit.
+- Verdicts asserted from intuition with no cited observation.
+- Flaky test "resolved" by rerunning until it passes.
+- Investigation drifts past the time box with no escalation and no file.
+
+## Observed gap closure
+
+S1 run 2026-07-01, headless `clio-coder run` against a scratch git fixture (an
+order-sensitive summation whose refactor replaced `math.fsum` with a plain
+accumulation loop; regression check fails by 1.474e-4).
+
+- RED (no skill): the agent found the correct root cause but with no stated
+  goal, no enumerated hypotheses, no falsification tests, and no verdicts; it
+  read the diff, asserted the cause, and benchmarked alternative summations ad
+  hoc. On a harder bug that first guess would have been unfalsified anchoring.
+- GREEN (skill via `--skill` and `/skill <name>` invocation): one-sentence goal,
+  three hypotheses (numerics, data, environment; the refactor regression
+  folded into H1) each with a WRONG-if test, explicit cheapest-first ranking,
+  CONFIRMED/REFUTED verdicts citing command output, untested H3 marked N/A,
+  fix applied only after the CONFIRMED verdict, and a commit message citing
+  the confirming observation. All six S1 bullets pass.
+
+## Smoke record (2026-08-13)
+
+One representative scenario via `clio-coder eval skill` 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/library/skills/research/scientific-debugging/plugin.json

@@ -0,0 +1,23 @@
+{
+	"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+	"name": "scientific-debugging",
+	"version": "0.3.1",
+	"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.",
+	"license": "Apache-2.0",
+	"extensions": {
+		"ai.iowarp.clio": {
+			"manifestVersion": 1,
+			"kind": "skill",
+			"resources": {
+				"skills": "."
+			},
+			"components": [
+				{
+					"kind": "skill",
+					"id": "scientific-debugging",
+					"path": "SKILL.md"
+				}
+			]
+		}
+	}
+}

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

@@ -0,0 +1,170 @@
+---
+name: scientific-modernization
+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
+  - port this solver to GPU
+  - migrate the scientific build system
+  - create a maintained fork
+  - preserve scientific parity
+version: 0.4.1
+license: Apache-2.0
+allowed-tools:
+  - read
+  - write
+  - grep
+  - ls
+  - find
+  - git
+  - context
+  - code_nav
+  - bash
+clio-coder:
+  registry-id: iowarp/clio-coder
+  source-url: https://github.com/iowarp/clio-coder/tree/main/library/skills/research/scientific-modernization
+  audit: pass
+  provenance: designed
+  eval-status: scenarios-recorded
+  model-size: large
+---
+
+# Scientific Modernization
+
+Modernization preserves scientific behavior and stewardship; it is not source
+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 registered, so
+any call is refused as an unregistered tool rather than answered. 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,
+supported users, contribution path. Prefer improving the original project when
+coordination is viable.
+
+Record the decision in writing before any implementation:
+
+- path chosen: upstream contribution, maintained successor, or explicitly
+  scoped fork;
+- the accountable maintainer or organization by name;
+- the compatibility surface users already rely on;
+- release, deprecation, and migration intent.
+
+Do not start a rewrite whose only durable plan is "the community can maintain
+it later." Exit: the four bullets above are written down and the user has seen
+them.
+
+## Stage 2 — Establish an independent scientific oracle
+
+Write the acceptance contract in `.clio-coder/validation.yaml` (preferred) or
+`VALIDATION.md` before changing behavior. Pick at least one oracle that does
+not depend on the new implementation agreeing with itself:
+
+- exact outputs from a trusted reference implementation;
+- parity against the established tool over a representative corpus;
+- known statistical behavior with pre-registered bounds;
+- simulated data whose correct answer is fixed in advance;
+- conserved quantities, analytical solutions, or domain invariants.
+
+For every output, define: units, shapes, ordering, missing-value behavior,
+determinism, absolute and relative tolerances, allowed platform variation.
+Include adversarial and historically troublesome inputs.
+
+If no credible oracle exists, stop and report that limitation. Implementation
+velocity cannot repair an undefined truth condition. Keep performance
+acceptance separate: pre-register speed claims through `experiment-protocol`.
+Exit: the contract file exists and names its oracle(s).
+
+## Stage 3 — Freeze the compatibility envelope
+
+Inventory observable behavior before migrating anything:
+
+- CLI and API contracts, file formats, schemas, defaults, error behavior;
+- packaging, fresh-install, upgrade, and uninstall paths;
+- supported platforms, compilers, runtimes, accelerators, schedulers;
+- resource scaling, reproducibility controls, provenance;
+- undocumented conventions captured by downstream tests and real workflows.
+
+Capture reference outputs and install evidence from released artifacts, not
+only the source checkout: mature tools carry user trust and conventions a
+line-by-line translation misses. Exit: reference outputs and the envelope
+inventory are stored as artifacts.
+
+## Stage 4 — Deliver in independently valid stages
+
+Split the work into the smallest stages that can each be checked against the
+oracle. Every stage gets a before/after boundary, an acceptance command, a
+retained artifact, and a rollback point. Prefer vertical slices that produce a
+usable result over a big-bang rewrite.
+
+Per stage:
+
+1. Capture the reference result on the pinned corpus and environment.
+2. Make one bounded change.
+3. Run compatibility and scientific-oracle checks.
+4. Preserve raw outputs, discrepancies, and provenance.
+5. Resolve or explicitly classify every mismatch before expanding scope.
+
+An agent's confidence is not evidence. If a reviewer cannot reconstruct the
+comparison from retained artifacts, the stage is unverified; say so. Exit per
+stage: oracle checks pass or every mismatch is classified in writing.
+
+## Stage 5 — Budget explicitly for the last mile
+
+Initial implementation is faster than convergence. Reserve work for: edge
+cases, subtle numerical differences, nondeterminism, fresh environments,
+large inputs, interrupted runs, packaging metadata, documentation, user
+migration. Re-run the full oracle matrix after any optimization: correctness
+proven before an optimization is not inherited by the optimized code.
+
+Use `scientific-debugging` when a mismatch needs causal diagnosis. Never widen
+tolerances or drop inconvenient corpus entries to obtain parity.
+
+## Stage 6 — Ship only with evidence and stewardship
+
+A completion claim must include all of:
+
+- the oracle and compatibility matrix that passed, plus retained artifacts;
+- unresolved differences and their user-visible consequences;
+- fresh-install and documented-workflow results;
+- performance results, if claimed, under their registered protocol;
+- upstream status, or the named owner and maintenance plan;
+- migration, rollback, release, and deprecation instructions.
+
+If scientific validity or durable ownership is unresolved, report the work as
+a prototype. Do not call it a replacement, successor, or production release.
+
+## Red Flags
+
+- A rewrite begins before maintainers or downstream users are consulted.
+- Tests derived only from the new implementation.
+- "The outputs look close" replacing declared tolerance semantics.
+- Performance wins reported before scientific parity.
+- One final comparison substituting for staged validation.
+- A passing happy path hiding fresh-install, scale, or edge-case failures.
+- A fork shipping without an accountable owner and maintenance horizon.

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

@@ -0,0 +1,111 @@
+# Evals - scientific-modernization
+
+Baseline scenarios (run a subagent WITHOUT the skill to capture the gap, then
+WITH the skill to confirm it closes). Rubric is pass/fail per bullet.
+
+## S1 - rewrite an established genomics tool in Rust
+
+Setup: a maintained genomics parser has a large user base, a reference CLI,
+and representative public datasets. The new repository has no validation
+contract. Prompt: "Rewrite this parser in Rust and make it the new default."
+
+Expected:
+
+- Checks the upstream contribution path, maintainers, license, and downstream
+  compatibility obligations before choosing a fork or successor.
+- Writes an acceptance contract before implementation, using the released
+  parser and fixed datasets as an independent parity oracle.
+- Specifies file, API, CLI, error, ordering, missing-value, and numerical
+  compatibility rather than comparing only happy-path output.
+- Splits the migration into independently validated stages with retained raw
+  comparison artifacts and rollback points.
+- Calls the result a prototype unless ownership, release, migration, and
+  maintenance are settled.
+
+## S2 - port a numerical solver to GPU
+
+Setup: a CPU solver is trusted, but floating-point reduction order will change
+on the GPU. Prompt: "Port the solver to CUDA and prove it is correct and
+faster."
+
+Expected:
+
+- Uses the CPU implementation, analytical cases, conserved quantities, or
+  fixed simulated truth as an oracle independent of the CUDA code.
+- Defines units, shapes, absolute and relative tolerances, nondeterminism, and
+  platform variation before the first GPU result.
+- Separates correctness parity from a pre-registered performance experiment
+  and invokes experiment-protocol for the latter.
+- Revalidates the full oracle matrix after each optimization rather than
+  inheriting correctness from an earlier version.
+- Includes large inputs, fresh environments, failures, and numerical edge
+  cases in the last-mile plan.
+
+## S3 - modernize packaging in place
+
+Setup: a scientific Python package has a legacy build, multiple supported
+platforms, and an active upstream. Prompt: "Replace the packaging system and
+release it without changing scientific behavior."
+
+Expected:
+
+- Prefers an upstreamable bounded change over creating a replacement package.
+- Captures fresh-install, upgrade, uninstall, import, CLI, and documented
+  workflow behavior from released artifacts before editing the build.
+- Uses existing scientific outputs as a no-regression oracle even though the
+  requested change appears packaging-only.
+- Delivers the migration in reversible stages and records platform-specific
+  evidence.
+- Names release ownership, deprecation impact, and rollback instructions.
+
+## S4 - anti-triggers
+
+Setup: one request asks why a solver emits NaNs; another asks to benchmark two
+MPI collectives without migrating software.
+
+Expected:
+
+- Routes the NaN diagnosis to scientific-debugging.
+- Routes the isolated performance comparison to experiment-protocol.
+- Does not manufacture a modernization or stewardship project for either.
+
+## Baseline failure modes to watch for (RED)
+
+- Starts a big-bang rewrite immediately and treats self-authored tests as proof.
+- Declares parity from a few hand-picked examples with no tolerance semantics.
+- Mixes correctness and performance so a speedup excuses changed answers.
+- Discovers edge cases only in one final comparison after the rewrite.
+- Replaces an active project without early maintainer coordination.
+- Calls an unowned fork production-ready because installation succeeds.
+
+## Smoke record (2026-08-13)
+
+One representative scenario via `clio-coder eval skill` 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.

package/library/skills/research/scientific-modernization/plugin.json

@@ -0,0 +1,23 @@
+{
+	"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+	"name": "scientific-modernization",
+	"version": "0.4.1",
+	"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.",
+	"license": "Apache-2.0",
+	"extensions": {
+		"ai.iowarp.clio": {
+			"manifestVersion": 1,
+			"kind": "skill",
+			"resources": {
+				"skills": "."
+			},
+			"components": [
+				{
+					"kind": "skill",
+					"id": "scientific-modernization",
+					"path": "SKILL.md"
+				}
+			]
+		}
+	}
+}