@brainervirus/workit-core 2.7.0 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "private": false,
   "description": "Workit shared core — task, policy, evidence, review, decision, worker, and writer state for agentic coding workflows",
   "keywords": [

package/scripts/bundled-deps.json

@@ -12,6 +12,7 @@
   ],
   "workit-cli": [
     "@alcalzone/ansi-tokenize",
+    "@babel/parser",
     "@inkjs/ui",
     "@openclaw/fs-safe",
     "ansi-escapes",
@@ -87,6 +88,7 @@
   "workit-pi": ["@openclaw/fs-safe", "zod"],
   "workit-claude-code": [
     "@alcalzone/ansi-tokenize",
+    "@babel/parser",
     "@inkjs/ui",
     "@openclaw/fs-safe",
     "ansi-escapes",

package/skills/workit-bdd/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: workit-bdd
+description: Use when turning a requirement, issue or acceptance criterion into tests, or when tests should read as behavior (Given/When/Then, BDD, scenarios, acceptance tests, test names and seams)
+---
+
+# Behavior first: Given/When/Then
+
+Write each acceptance criterion as Given/When/Then before any code, then let
+it name the test and pick the seam. This skill shapes the scenarios; the
+RED/GREEN loop itself is workit-behavioral-tdd.
+
+## Method
+
+1. Write the scenarios. One behavior per scenario, in the user's or caller's
+   words: `Given <state>, When <action>, Then <observable result>`. Include the
+   unhappy paths a caller depends on (denied, empty, invalid, timeout).
+2. Agree the seams. Pick the highest stable interface the scenario can be
+   observed through: a CLI verb, a public function, an HTTP route. Ideally one
+   seam per feature. Write the seams down; do not test at an unagreed seam.
+3. Name the tests after the scenarios. The test name is the Given/When/Then
+   sentence; the body is arrange (Given), act (When), assert (Then). Expected
+   values come from the scenario (a literal from a worked example or the
+   spec), never from the code.
+4. Use Gherkin only where the repo already does (`.feature` files with
+   playwright-bdd, cucumber, jest-cucumber). Otherwise plain test names carry
+   the scenario; do not add a BDD framework.
+5. Build in vertical slices, one scenario at a time, with
+   workit-behavioral-tdd: run `workit check test` RED for the new scenario,
+   make the smallest change, run `workit check test` GREEN, then the next.
+6. Mock only at system boundaries: network, clock, randomness, other
+   processes, sometimes the filesystem. Never the unit or its internal
+   collaborators; use the real thing or an in-memory adapter behind a port.
+
+## Completion
+
+Every acceptance criterion maps to a named test at an agreed seam, each was
+seen RED then GREEN through `workit check test`, and the new tests have no
+tautologies:
+
+```sh
+workit test-audit --diff && workit check test
+```

package/skills/workit-behavioral-tdd/SKILL.md

@@ -39,6 +39,8 @@ Use this method when assessment selects the `testing` dimension.
   ghost loops (assert inside a possibly-empty loop), smoke-only renders,
   type-only or CSS-class coupling. If the test still passes when every
   imported function returns undefined, rewrite the assertion or delete it.
+  `workit test-audit --diff` flags these; triage them with workit-test-audit.
+  Turning acceptance criteria into scenarios and seams is workit-bdd.
 
 Run RED/GREEN through `workit check`, which records the observed result on the
 current task; shared `evidence` operations are for notes and non-test evidence.

package/skills/workit-test-audit/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: workit-test-audit
+description: Use when tests may be tautological, low-value or noisy, before trusting a green suite, when reviewing tests an agent wrote, or when asked to clean up, prune or strengthen tests
+---
+
+# Audit tests for tautologies
+
+A tautological test recomputes its expected value the way the code does, so it
+passes by construction and can never disagree with the code. Find those and
+other low-value tests and triage each one. The audit is advice: never delete
+or weaken a test to make it quiet.
+
+## Method
+
+1. Run the audit on the change (or the paths you were asked about):
+   `workit test-audit --diff --json` or `workit test-audit <paths> --json`.
+   Each finding has file:line, rule, severity, confidence, why and a fix.
+   Prose checks are `info`; add `--min-severity info` to see them.
+2. Triage every finding with "Name the Break": which wrong production change
+   should make this test fail? Then choose one, and say which:
+   - Replace: keep the behavior, fix the oracle. Assert the public result
+     against an independent expected value (a literal from a worked example,
+     the spec, an external contract). Plant the bug you named, watch the new
+     test fail, then revert the plant.
+   - Keep with a reason: the value is an external contract or the finding is
+     wrong. Mark it `// workit-test-audit-ignore <rule> -- <reason>`.
+   - Remove: only `assertion-free` or `duplicate-body` tests, and only after
+     checking that no other test loses unique behavior with it.
+3. Check the replacements catch real breaks: `workit test-audit --mutate --diff`
+   (pass `--test-cmd "<runner> {files}"` to run only the related tests). A
+   surviving mutant names a change no test notices; add the missing case.
+4. Leave untouched tests outside the diff alone; propose that cleanup as its
+   own change.
+
+## Completion
+
+Every finding is triaged (replaced with a test that failed on a planted bug,
+kept with an ignore comment and reason, or removed as above) and the configured
+tests are green:
+
+```sh
+workit check test
+```

package/src/core/methods.ts

@@ -171,7 +171,8 @@ target result; a local commit alone is not evidence of a requested remote push.
 Skill routing: slash aliases /wk-* load on demand. Use workit-steer for a
 substantial interruption or change of direction, workit-deslop when relevant
 to a PR-ready endpoint, workit-green-run for failing CI, workit-blast-radius
-when impact is uncertain, and workit-challenge for genuinely open consequential
-choices. Load workit-plan when dependencies or handoff need durable next actions.
+when impact is uncertain, workit-challenge for genuinely open consequential
+choices, workit-bdd to turn acceptance criteria into Given/When/Then tests, and
+workit-test-audit to check tests for tautologies. Load workit-plan when dependencies or handoff need durable next actions.
 Load the skill; never act from memory of it.
 `.trim();

package/src/core/skill-manifests.ts

@@ -16,6 +16,8 @@ export const WORKIT_METHOD_SKILLS = [
   "workit-mockup",
   "workit-green-run",
   "workit-steer",
+  "workit-bdd",
+  "workit-test-audit",
 ] as const;
 
 /** wk- slash aliases (one per skill): alias → method skill. An alias routes
@@ -35,6 +37,8 @@ export const WORKIT_SKILL_ALIASES = {
   "wk-mockup": "workit-mockup",
   "wk-green-run": "workit-green-run",
   "wk-steer": "workit-steer",
+  "wk-bdd": "workit-bdd",
+  "wk-test-audit": "workit-test-audit",
 } as const;
 
 export const skillManifestNames = (root: string): string[] =>