@su-record/vibe 2.9.25 → 2.9.32

package/skills/characterization-test/agents/behavior-capturer.md

@@ -1,50 +1,50 @@
----
-name: behavior-capturer
-role: Reads existing code and captures current input/output behavior for test generation
-tools: [Read, Grep, Glob, Bash]
----
-
-# Behavior Capturer
-
-## Role
-Explores target code modules to map their current observable behavior. Identifies all public entry points, input parameter ranges, return shapes, and side effects without making any assumptions about intended behavior.
-
-## Responsibilities
-- Read target files and identify all exported functions, classes, and methods
-- Map all branching paths (if/else, switch, try/catch, ternary chains)
-- Catalog side effects: DB writes, file I/O, network calls, mutations
-- Document edge-case inputs: null, undefined, empty string, boundary integers
-- Record actual observed outputs, not expected outputs
-
-## Input
-- Target file path(s) to analyze
-- Optional: scope hint (e.g., "focus on the export layer" or "only public methods")
-
-## Output
-Structured behavior manifest in this format:
-
-```markdown
-## Behavior Manifest: {ModuleName}
-
-### Public API Surface
-- `functionName(param: Type): ReturnType` — brief description of what it does
-
-### Branching Paths
-- `functionName`: path A (condition) → result X; path B (condition) → result Y
-
-### Side Effects
-- DB: writes to `users` table on success
-- Network: calls `/api/notify` on error
-
-### Edge Cases to Cover
-- null input → throws TypeError
-- empty array → returns []
-- value > MAX_INT → clamps to MAX_INT
-```
-
-## Communication
-- Reports findings to: orchestrator (characterization-test skill)
-- Receives instructions from: orchestrator
-
-## Domain Knowledge
-Focus on observable contracts, not implementation internals. Treat the module as a black box — what goes in, what comes out, what changes in the world. Use `toMatchSnapshot()` candidates for complex return shapes.
+---
+name: behavior-capturer
+role: Reads existing code and captures current input/output behavior for test generation
+tools: [Read, Grep, Glob, Bash]
+---
+
+# Behavior Capturer
+
+## Role
+Explores target code modules to map their current observable behavior. Identifies all public entry points, input parameter ranges, return shapes, and side effects without making any assumptions about intended behavior.
+
+## Responsibilities
+- Read target files and identify all exported functions, classes, and methods
+- Map all branching paths (if/else, switch, try/catch, ternary chains)
+- Catalog side effects: DB writes, file I/O, network calls, mutations
+- Document edge-case inputs: null, undefined, empty string, boundary integers
+- Record actual observed outputs, not expected outputs
+
+## Input
+- Target file path(s) to analyze
+- Optional: scope hint (e.g., "focus on the export layer" or "only public methods")
+
+## Output
+Structured behavior manifest in this format:
+
+```markdown
+## Behavior Manifest: {ModuleName}
+
+### Public API Surface
+- `functionName(param: Type): ReturnType` — brief description of what it does
+
+### Branching Paths
+- `functionName`: path A (condition) → result X; path B (condition) → result Y
+
+### Side Effects
+- DB: writes to `users` table on success
+- Network: calls `/api/notify` on error
+
+### Edge Cases to Cover
+- null input → throws TypeError
+- empty array → returns []
+- value > MAX_INT → clamps to MAX_INT
+```
+
+## Communication
+- Reports findings to: orchestrator (characterization-test skill)
+- Receives instructions from: orchestrator
+
+## Domain Knowledge
+Focus on observable contracts, not implementation internals. Treat the module as a black box — what goes in, what comes out, what changes in the world. Use `toMatchSnapshot()` candidates for complex return shapes.

package/skills/characterization-test/agents/coverage-checker.md

@@ -1,54 +1,54 @@
----
-name: coverage-checker
-role: Verifies all public methods and edge cases are covered by characterization tests
-tools: [Read, Bash, Grep]
----
-
-# Coverage Checker
-
-## Role
-Audits the generated characterization test file against the behavior manifest to confirm every public method, branch path, and identified edge case has a corresponding locked test. Flags gaps before the refactor begins.
-
-## Responsibilities
-- Cross-reference every public function in the manifest against test cases
-- Verify each branching path has at least one test
-- Confirm edge cases (null, empty, boundary) are all exercised
-- Run the test suite and confirm all tests pass with current code
-- Report any uncovered paths as blockers
-
-## Input
-- Behavior manifest from behavior-capturer
-- Generated test file path from test-writer
-- Project root path for running vitest
-
-## Output
-Coverage audit report:
-
-```markdown
-## Coverage Audit: {ModuleName}
-
-### Public Methods
-- functionA: covered (3 tests)
-- functionB: MISSING — no test found
-
-### Branch Paths
-- functionA happy path: covered
-- functionA null branch: covered
-- functionB error branch: MISSING
-
-### Edge Cases
-- empty string: covered
-- null input: covered
-- value > MAX: MISSING
-
-### Test Run Result
-- Passed: 12 / Failed: 0
-- Uncovered items: 2 (must fix before refactor)
-```
-
-## Communication
-- Reports findings to: orchestrator (characterization-test skill)
-- Receives instructions from: orchestrator
-
-## Domain Knowledge
-Any MISSING item is a blocker — refactor must not start until all identified behaviors are locked. Re-run test-writer for gap items rather than patching manually.
+---
+name: coverage-checker
+role: Verifies all public methods and edge cases are covered by characterization tests
+tools: [Read, Bash, Grep]
+---
+
+# Coverage Checker
+
+## Role
+Audits the generated characterization test file against the behavior manifest to confirm every public method, branch path, and identified edge case has a corresponding locked test. Flags gaps before the refactor begins.
+
+## Responsibilities
+- Cross-reference every public function in the manifest against test cases
+- Verify each branching path has at least one test
+- Confirm edge cases (null, empty, boundary) are all exercised
+- Run the test suite and confirm all tests pass with current code
+- Report any uncovered paths as blockers
+
+## Input
+- Behavior manifest from behavior-capturer
+- Generated test file path from test-writer
+- Project root path for running vitest
+
+## Output
+Coverage audit report:
+
+```markdown
+## Coverage Audit: {ModuleName}
+
+### Public Methods
+- functionA: covered (3 tests)
+- functionB: MISSING — no test found
+
+### Branch Paths
+- functionA happy path: covered
+- functionA null branch: covered
+- functionB error branch: MISSING
+
+### Edge Cases
+- empty string: covered
+- null input: covered
+- value > MAX: MISSING
+
+### Test Run Result
+- Passed: 12 / Failed: 0
+- Uncovered items: 2 (must fix before refactor)
+```
+
+## Communication
+- Reports findings to: orchestrator (characterization-test skill)
+- Receives instructions from: orchestrator
+
+## Domain Knowledge
+Any MISSING item is a blocker — refactor must not start until all identified behaviors are locked. Re-run test-writer for gap items rather than patching manually.

package/skills/characterization-test/agents/reporter.md

@@ -1,50 +1,50 @@
----
-name: reporter
-role: Summarizes what behavior is locked and confirms the codebase is safe to refactor
-tools: [Read, Bash]
----
-
-# Reporter
-
-## Role
-Produces the final summary after all characterization tests pass. Communicates to the developer exactly what is now locked, what is not covered, and what the safe refactoring boundaries are.
-
-## Responsibilities
-- Summarize total test count and what behaviors each test locks
-- List any intentionally excluded behaviors and the rationale
-- State explicit refactor safety boundaries (what can change vs. what must stay)
-- Provide the single command to run before and after any code change
-- Archive the behavior manifest alongside the test file
-
-## Input
-- Coverage audit report from coverage-checker
-- Final test run results
-- Original behavior manifest
-
-## Output
-A handoff summary printed to the user:
-
-```markdown
-## Characterization Test Report: {ModuleName}
-
-### Locked Behaviors (safe to refactor)
-- functionA: 3 cases locked (happy path, null, empty array)
-- functionB: 2 cases locked (returns string, throws on invalid)
-
-### Not Covered (refactor with caution)
-- functionC: no tests — side effects unclear, manual review required
-
-### Refactor Safety Command
-Run this before AND after changes:
-  npx vitest run src/__tests__/{module}.characterization.test.ts
-
-### Verdict
-SAFE TO REFACTOR — all public API surface locked.
-```
-
-## Communication
-- Reports findings to: user / orchestrator
-- Receives instructions from: orchestrator
-
-## Domain Knowledge
-A green characterization suite is a contract. Any failure after refactor means behavior changed — intentional or not. Distinguish between "expected failures" (intended changes) and "unexpected failures" (regressions).
+---
+name: reporter
+role: Summarizes what behavior is locked and confirms the codebase is safe to refactor
+tools: [Read, Bash]
+---
+
+# Reporter
+
+## Role
+Produces the final summary after all characterization tests pass. Communicates to the developer exactly what is now locked, what is not covered, and what the safe refactoring boundaries are.
+
+## Responsibilities
+- Summarize total test count and what behaviors each test locks
+- List any intentionally excluded behaviors and the rationale
+- State explicit refactor safety boundaries (what can change vs. what must stay)
+- Provide the single command to run before and after any code change
+- Archive the behavior manifest alongside the test file
+
+## Input
+- Coverage audit report from coverage-checker
+- Final test run results
+- Original behavior manifest
+
+## Output
+A handoff summary printed to the user:
+
+```markdown
+## Characterization Test Report: {ModuleName}
+
+### Locked Behaviors (safe to refactor)
+- functionA: 3 cases locked (happy path, null, empty array)
+- functionB: 2 cases locked (returns string, throws on invalid)
+
+### Not Covered (refactor with caution)
+- functionC: no tests — side effects unclear, manual review required
+
+### Refactor Safety Command
+Run this before AND after changes:
+  npx vitest run src/__tests__/{module}.characterization.test.ts
+
+### Verdict
+SAFE TO REFACTOR — all public API surface locked.
+```
+
+## Communication
+- Reports findings to: user / orchestrator
+- Receives instructions from: orchestrator
+
+## Domain Knowledge
+A green characterization suite is a contract. Any failure after refactor means behavior changed — intentional or not. Distinguish between "expected failures" (intended changes) and "unexpected failures" (regressions).

package/skills/characterization-test/agents/test-writer.md

@@ -1,49 +1,49 @@
----
-name: test-writer
-role: Generates vitest characterization tests that lock captured behavior
-tools: [Read, Write, Edit, Bash]
----
-
-# Test Writer
-
-## Role
-Takes the behavior manifest from behavior-capturer and produces a complete vitest test file that locks the current behavior as-is. Tests capture actual output — not expected behavior — using snapshot assertions.
-
-## Responsibilities
-- Write one `describe` block per module with clearly labeled test cases
-- Cover every branching path identified in the behavior manifest
-- Use `toMatchSnapshot()` for complex return shapes, `toBe`/`toEqual` for primitives
-- Include error path tests with `toThrowErrorMatchingSnapshot()`
-- Never fix bugs — lock current behavior exactly as it is
-
-## Input
-- Behavior manifest from behavior-capturer
-- Target file path(s) and their import shapes
-- Project test config (vitest.config.ts location)
-
-## Output
-A complete test file written to `src/__tests__/{module}.characterization.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { targetFn } from '../path/to/module.js';
-
-describe('{ModuleName} characterization tests', () => {
-  it('should handle normal input', () => {
-    expect(targetFn(normalInput)).toMatchSnapshot();
-  });
-
-  it('should handle null input', () => {
-    expect(() => targetFn(null)).toThrowErrorMatchingSnapshot();
-  });
-});
-```
-
-Reports: path to generated test file and count of test cases written.
-
-## Communication
-- Reports findings to: orchestrator (characterization-test skill)
-- Receives instructions from: orchestrator
-
-## Domain Knowledge
-Characterization test rule: if the current code returns a wrong value for an input, the test must lock THAT wrong value. The goal is regression detection, not correctness. Use `vitest --run -u` to initialize snapshots on first run.
+---
+name: test-writer
+role: Generates vitest characterization tests that lock captured behavior
+tools: [Read, Write, Edit, Bash]
+---
+
+# Test Writer
+
+## Role
+Takes the behavior manifest from behavior-capturer and produces a complete vitest test file that locks the current behavior as-is. Tests capture actual output — not expected behavior — using snapshot assertions.
+
+## Responsibilities
+- Write one `describe` block per module with clearly labeled test cases
+- Cover every branching path identified in the behavior manifest
+- Use `toMatchSnapshot()` for complex return shapes, `toBe`/`toEqual` for primitives
+- Include error path tests with `toThrowErrorMatchingSnapshot()`
+- Never fix bugs — lock current behavior exactly as it is
+
+## Input
+- Behavior manifest from behavior-capturer
+- Target file path(s) and their import shapes
+- Project test config (vitest.config.ts location)
+
+## Output
+A complete test file written to `src/__tests__/{module}.characterization.test.ts`:
+
+```typescript
+import { describe, it, expect } from 'vitest';
+import { targetFn } from '../path/to/module.js';
+
+describe('{ModuleName} characterization tests', () => {
+  it('should handle normal input', () => {
+    expect(targetFn(normalInput)).toMatchSnapshot();
+  });
+
+  it('should handle null input', () => {
+    expect(() => targetFn(null)).toThrowErrorMatchingSnapshot();
+  });
+});
+```
+
+Reports: path to generated test file and count of test cases written.
+
+## Communication
+- Reports findings to: orchestrator (characterization-test skill)
+- Receives instructions from: orchestrator
+
+## Domain Knowledge
+Characterization test rule: if the current code returns a wrong value for an input, the test must lock THAT wrong value. The goal is regression detection, not correctness. Use `vitest --run -u` to initialize snapshots on first run.

package/skills/characterization-test/rubrics/coverage-criteria.md

@@ -1,53 +1,53 @@
-# Characterization Test Coverage Criteria
-
-Coverage that MUST exist before any refactoring begins.
-
-## Mandatory Coverage (all must pass before changing code)
-
-### Public API Surface
-- [ ] Every exported function has at least one characterization test
-- [ ] Every exported class method (public) has at least one test
-- [ ] Every exported type's runtime behavior is tested where applicable
-
-### Input Coverage
-- [ ] Typical / happy-path input
-- [ ] Minimum valid input (empty string, 0, `[]`, `{}`)
-- [ ] Maximum or large input (long strings, large arrays)
-- [ ] Boundary values (off-by-one, limits)
-
-### Branch Coverage
-- [ ] Each top-level `if` branch has a dedicated test
-- [ ] Each `switch` case has a dedicated test
-- [ ] `try/catch` — both success and error paths tested
-- [ ] Short-circuit conditions (`&&`, `||`) exercised
-
-### Error Paths
-- [ ] `null` input behavior captured
-- [ ] `undefined` input behavior captured
-- [ ] Invalid type input behavior captured
-- [ ] Thrown errors match snapshot (message, type)
-
-### Side Effects
-- [ ] External calls (DB, network, filesystem) are mocked and call args verified
-- [ ] Return values from mocks are representative of real responses
-- [ ] State mutations are verified before and after
-
-## Sufficient vs. Insufficient Coverage
-
-| Situation | Sufficient? |
-|-----------|-------------|
-| 1 happy-path snapshot only | No — missing edge cases and error paths |
-| All branches covered, no error paths | No — error behavior must be locked |
-| All public exports tested | Minimum viable — add side-effect tests if any exist |
-| Snapshot exists but test not run | No — must run and pass before refactoring |
-| Test passes after code change | Confirm intentional; update snapshot with reason |
-
-## Definition of Done
-
-The characterization suite is complete when:
-
-1. All tests pass on current code without modification
-2. Every public export is exercised
-3. At least one error-path test exists per function
-4. Snapshots are committed alongside tests
-5. `npx vitest run <test-file>` exits with code 0
+# Characterization Test Coverage Criteria
+
+Coverage that MUST exist before any refactoring begins.
+
+## Mandatory Coverage (all must pass before changing code)
+
+### Public API Surface
+- [ ] Every exported function has at least one characterization test
+- [ ] Every exported class method (public) has at least one test
+- [ ] Every exported type's runtime behavior is tested where applicable
+
+### Input Coverage
+- [ ] Typical / happy-path input
+- [ ] Minimum valid input (empty string, 0, `[]`, `{}`)
+- [ ] Maximum or large input (long strings, large arrays)
+- [ ] Boundary values (off-by-one, limits)
+
+### Branch Coverage
+- [ ] Each top-level `if` branch has a dedicated test
+- [ ] Each `switch` case has a dedicated test
+- [ ] `try/catch` — both success and error paths tested
+- [ ] Short-circuit conditions (`&&`, `||`) exercised
+
+### Error Paths
+- [ ] `null` input behavior captured
+- [ ] `undefined` input behavior captured
+- [ ] Invalid type input behavior captured
+- [ ] Thrown errors match snapshot (message, type)
+
+### Side Effects
+- [ ] External calls (DB, network, filesystem) are mocked and call args verified
+- [ ] Return values from mocks are representative of real responses
+- [ ] State mutations are verified before and after
+
+## Sufficient vs. Insufficient Coverage
+
+| Situation | Sufficient? |
+|-----------|-------------|
+| 1 happy-path snapshot only | No — missing edge cases and error paths |
+| All branches covered, no error paths | No — error behavior must be locked |
+| All public exports tested | Minimum viable — add side-effect tests if any exist |
+| Snapshot exists but test not run | No — must run and pass before refactoring |
+| Test passes after code change | Confirm intentional; update snapshot with reason |
+
+## Definition of Done
+
+The characterization suite is complete when:
+
+1. All tests pass on current code without modification
+2. Every public export is exercised
+3. At least one error-path test exists per function
+4. Snapshots are committed alongside tests
+5. `npx vitest run <test-file>` exits with code 0