opencode-codeops 2.5.0 → 2.6.0

package/skills/organize-tests/references/language-adapters.md

@@ -0,0 +1,54 @@
+# Language Adapter Recipes
+
+> **CodeOps Artifact Schema**: 1
+
+The selector core is language-neutral. Each adapter is only a discovery method
+and an argv command stored in the map. Never add a language branch to the core.
+
+| Ecosystem | Natural unit | Discovery | Subset command |
+| --- | --- | --- | --- |
+| Node `node --test` | test file | file globs | `node --test {tests}` |
+| Vitest | test file | config/project | `npx vitest run {tests}` |
+| Jest | test file | config | `npx jest --runTestsByPath {tests}` |
+| Rust | crate or target | `cargo metadata` | `cargo test -p <crate> --lib --tests` |
+| Python | file or node ID | `pytest --collect-only` | `python3 -m pytest {tests}` |
+| Go | package | `go list ./...` | `go test ./pkg/...` |
+| JVM | class or package | Gradle/Maven tasks | `./gradlew test --tests com.example.core.*` |
+| .NET | project or class | `dotnet test --list-tests` | `dotnet test --filter FullyQualifiedName~Core` |
+| C/C++ | binary or target | `ctest -N`, Bazel query | `ctest -R ^core_`, Bazel target |
+| Ruby | file | runner config | `rspec {files}` |
+| PHP | file | runner config | `phpunit {files}` |
+| Custom | project unit | project command | project argv |
+
+## Target-based groups
+
+Rust unit tests are inline in source, Go tests are package-level, and C/C++
+tests are binary/target-level. These runners discover their own unit, so a
+target-based group may omit `tests`. Ownership is then validated through
+`sources` plus a smoke run of the command; the group is exempt from file-glob
+ownership checks.
+
+A target-based command must still prove a nonzero test count. The preview records
+that count.
+
+## File-based groups
+
+Node, Vitest, Jest, Python, Ruby, and PHP groups use `tests` globs. `{tests}`
+expands to every file the group owns, independent of the change set. A
+source-only change therefore still runs the group's whole test set.
+
+## Custom adapter
+
+Use `--custom` when no recipe fits. Ask for both commands:
+
+- the full verify command;
+- the subset command, as argv tokens, with `{tests}` where file paths belong.
+
+Run the subset once and record the count. If the command cannot run a subset,
+keep the project on the full gate; do not invent a selector.
+
+## Cross-language projects
+
+Use one fragment per ecosystem and a shared `policy.json`. The full command may
+be a single umbrella script or an array of argv commands. Never let one
+ecosystem's group command run another ecosystem's suite.

package/skills/organize-tests/references/map-health.md

@@ -0,0 +1,47 @@
+# Map Health and Audit
+
+> **CodeOps Artifact Schema**: 1
+
+A map can be valid JSON and still be unhealthy. The audit looks for drift and
+ownership defects that make selection quietly less useful.
+
+## Checks
+
+| Finding | Meaning | Action |
+| --- | --- | --- |
+| `map.orphan-test` | A test under a test root belongs to no group | Add it to an owning group, or record an explicit ignore/acceptance decision; the skill never deletes a test |
+| `map.overlap` | A test belongs to more than one group | Give it exactly one owner |
+| `map.unknown-source` | A source path is owned, full-on, or ignored by nothing | Add ownership, a full-on rule, or a documented ignore |
+| `map.slice-no-task` | A slice has no fast task tier | Add a task group or split the slice |
+| `map.slice-no-release` | A slice has no release/acceptance path | Add a release group or a per-slice acceptance record |
+| `map.group.slow` | A task group estimates above 180 s | Split it or move slow tests to a higher tier |
+| `map.empty-group` | A file-based group matches no tracked test | Fix the glob or remove the group |
+| never selected | A group has never run in recorded evidence | Check its sources and dependency edges |
+| flaky candidate | A group fails intermittently | Stabilize the test; do not hide it in a higher tier |
+
+A file is a test candidate when a group's `tests` glob claims it or its name follows a
+test convention (`.test.`, `.spec.`, `_test.`, `test_*`, `*Test`, or a `.rs` file under a
+test root). Fixtures and helpers under a test root are not orphan tests.
+
+## Strict mode
+
+`check --strict` promotes drift warnings to errors and exits 4. Malformed map
+rules still exit 3. Release and acceptance CI runs strict mode so a stale map
+cannot silently widen selection.
+
+## Refresh
+
+`--refresh` may update globs, dependency edges, and timings. It preserves manual
+group edits, owner fields, and acceptance records. It never renames an ID; a
+renamed group is a new group with a new owner decision.
+
+## Slow groups
+
+A slow task tier is a design smell, not a selector failure. Split the slice or
+move the slow test to `phase` or `release`. Never drop the test from the map to
+make the budget green.
+
+## Reporting
+
+Every audit finding names the path or group ID and the rule code. The report is
+read-only; the user decides whether to refresh, split, or accept the finding.

package/skills/organize-tests/references/project-wrapper.md

@@ -0,0 +1,72 @@
+# Project Wrapper Guidance
+
+> **CodeOps Artifact Schema**: 1
+
+A wrapper is optional. It gives a project short npm scripts without copying
+selector logic. The wrapper is a thin adapter over the plugin CLI.
+
+## Rules
+
+- No selection logic in the wrapper.
+- No language detection, glob parsing, or command rewriting.
+- Forward every argument unchanged.
+- Resolve the project root and map path once, then call the CLI.
+- Keep the file small enough to review in one screen.
+
+## Example
+
+`scripts/codeops-test.mjs`:
+
+```js
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process"
+import { fileURLToPath } from "node:url"
+import { dirname, join } from "node:path"
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..")
+const cli = process.env.CODEOPS_TEST_CLI ?? "codeops-test"
+const result = spawnSync(cli, process.argv.slice(2), {
+  cwd: root,
+  stdio: "inherit",
+  shell: false,
+})
+process.exitCode = result.status ?? 1
+```
+
+Package scripts:
+
+```json
+{
+  "scripts": {
+    "verify:task": "node scripts/codeops-test.mjs run --gate task",
+    "verify:phase": "node scripts/codeops-test.mjs run --gate phase",
+    "test:map:check": "node scripts/codeops-test.mjs check --strict"
+  }
+}
+```
+
+The full verify command stays the project's existing command:
+
+```json
+{
+  "scripts": {
+    "verify": "npm run typecheck && npm run test"
+  }
+}
+```
+
+## When not to use a wrapper
+
+A project may call `node bin/codeops-test.mjs` or the installed `codeops-test`
+binary directly. The AGENTS testing block names whichever command is real. Never
+invent a script name that does not exist.
+
+## Verification
+
+After adding a wrapper, run:
+
+1. `npm run test:map:check` — the map is valid.
+2. `npm run verify:task` with one real change — a nonzero selected set runs.
+3. `npm run verify` — the full gate still passes.
+
+Record the observed counts in the adoption evidence.

package/skills/organize-tests/references/shadow-mode.md

@@ -0,0 +1,60 @@
+# Shadow Adoption
+
+> **CodeOps Artifact Schema**: 1
+
+Shadow mode proves that a proposed map selects every test the full suite would
+fail. It is evidence, not a switch. Adoption requires zero missed failures; never enable the map from a single run.
+
+## Procedure
+
+1. Compute the selected set for the current diff with an explicit baseline.
+2. Run the selected groups with `--no-fail-fast`; capture every result.
+3. Run the full command regardless of the selected result.
+4. Compare the two results.
+5. Write the evidence record and report the verdict.
+6. Never enable the map automatically; a user or the skill decides after
+   reviewing the evidence.
+
+## Verdicts
+
+| Selected | Full | Verdict | Action |
+| --- | --- | --- | --- |
+| pass | pass | `zero-missed` | Candidate for adoption after review |
+| pass | fail | `escaped` | Refuse adoption; name the escaped failure |
+| fail | pass | `selected-failure` | Refuse adoption; fix selection or flake |
+| fail | fail | `both-failed` | No adoption signal; report both tails |
+
+The skill must refuse adoption on an escaped verdict. An `escaped` verdict is the dangerous case: the selected slice was green while
+the full suite was red. The report must name the escaping group and include the
+full failure tail. Do not explain it away as flaky without evidence.
+
+## Evidence shape
+
+```json
+{
+  "verdict": "zero-missed",
+  "gate": "pr",
+  "changed": ["src/a/dialog.ts"],
+  "mapHash": "<sha256>",
+  "selected": ["a.unit"],
+  "selectedResult": "passed",
+  "fullResult": "passed",
+  "escaped": [],
+  "enabled": false
+}
+```
+
+The record contains no test output, secrets, or environment values. Failure
+tails may appear in the human report but not in a committed map.
+
+## Repetition
+
+Run shadow mode on several real change sets, including:
+
+- a single-slice change;
+- a shared-contract change;
+- a change that should force full;
+- a docs-only change.
+
+A single green shadow run is not enough to prove a selector. Adopt only after
+the project has seen zero missed failures across representative changes.

package/standards/coding-standards-full.md

@@ -71,6 +71,34 @@ These apply to all code I write unless this project's `AGENTS.md` overrides a sp
 
 # Testing standards
 
+## Prime directives for verification
+
+1. **Test-first is unchanged.** Specification tests are written before implementation and run
+   red, then green. Selection never changes this.
+2. **The inner loop runs the smallest safe verification slice.** With a valid map, a task runs the
+   selected feature-slice `task` groups plus fast static checks. Without a map, a plan's
+   `**Task verify**` command may provide the same scoped behavior; otherwise the full verify runs
+   as today.
+3. **The outer gate is always full.** The full verify runs at phase/plan completion, before
+   push/release, at acceptance, and in CI. A green slice is not a release signal.
+4. **Selection fails closed.** Unknown paths, shared infrastructure, manifests/lockfiles,
+   test-runner/config changes, CI changes, stale/invalid maps, and selector errors select the
+   full suite. No silent skips.
+5. **Spec tests are never skipped.** The feature's spec test file always runs, even if the map
+   would not select its group. The executor passes the plan's declared spec file(s) with
+   `--include`; the selector adds the owning group, or falls back to full if the spec file is
+   unowned.
+6. **Evidence is explicit.** Verification names the groups or scoped command used, what was
+   deferred, and the baseline. CI remains authoritative.
+
+**Conditional wording.** Run the project's full verify command before completing any task or
+committing, unless the project has a valid `codeops/test-map.json` or `codeops/test-map/`
+directory, or the plan records a validated `**Task verify**` scoped command. With either opt-in,
+the task-level verify may run the selected test groups plus the project's fast static checks, or
+the plan-scoped command. The full verify still runs at phase/plan completion, before push/merge,
+at acceptance, and in CI. Any selection error, unknown path, shared change, or stale map falls
+back to the full verify. The canonical protocol is `_shared/test-selection.md`.
+
 - **Run the project's verify command (build + test) before completing any task or committing.** No code is "done" while any test fails.
 - **Targeted vs. full:** iterate with targeted tests, but run the **full** verify before declaring completion.
 - **Maximum, granular coverage:** happy path, edge/boundary cases, error/invalid inputs, and integration — each test focused on one thing with a clear failure message.

package/standards/coding-standards.md

@@ -30,6 +30,35 @@ Do not duplicate these standards in `~/.config/opencode/AGENTS.md` — the plugi
   containers.
 
 # Testing standards
+
+## Prime directives for verification
+
+1. **Test-first is unchanged.** Specification tests are written before implementation and run
+   red, then green. Selection never changes this.
+2. **The inner loop runs the smallest safe verification slice.** With a valid map, a task runs the
+   selected feature-slice `task` groups plus fast static checks. Without a map, a plan's
+   `**Task verify**` command may provide the same scoped behavior; otherwise the full verify runs
+   as today.
+3. **The outer gate is always full.** The full verify runs at phase/plan completion, before
+   push/release, at acceptance, and in CI. A green slice is not a release signal.
+4. **Selection fails closed.** Unknown paths, shared infrastructure, manifests/lockfiles,
+   test-runner/config changes, CI changes, stale/invalid maps, and selector errors select the
+   full suite. No silent skips.
+5. **Spec tests are never skipped.** The feature's spec test file always runs, even if the map
+   would not select its group. The executor passes the plan's declared spec file(s) with
+   `--include`; the selector adds the owning group, or falls back to full if the spec file is
+   unowned.
+6. **Evidence is explicit.** Verification names the groups or scoped command used, what was
+   deferred, and the baseline. CI remains authoritative.
+
+**Conditional wording.** Run the project's full verify command before completing any task or
+committing, unless the project has a valid `codeops/test-map.json` or `codeops/test-map/`
+directory, or the plan records a validated `**Task verify**` scoped command. With either opt-in,
+the task-level verify may run the selected groups or the scoped command; the full verify still
+runs at phase/plan completion, before push/merge, at acceptance, and in CI. Any selection error,
+unknown path, shared change, or stale map falls back to the full verify. The canonical detail is
+`_shared/test-selection.md`.
+
 - **Run the project's verify command before completing any task or committing**; full verify
   before declaring done. No code is "done" while any test fails.
 - Granular coverage (happy path, edges, errors, integration); E2E where feasible; real objects