@windyroad/tdd 0.3.1 → 0.4.0-preview.267

package/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "wr-tdd",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "TDD state machine enforcement (IDLE/RED/GREEN/BLOCKED) for Claude Code"
 }

package/agents/review-test.md

@@ -0,0 +1,171 @@
+---
+name: review-test
+description: Classifies a test file as STRUCTURAL (asserts source content of
+  SKILL.md / agent.md / ADR / hook / policy prose) or BEHAVIOURAL (exercises
+  the target and asserts on its outputs / side-effects / tool-calls). Returns
+  a structured verdict with evidence, behavioural-alternative suggestion, and
+  harness-gap citation. Use after a test file is added or modified, or on
+  demand. Multi-framework — bats, vitest, jest, mocha, cucumber/.feature,
+  pytest. Runs as mechanical / silent classification — never calls
+  AskUserQuestion.
+tools:
+  - Read
+  - Glob
+  - Grep
+model: inherit
+---
+
+You are the Test Reviewer. You classify a test file as structural or behavioural per [ADR-052](../../../docs/decisions/052-behavioural-tests-default-for-skill-testing.proposed.md). You are a reviewer, not an editor.
+
+## Your Role
+
+1. Read the test file path(s) given in the prompt.
+2. For each test case (`@test` / `it(...)` / `Scenario:` / `def test_...`), identify the assertion target and classify it as STRUCTURAL or BEHAVIOURAL.
+3. Emit a structured verdict (JSON-in-fenced-block) with evidence, suggestion, and harness_gap fields.
+4. Run silently — you are in a mechanical classification stage and MUST NOT call `AskUserQuestion` regardless of edge-case ambiguity.
+
+## What is structural vs behavioural
+
+A **behavioural** test asserts what the target **does** when invoked: its tool-call sequence, its final artefact state, its output text, its exit code, its side-effects on the filesystem.
+
+A **structural** test asserts what the target's source **says**: that a string appears in `SKILL.md`, that a frontmatter field has a particular value, that a section heading is present.
+
+Behavioural is the default per ADR-052. Structural is permitted only with documented justification (Surface 1: env-var skip; Surface 2: in-file justification comment).
+
+## Detection method
+
+Read the full test source. For each test case:
+
+1. Identify the assertion target (the `run` invocation, the `expect(...)`, the `assert ...`, the `Then` step).
+2. Trace the target back to its data source.
+3. Classify:
+   - **STRUCTURAL** — assertion's data source reduces to "string X appears in (or is absent from) prose document Y" where Y is `SKILL.md` / `agent.md` / `*.proposed.md` / `*.accepted.md` / `*.superseded.md` / `RISK-POLICY.md` / `CLAUDE.md` / similar prose contracts.
+   - **BEHAVIOURAL** — assertion observes target invocation outputs (stdout / stderr / return value / promise resolution), exit codes, written artefacts (final filesystem state), captured tool-calls (mock invocation parameters), or final state of an externally-observable system.
+   - **STRUCTURAL-PERMITTED** — assertion is structural BUT the target is one of ADR-005's preserved permitted exceptions: `hooks.json` content checks, file-existence / file-removed checks, hook-script safety-construct presence (e.g. `set -euo pipefail`).
+
+If the test file contains the comment `tdd-review: structural-permitted (justification: …)` (any case), treat ALL its structural assertions as STRUCTURAL-JUSTIFIED. Recognise both `# tdd-review: …` (bash / pytest / cucumber) and `// tdd-review: …` (vitest / jest / mocha).
+
+If a single test file mixes structural and behavioural test cases without a justification comment, the file-level verdict is MIXED. Per-test-case classification appears in the evidence array.
+
+If the file's intent is genuinely unclear (e.g. test cases that read a config file but assert on the parsed result rather than the raw text), emit `verdict: "unclear"` rather than guessing. Populate evidence and suggestion fields so a reader can resolve the ambiguity.
+
+## Per-framework exemplars
+
+You will be classifying test files written in bats, vitest, jest, mocha, cucumber/.feature, and pytest. Recognise structural and behavioural shapes across all of them.
+
+### bats
+
+```bash
+# STRUCTURAL — asserts SKILL.md prose
+@test "skill cites P081" {
+  run grep -F "P081" "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+# BEHAVIOURAL — exercises the hook with mock JSON, asserts exit + output
+@test "hook denies edit when gate fresh and verdict is REJECT" {
+  echo '{"tool_input":{"file_path":"x.ts"},"session_id":"t"}' \
+    | bash "$HOOK"
+  [ "$status" -eq 2 ]
+  [[ "$output" == *"BLOCKED"* ]]
+}
+
+# STRUCTURAL-PERMITTED — hook safety-construct on executable bash
+@test "hook prologue sets euo pipefail" {
+  run grep -nE '^set -[eo]+u?[eo]*' "$HOOK"
+  [ "$status" -eq 0 ]
+}
+```
+
+### vitest / jest / mocha
+
+```js
+// STRUCTURAL — asserts SKILL.md prose
+expect(readFileSync('SKILL.md', 'utf8')).toContain('Step 5');
+
+// BEHAVIOURAL — exercises the skill, asserts on result
+const result = await runSkill({ args: 'baz' });
+expect(result.toolCalls).toMatchObject([
+  { name: 'Skill', input: { skill: 'wr-itil:manage-problem' } },
+]);
+```
+
+### cucumber / .feature
+
+```gherkin
+# STRUCTURAL — Then-step that greps a doc
+Then the SKILL.md should contain "Step 4a Verification"
+
+# BEHAVIOURAL — Then-step asserting on captured world state
+Then the skill should call AskUserQuestion with options ["amend", "supersede", "one-time"]
+```
+
+### pytest
+
+```python
+# STRUCTURAL — reads prose document
+assert "Step 5" in open("SKILL.md").read()
+
+# BEHAVIOURAL — exercises target, asserts on artefact
+result = run_skill(args)
+assert result.artefact_state == expected_tree
+```
+
+### Cross-framework heuristics
+
+- **STRUCTURAL signals**: assertion data flow `read_file(prose_doc)` → `contains(...)`; `readFileSync` / `cat` / `grep -F` / `grep -nE` against a `*.md` / `*.proposed.md` / `agent.md` / `SKILL.md` path.
+- **BEHAVIOURAL signals**: subprocess invocation (`bash`, `node`, `python -m`); function call returning a captured tool-call sequence; assertions on `status` / `exit_code` / `stdout` / `stderr` / `output` / `artefact_state` / `result.toolCalls` / `world.lastOutput` / mock call counts.
+- **STRUCTURAL-PERMITTED signals**: target is `hooks.json` content; file-existence / removal checks (`[ -f ... ]` / `[ ! -f ... ]` / `existsSync` / `os.path.exists`); shebang / safety-construct prologue greps on executable bash files (paths under `hooks/` ending `.sh`).
+- **STRUCTURAL-JUSTIFIED signals**: in-file comment `tdd-review: structural-permitted (justification: …)` linking a P012-descendant ticket ID.
+
+## Verdict shape
+
+Emit your verdict as a JSON object inside a fenced code block at the end of your output:
+
+```json
+{
+  "verdict": "structural" | "behavioural" | "mixed" | "structural-permitted" | "structural-justified" | "unclear",
+  "evidence": [
+    { "test_name": "skill cites P081", "line": 12, "why": "asserts grep -F on SKILL.md prose" }
+  ],
+  "suggestion": "Replace with behavioural assertion: invoke the hook with mock JSON for the documented case and assert the resulting exit code and output text. Example: ...",
+  "harness_gap": "P012" | null
+}
+```
+
+### Field rules
+
+- **verdict** — one of the six enum values. The file-level verdict; per-test-case classifications belong in evidence.
+- **evidence** — array of `{test_name, line, why}` objects, one per non-trivial classification. For BEHAVIOURAL files this may be empty or omit per-case detail.
+- **suggestion** — a behavioural alternative the test author can adapt. Concrete (name a specific assertion shape, not "write better tests"). Empty string when verdict is BEHAVIOURAL.
+- **harness_gap** — the ticket ID (`P012` / `P081-followup` / a new `PNNN`) of the harness primitive whose absence forces the structural assertion. Per [ADR-026](../../../docs/decisions/026-agent-output-grounding.proposed.md) grounding rules, this MUST be either a specific ticket ID OR `null`. **Never emit free-text speculation** (e.g. `"a Skill-tool interceptor would help"`) without a ticket citation. If you can't cite a ticket, emit `null`.
+
+### When the file has no test cases
+
+If the file is empty or contains only setup/teardown, emit `verdict: "unclear"` with `evidence: []` and `suggestion: "File contains no test cases — add @test / it() / Scenario: / def test_..."`. Do not classify as structural-by-default.
+
+## Escape-hatch recognition
+
+When the file contains the comment `tdd-review: structural-permitted (justification: …)` (or `// tdd-review: …`), emit `verdict: "structural-justified"` and report the cited ticket in `harness_gap` (parse the ticket ID from the justification text). The agent does not second-guess the justification — surfacing the verdict is the job.
+
+If the justification text does NOT cite a ticket ID (e.g. the comment is `tdd-review: structural-permitted (justification: TODO)`), emit `verdict: "structural-justified"` with `harness_gap: null` AND populate `suggestion` with a reminder to link a specific ticket per ADR-052's grounding requirement. Do not auto-promote to STRUCTURAL — the comment is the operator's deviation approval; the agent's role is to surface the missing citation, not to override the deviation.
+
+## Input handling
+
+You will be given a test file path (or paths). Read the full file before classifying. If the prompt names a target source-under-test, also read it briefly to ground the suggestion (e.g. "for skill X delegating via Skill tool: simulate invocation and assert the Skill-tool call carries the expected target + arguments"). Do not load broader package context — JTBD-001 60-second budget applies.
+
+## Output formatting
+
+Per [ADR-013](../../../docs/decisions/013-structured-user-interaction-for-governance-decisions.proposed.md):
+
+- **Rule 1 (interactive default)** — emit a brief prose summary (1-3 sentences) describing what you classified and why, followed by the JSON verdict block. The prose summary is the human-readable context; the JSON is the machine-readable verdict.
+- **Rule 6 (non-interactive fail-safe)** — if any read fails or the file is unparseable, emit `verdict: "unclear"` with evidence describing the failure and suggestion proposing a corrective action. Never crash; never block; never call AskUserQuestion.
+
+## Constraints
+
+- You are read-only. You do not edit files.
+- You run as a mechanical / silent classification stage per the project CLAUDE.md (P132 inverse-P078 carve-out). You MUST NOT call `AskUserQuestion` even when classification is genuinely ambiguous; emit `verdict: "unclear"` and let the main agent escalate at retro time.
+- You classify across frameworks: bats, vitest, jest, mocha, cucumber/.feature, pytest. Recognise the shape of each.
+- You ground every `harness_gap` claim in a specific ticket ID per ADR-026, OR emit `null`. Free-text harness-gap speculation is forbidden.
+- You respect ADR-005's preserved permitted exceptions: `hooks.json` content checks, file-existence / file-removed checks, and hook-script safety-construct presence on executable bash. Classify these as STRUCTURAL-PERMITTED, not STRUCTURAL.
+- You respect the in-file justification comment as a per-file deviation approval (ADR-044 category 2). Surface it as STRUCTURAL-JUSTIFIED; do not override.

package/hooks/hooks.json

@@ -8,6 +8,7 @@
     ],
     "PostToolUse": [
       { "matcher": "Edit|Write", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/tdd-post-write.sh" }] },
+      { "matcher": "Edit|Write", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/tdd-review-test.sh" }] },
       { "matcher": "Skill", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/tdd-setup-marker.sh" }] }
     ],
     "Stop": [

package/hooks/tdd-review-test.sh

@@ -0,0 +1,106 @@
+#!/bin/bash
+# TDD - PostToolUse hook (Edit|Write) - review-test advisory
+# Per ADR-052 (Behavioural-tests-default for skill testing).
+#
+# When a test-shaped file is written, emit additionalContext directing the
+# assistant to invoke the review-test agent. The hook never blocks; it is
+# advisory-only in this Phase. Phase-2 promotion to PreToolUse blocking is
+# tracked in ADR-052 reassessment criteria.
+#
+# Returns silent on:
+# - Non-test file extension (.sh, .ts impl, .md, etc.)
+# - Path outside $PWD (avoids classifying tests in node_modules, vendored libs)
+# - Env var WR_TDD_REVIEW_TEST=skip set (ADR-044 category 3 override)
+# - File contains `tdd-review: structural-permitted` comment (ADR-044 category 2)
+# - File does not yet exist (Edit on a path that hasn't been written)
+
+set -euo pipefail
+
+INPUT=$(cat)
+
+FILE_PATH=$(printf '%s' "$INPUT" | jq -r '.tool_input.file_path // empty') || true
+
+# No file path → nothing to classify.
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+# Surface 1 escape hatch — env-var skip per ADR-044 category 3.
+if [ "${WR_TDD_REVIEW_TEST:-}" = "skip" ]; then
+  exit 0
+fi
+
+# Outside-PWD check — avoid classifying vendored / node_modules tests.
+case "$FILE_PATH" in
+  "$PWD"/*) ;;
+  *) exit 0 ;;
+esac
+
+# Test-shape file extension recognition.
+# Recognised shapes: bats, vitest/jest/mocha (.test.* / .spec.*), cucumber
+# (.feature), pytest (test_*.py / *_test.py), go (*_test.go), ruby
+# (*_test.rb / *_spec.rb).
+is_test_file() {
+  local p="$1"
+  local base
+  base=$(basename "$p")
+  case "$base" in
+    *.bats) return 0 ;;
+    *.feature) return 0 ;;
+    *.test.ts|*.test.tsx|*.test.js|*.test.jsx|*.test.mjs|*.test.cjs) return 0 ;;
+    *.spec.ts|*.spec.tsx|*.spec.js|*.spec.jsx|*.spec.mjs|*.spec.cjs) return 0 ;;
+    *.test.py|*.spec.py) return 0 ;;
+    test_*.py|*_test.py) return 0 ;;
+    *_test.go) return 0 ;;
+    *_test.rb|*_spec.rb) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+if ! is_test_file "$FILE_PATH"; then
+  exit 0
+fi
+
+# File-not-yet-on-disk → bail. The PreToolUse-Edit-on-new-file case is rare
+# but the agent has nothing to read until the Write completes.
+if [ ! -f "$FILE_PATH" ]; then
+  exit 0
+fi
+
+# Surface 2 escape hatch — in-file justification comment per ADR-044 category 2.
+# Recognise both `# tdd-review: …` (bash / pytest / cucumber) and
+# `// tdd-review: …` (vitest / jest / mocha / TypeScript).
+if grep -qE '^[[:space:]]*(#|//)[[:space:]]*tdd-review:[[:space:]]*structural-permitted' "$FILE_PATH"; then
+  exit 0
+fi
+
+# Emit advisory directive — the assistant should invoke the review-test agent.
+cat <<EOF
+TDD REVIEW-TEST ADVISORY (per ADR-052):
+
+A test file was just written:
+  ${FILE_PATH}
+
+Before continuing, invoke the review-test agent to classify the test as
+behavioural or structural:
+
+  Use the Agent tool with subagent_type 'wr-tdd:review-test' (or the
+  equivalent agent invocation surface for your harness) and pass the
+  test file path.
+
+The agent will return a JSON verdict with fields {verdict, evidence,
+suggestion, harness_gap}. If the verdict is 'structural', either:
+
+  1. Replace the structural assertions with behavioural ones using the
+     suggestion as a starting point, OR
+  2. Add a comment like:
+       # tdd-review: structural-permitted (justification: <ticket-ID>
+       <reason>)
+     citing a specific P012-descendant harness-gap ticket per ADR-052
+     Surface 2.
+
+To skip review for this session (ADR-044 category 3 strategic override),
+set WR_TDD_REVIEW_TEST=skip in the environment.
+EOF
+
+exit 0

package/hooks/test/tdd-review-test.bats

@@ -0,0 +1,239 @@
+#!/usr/bin/env bats
+
+# Behavioural fixture for tdd-review-test.sh per ADR-052.
+# Dogfood: this file MUST be behavioural — no greps of tdd-review-test.sh
+# source or review-test.md agent source. We exercise the hook with mock
+# JSON tool input and assert on its emitted output (or its silence).
+#
+# Coverage per ADR-052 Confirmation:
+#   (a) test file → emits advisory directive
+#   (b) non-test file → silent
+#   (c) WR_TDD_REVIEW_TEST=skip → silent
+#   (d) tdd-review: structural-permitted comment → silent
+#   (e) outside-PWD path → silent
+#   (f) file does not exist on disk → silent
+#
+# @problem P081
+
+setup() {
+  REPO_ROOT="$(cd "$(dirname "$BATS_TEST_FILENAME")/../../../.." && pwd)"
+  HOOK="$REPO_ROOT/packages/tdd/hooks/tdd-review-test.sh"
+
+  WORKDIR="$(mktemp -d)"
+  ORIG_PWD="$PWD"
+  cd "$WORKDIR"
+
+  # Sample test file content — a structural assertion the agent should flag.
+  STRUCTURAL_BATS_BODY='@test "skill cites P081" {
+  run grep -F "P081" "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}'
+
+  # Sample test file content with the in-file justification comment.
+  JUSTIFIED_BATS_BODY='# tdd-review: structural-permitted (justification: P012 harness primitive not yet implemented)
+@test "skill cites P081" {
+  run grep -F "P081" "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}'
+
+  # Sample TS test file with the // form of the justification comment.
+  JUSTIFIED_TS_BODY='// tdd-review: structural-permitted (justification: P012 vitest harness)
+import { expect, test } from "vitest";
+test("skill cites P081", () => {
+  expect(true).toBe(true);
+});'
+
+  # Non-test file body.
+  IMPL_BODY='function foo() { return 1; }'
+}
+
+teardown() {
+  cd "$ORIG_PWD"
+  rm -rf "$WORKDIR"
+}
+
+# Helper — invoke the hook with a tool_input.file_path and capture output.
+run_hook_with_path() {
+  local path="$1"
+  local json
+  json=$(jq -nc --arg p "$path" '{tool_input: {file_path: $p}, session_id: "rt-test"}')
+  printf '%s' "$json" | bash "$HOOK"
+}
+
+# --- (a) test file → emits advisory directive ---
+
+@test "emits advisory when a .bats file is written" {
+  local f="$WORKDIR/foo.bats"
+  printf '%s\n' "$STRUCTURAL_BATS_BODY" > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"TDD REVIEW-TEST ADVISORY"* ]]
+  [[ "$output" == *"$f"* ]]
+  [[ "$output" == *"review-test"* ]]
+}
+
+@test "emits advisory when a vitest .test.ts file is written" {
+  local f="$WORKDIR/foo.test.ts"
+  printf 'test("foo", () => {});\n' > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"TDD REVIEW-TEST ADVISORY"* ]]
+}
+
+@test "emits advisory when a pytest test_*.py file is written" {
+  local f="$WORKDIR/test_foo.py"
+  printf 'def test_foo():\n    assert True\n' > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"TDD REVIEW-TEST ADVISORY"* ]]
+}
+
+@test "emits advisory when a cucumber .feature file is written" {
+  local f="$WORKDIR/checkout.feature"
+  printf 'Feature: foo\n  Scenario: bar\n    Given x\n' > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"TDD REVIEW-TEST ADVISORY"* ]]
+}
+
+# --- (b) non-test file → silent ---
+
+@test "silent on a plain .ts implementation file" {
+  local f="$WORKDIR/foo.ts"
+  printf '%s\n' "$IMPL_BODY" > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [ -z "$output" ]
+}
+
+@test "silent on a hook .sh file" {
+  local f="$WORKDIR/some-hook.sh"
+  printf '#!/bin/bash\necho hi\n' > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [ -z "$output" ]
+}
+
+@test "silent on a .md prose file" {
+  local f="$WORKDIR/README.md"
+  printf '# Heading\n' > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [ -z "$output" ]
+}
+
+# --- (c) WR_TDD_REVIEW_TEST=skip → silent ---
+
+@test "silent when WR_TDD_REVIEW_TEST=skip is set" {
+  local f="$WORKDIR/foo.bats"
+  printf '%s\n' "$STRUCTURAL_BATS_BODY" > "$f"
+
+  WR_TDD_REVIEW_TEST=skip run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [ -z "$output" ]
+}
+
+# --- (d) tdd-review: structural-permitted comment → silent ---
+
+@test "silent when bash # tdd-review justification comment present" {
+  local f="$WORKDIR/foo.bats"
+  printf '%s\n' "$JUSTIFIED_BATS_BODY" > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [ -z "$output" ]
+}
+
+@test "silent when TS // tdd-review justification comment present" {
+  local f="$WORKDIR/foo.test.ts"
+  printf '%s\n' "$JUSTIFIED_TS_BODY" > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [ -z "$output" ]
+}
+
+# --- (e) outside-PWD path → silent ---
+
+@test "silent when file path is outside PWD" {
+  # Create the file in a different temp dir so it exists but is not under PWD.
+  local outside
+  outside="$(mktemp -d)"
+  local f="$outside/foo.bats"
+  printf '%s\n' "$STRUCTURAL_BATS_BODY" > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [ -z "$output" ]
+
+  rm -rf "$outside"
+}
+
+# --- (f) file does not exist on disk → silent ---
+
+@test "silent when file path does not exist on disk" {
+  local f="$WORKDIR/nonexistent.bats"
+  # Deliberately do NOT create the file.
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [ -z "$output" ]
+}
+
+# --- Additional behavioural assertions ---
+
+@test "advisory text mentions ADR-052" {
+  local f="$WORKDIR/foo.bats"
+  printf '%s\n' "$STRUCTURAL_BATS_BODY" > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"ADR-052"* ]]
+}
+
+@test "advisory text mentions both escape hatches" {
+  local f="$WORKDIR/foo.bats"
+  printf '%s\n' "$STRUCTURAL_BATS_BODY" > "$f"
+
+  run run_hook_with_path "$f"
+
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"WR_TDD_REVIEW_TEST=skip"* ]]
+  [[ "$output" == *"structural-permitted"* ]]
+}
+
+@test "exit status is always 0 (advisory, never blocking)" {
+  local f="$WORKDIR/foo.bats"
+  printf '%s\n' "$STRUCTURAL_BATS_BODY" > "$f"
+
+  run run_hook_with_path "$f"
+  [ "$status" -eq 0 ]
+
+  printf '%s\n' "$JUSTIFIED_BATS_BODY" > "$f"
+  run run_hook_with_path "$f"
+  [ "$status" -eq 0 ]
+
+  rm "$f"
+  run run_hook_with_path "$f"
+  [ "$status" -eq 0 ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windyroad/tdd",
-  "version": "0.3.1",
+  "version": "0.4.0-preview.267",
   "description": "TDD state machine enforcement (Red-Green-Refactor cycle)",
   "bin": {
     "windyroad-tdd": "./bin/install.mjs"