@su-record/vibe 2.8.49 → 2.8.51

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

package/skills/characterization-test/templates/test-template.ts

@@ -1,101 +1,101 @@
-/**
- * Characterization test template — lock existing behavior before refactoring.
- *
- * Instructions:
- *   1. Replace {{MODULE_NAME}} with the module under test.
- *   2. Replace {{IMPORT_PATH}} with the relative import path.
- *   3. Replace {{FUNCTION_NAME}} with each public export to characterize.
- *   4. Run once to generate snapshots: npx vitest run --update {{TEST_FILE}}
- *   5. Verify all tests pass BEFORE making any changes to the source.
- *
- * IMPORTANT: Capture ACTUAL behavior, not expected/ideal behavior.
- * If the current code has a bug, capture the buggy output — fix it separately.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// import { {{FUNCTION_NAME}} } from '{{IMPORT_PATH}}';
-
-describe('{{MODULE_NAME}} — characterization tests', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  // -------------------------------------------------------------------------
-  // Happy path — normal inputs
-  // -------------------------------------------------------------------------
-
-  it('should handle typical input', () => {
-    // const result = {{FUNCTION_NAME}}({{TYPICAL_INPUT}});
-    // expect(result).toMatchSnapshot();
-  });
-
-  it('should handle minimum valid input', () => {
-    // const result = {{FUNCTION_NAME}}({{MIN_INPUT}});
-    // expect(result).toMatchSnapshot();
-  });
-
-  it('should handle maximum valid input', () => {
-    // const result = {{FUNCTION_NAME}}({{MAX_INPUT}});
-    // expect(result).toMatchSnapshot();
-  });
-
-  // -------------------------------------------------------------------------
-  // Edge cases — boundary values
-  // -------------------------------------------------------------------------
-
-  it('should handle empty string input', () => {
-    // const result = {{FUNCTION_NAME}}('');
-    // expect(result).toMatchSnapshot();
-  });
-
-  it('should handle empty array input', () => {
-    // const result = {{FUNCTION_NAME}}([]);
-    // expect(result).toMatchSnapshot();
-  });
-
-  it('should handle zero / false / null-like values', () => {
-    // const result = {{FUNCTION_NAME}}(0);
-    // expect(result).toMatchSnapshot();
-  });
-
-  // -------------------------------------------------------------------------
-  // Error paths — failure modes
-  // -------------------------------------------------------------------------
-
-  it('should handle null input', () => {
-    // expect(() => {{FUNCTION_NAME}}(null)).toThrowErrorMatchingSnapshot();
-  });
-
-  it('should handle undefined input', () => {
-    // expect(() => {{FUNCTION_NAME}}(undefined)).toThrowErrorMatchingSnapshot();
-  });
-
-  it('should handle invalid type input', () => {
-    // expect(() => {{FUNCTION_NAME}}({{INVALID_INPUT}})).toThrowErrorMatchingSnapshot();
-  });
-
-  // -------------------------------------------------------------------------
-  // Side effects — external interactions
-  // -------------------------------------------------------------------------
-
-  it('should call external dependency with correct arguments', () => {
-    // const spy = vi.spyOn({{DEPENDENCY}}, '{{METHOD}}');
-    // {{FUNCTION_NAME}}({{TYPICAL_INPUT}});
-    // expect(spy).toHaveBeenCalledWith({{EXPECTED_ARGS}});
-    // expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  // -------------------------------------------------------------------------
-  // Branching paths — one test per major branch
-  // -------------------------------------------------------------------------
-
-  it('should take branch A when condition is true', () => {
-    // const result = {{FUNCTION_NAME}}({{BRANCH_A_INPUT}});
-    // expect(result).toMatchSnapshot();
-  });
-
-  it('should take branch B when condition is false', () => {
-    // const result = {{FUNCTION_NAME}}({{BRANCH_B_INPUT}});
-    // expect(result).toMatchSnapshot();
-  });
-});
+/**
+ * Characterization test template — lock existing behavior before refactoring.
+ *
+ * Instructions:
+ *   1. Replace {{MODULE_NAME}} with the module under test.
+ *   2. Replace {{IMPORT_PATH}} with the relative import path.
+ *   3. Replace {{FUNCTION_NAME}} with each public export to characterize.
+ *   4. Run once to generate snapshots: npx vitest run --update {{TEST_FILE}}
+ *   5. Verify all tests pass BEFORE making any changes to the source.
+ *
+ * IMPORTANT: Capture ACTUAL behavior, not expected/ideal behavior.
+ * If the current code has a bug, capture the buggy output — fix it separately.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// import { {{FUNCTION_NAME}} } from '{{IMPORT_PATH}}';
+
+describe('{{MODULE_NAME}} — characterization tests', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  // -------------------------------------------------------------------------
+  // Happy path — normal inputs
+  // -------------------------------------------------------------------------
+
+  it('should handle typical input', () => {
+    // const result = {{FUNCTION_NAME}}({{TYPICAL_INPUT}});
+    // expect(result).toMatchSnapshot();
+  });
+
+  it('should handle minimum valid input', () => {
+    // const result = {{FUNCTION_NAME}}({{MIN_INPUT}});
+    // expect(result).toMatchSnapshot();
+  });
+
+  it('should handle maximum valid input', () => {
+    // const result = {{FUNCTION_NAME}}({{MAX_INPUT}});
+    // expect(result).toMatchSnapshot();
+  });
+
+  // -------------------------------------------------------------------------
+  // Edge cases — boundary values
+  // -------------------------------------------------------------------------
+
+  it('should handle empty string input', () => {
+    // const result = {{FUNCTION_NAME}}('');
+    // expect(result).toMatchSnapshot();
+  });
+
+  it('should handle empty array input', () => {
+    // const result = {{FUNCTION_NAME}}([]);
+    // expect(result).toMatchSnapshot();
+  });
+
+  it('should handle zero / false / null-like values', () => {
+    // const result = {{FUNCTION_NAME}}(0);
+    // expect(result).toMatchSnapshot();
+  });
+
+  // -------------------------------------------------------------------------
+  // Error paths — failure modes
+  // -------------------------------------------------------------------------
+
+  it('should handle null input', () => {
+    // expect(() => {{FUNCTION_NAME}}(null)).toThrowErrorMatchingSnapshot();
+  });
+
+  it('should handle undefined input', () => {
+    // expect(() => {{FUNCTION_NAME}}(undefined)).toThrowErrorMatchingSnapshot();
+  });
+
+  it('should handle invalid type input', () => {
+    // expect(() => {{FUNCTION_NAME}}({{INVALID_INPUT}})).toThrowErrorMatchingSnapshot();
+  });
+
+  // -------------------------------------------------------------------------
+  // Side effects — external interactions
+  // -------------------------------------------------------------------------
+
+  it('should call external dependency with correct arguments', () => {
+    // const spy = vi.spyOn({{DEPENDENCY}}, '{{METHOD}}');
+    // {{FUNCTION_NAME}}({{TYPICAL_INPUT}});
+    // expect(spy).toHaveBeenCalledWith({{EXPECTED_ARGS}});
+    // expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  // -------------------------------------------------------------------------
+  // Branching paths — one test per major branch
+  // -------------------------------------------------------------------------
+
+  it('should take branch A when condition is true', () => {
+    // const result = {{FUNCTION_NAME}}({{BRANCH_A_INPUT}});
+    // expect(result).toMatchSnapshot();
+  });
+
+  it('should take branch B when condition is false', () => {
+    // const result = {{FUNCTION_NAME}}({{BRANCH_B_INPUT}});
+    // expect(result).toMatchSnapshot();
+  });
+});