@simplysm/claude 13.0.26 → 13.0.27

package/claude/skills/sd-check/SKILL.md

@@ -1,143 +1,205 @@
 ---
 name: sd-check
-description: Verify code via typecheck, lint, and tests
-argument-hint: "[path]"
-model: opus
+description: Use when verifying code quality via typecheck, lint, and tests - before deployment, PR creation, after code changes, or when type errors, lint violations, or test failures are suspected. Applies to whole project or specific paths.
 ---
 
-## Usage
+# sd-check
 
-- `/sd-check` — verify the entire project
-- `/sd-check packages/core-common` — verify a specific path only
+Verify code quality through parallel execution of typecheck, lint, and test checks.
 
-If an argument is provided, run against that path. Otherwise, run against the entire project.
+## Overview
 
-## Environment Pre-check
+**This skill provides EXACT STEPS you MUST follow - it is NOT a command to invoke.**
 
-Before running any verification, confirm the project environment is properly set up.
-Run these checks **in parallel** and report results before proceeding.
+**Foundational Principle:** Violating the letter of these steps is violating the spirit of verification.
 
-### 1. Root package.json version
+When the user asks to verify code, YOU will manually execute **EXACTLY THESE 4 STEPS** (no more, no less):
 
-Read the root `package.json` and check the `version` field.
-The major version must be `13` (e.g., `13.x.x`). If the major version is not `13`, stop and report:
+**Step 1:** Environment Pre-check (4 checks in parallel)
+**Step 2:** Launch 3 haiku agents in parallel (typecheck, lint, test ONLY)
+**Step 3:** Collect results, fix errors in priority order
+**Step 4:** Re-verify (go back to Step 2) until all pass
 
-> "This skill requires simplysm v13. Current version: {version}"
+**Core principle:** Always re-run ALL checks after any fix - changes can cascade.
 
-### 2. pnpm workspace
+**CRITICAL:**
+- This skill verifies ONLY typecheck, lint, and test
+- **NO BUILD. NO DEV SERVER. NO TEAMS. NO TASK LISTS.**
+- Do NOT create your own "better" workflow - follow these 4 steps EXACTLY
 
-Verify this is a pnpm project:
+## Usage
 
-```
-ls pnpm-workspace.yaml pnpm-lock.yaml
-```
+- `/sd-check` — verify entire project
+- `/sd-check packages/core-common` — verify specific path only
 
-Both files must exist. If missing, stop and report to the user.
+**Default:** If no path argument provided, verify entire project.
 
-### 3. package.json scripts
+## Quick Reference
 
-Read the root `package.json` and confirm these scripts are defined:
+| Check | Command | Agent Model | Purpose |
+|-------|---------|-------------|---------|
+| Typecheck | `pnpm typecheck [path]` | haiku | Type errors |
+| Lint | `pnpm lint --fix [path]` | haiku | Code quality |
+| Test | `pnpm vitest [path] --run` | haiku | Functionality |
 
-- `typecheck`
-- `lint`
+**All 3 run in PARALLEL** (separate haiku agents, single message)
 
-If either is missing, stop and report to the user.
+## Workflow
 
-### 4. Vitest config
+### Step 1: Environment Pre-check
 
-Verify vitest is configured:
+Before ANY verification, confirm environment setup with these checks **in parallel**:
 
-```
-ls vitest.config.ts
-```
+1. **Root package.json version** - Read `package.json`, verify major version is `13` (e.g., `13.x.x`)
+   - If not 13: STOP, report "This skill requires simplysm v13. Current: {version}"
 
-If missing, stop and report to the user.
+2. **pnpm workspace** - Verify `pnpm-workspace.yaml` and `pnpm-lock.yaml` exist
+   - Command: `ls pnpm-workspace.yaml pnpm-lock.yaml`
+   - If missing: STOP, report to user
 
----
-
-If all pre-checks pass, report "Environment OK" and proceed to code verification.
+3. **package.json scripts** - Read root `package.json`, confirm `typecheck` and `lint` scripts defined
+   - If missing: STOP, report to user
 
-## Code Verification
+4. **Vitest config** - Verify `vitest.config.ts` exists
+   - Command: `ls vitest.config.ts`
+   - If missing: STOP, report to user
 
-Run verification checks using haiku agents for command execution, then analyze and fix errors.
-Repeat until all checks pass.
+**If all pass:** Report "Environment OK", proceed to Step 2.
 
-### Step 1: Launch Verification Agents (Parallel)
+### Step 2: Launch 3 Haiku Agents in Parallel
 
-Launch 3 haiku agents in parallel using the Task tool.
+Launch ALL 3 agents in a **single message** using Task tool.
 
-**Important**: Replace `[path]` in the commands below with the actual path argument provided by the user. If no argument was provided, omit the path (runs on entire project).
+**Replace `[path]` with user's argument, or OMIT if no argument (defaults to full project).**
 
 **Agent 1 - Typecheck:**
 ```
-Task tool with:
+Task tool:
   subagent_type: Bash
   model: haiku
   description: "Run typecheck"
-  prompt: "Run `pnpm typecheck [path]` and return the full output. Do NOT analyze or fix errors - just report the raw output."
+  prompt: "Run `pnpm typecheck [path]` and return full output. Do NOT analyze or fix - just report raw output."
 ```
 
 **Agent 2 - Lint:**
 ```
-Task tool with:
+Task tool:
   subagent_type: Bash
   model: haiku
   description: "Run lint with auto-fix"
-  prompt: "Run `pnpm lint --fix [path]` and return the full output. Do NOT analyze or fix errors - just report the raw output."
+  prompt: "Run `pnpm lint --fix [path]` and return full output. Do NOT analyze or fix - just report raw output."
 ```
 
 **Agent 3 - Test:**
 ```
-Task tool with:
+Task tool:
   subagent_type: Bash
   model: haiku
   description: "Run tests"
-  prompt: "Run `pnpm vitest [path] --run` and return the full output. Do NOT analyze or fix errors - just report the raw output."
+  prompt: "Run `pnpm vitest [path] --run` and return full output. Do NOT analyze or fix - just report raw output."
 ```
 
-### Step 2: Collect Results and Fix Errors
+### Step 3: Collect Results and Fix Errors
+
+Wait for ALL 3 agents. Collect outputs.
+
+**If all checks passed:** Complete (see Completion Criteria).
+
+**If any errors found:**
 
-Wait for all 3 agents to complete. Collect their outputs.
+1. **Analyze by priority:** Typecheck → Lint → Test
+   - Typecheck errors may cause lint/test errors (cascade)
 
-If any errors are found:
+2. **Read failing files** to identify root cause
 
-1. **Analyze errors by priority**: typecheck → lint → test
-   - Typecheck errors may cause lint/test errors, so fix them first
-2. **Read failing files** to identify root causes
-3. **Fix with Edit**:
-   - Typecheck errors: Fix type issues
-   - Lint errors: Fix linting issues (most should be auto-fixed by `--fix`)
-   - Test failures:
-     - Run `git diff` to check for intentional code changes
-     - If intentional changes not reflected in tests: Update test code
-     - If source code bug: Fix source code
-4. Proceed to Step 3
+3. **Fix with Edit:**
+   - **Typecheck:** Fix type issues
+   - **Lint:** Fix code quality (most auto-fixed by `--fix`)
+   - **Test:**
+     - Run `git diff` to check intentional changes
+     - If changes not reflected in tests: Update test
+     - If source bug: Fix source
+     - **If root cause unclear OR 2-3 fix attempts failed:** Recommend `/sd-debug`
 
-If all checks passed: Proceed to Completion.
+4. **Proceed to Step 4**
 
-### Step 3: Re-verify (Loop)
+### Step 4: Re-verify (Loop Until All Pass)
 
-Go back to Step 1 and launch the 3 haiku agents again.
-Repeat until all checks pass with no errors.
+**CRITICAL:** After ANY fix, re-run ALL 3 checks.
+
+Go back to Step 2 and launch 3 haiku agents again.
+
+**Do NOT assume:** "I only fixed typecheck → skip lint/test". Fixes cascade.
+
+Repeat Steps 2-4 until all 3 checks pass.
 
 ## Common Mistakes
 
-### Running checks sequentially instead of parallel
-❌ **Wrong**: Launch agent 1, wait, then agent 2, wait, then agent 3
-✅ **Right**: Launch all 3 agents in a single message with multiple Task tool calls
+### ❌ Running checks sequentially
+**Wrong:** Launch agent 1, wait → agent 2, wait → agent 3
+**Right:** Launch ALL 3 in single message (parallel Task calls)
+
+### ❌ Fixing before collecting all results
+**Wrong:** Agent 1 returns error → fix immediately → re-verify
+**Right:** Wait for all 3 → collect all errors → fix in priority order → re-verify
+
+### ❌ Skipping re-verification after fixes
+**Wrong:** Fix typecheck → assume lint/test still pass
+**Right:** ALWAYS re-run all 3 checks after any fix
+
+### ❌ Using wrong model
+**Wrong:** `model: opus` or `model: sonnet` for verification agents
+**Right:** `model: haiku` (cheaper, faster for command execution)
+
+### ❌ Including build/dev steps
+**Wrong:** Run `pnpm build` or `pnpm dev` as part of verification
+**Right:** sd-check is ONLY typecheck, lint, test (no build, no dev)
+
+### ❌ Asking user for path
+**Wrong:** No path provided → ask "which package?"
+**Right:** No path → verify entire project (omit path in commands)
+
+### ❌ Infinite fix loop
+**Wrong:** Keep trying same fix when tests fail repeatedly
+**Right:** After 2-3 failed attempts → recommend `/sd-debug`
+
+## Red Flags - STOP and Follow Workflow
 
-### Fixing before collecting all results
-❌ **Wrong**: Agent 1 returns error → fix immediately → launch agents again
-✅ **Right**: Wait for all 3 agents → collect all errors → fix in priority order → re-verify
+If you find yourself doing ANY of these, you're violating the skill:
 
-### Skipping re-verification after fixes
-❌ **Wrong**: Fix typecheck error → assume lint/test still pass
-✅ **Right**: Always re-run all 3 checks after any fix (fixes can introduce new errors)
+- Treating sd-check as a command to invoke (`Skill: sd-check Args: ...`)
+- Including build or dev server in verification
+- Running agents sequentially instead of parallel
+- Not re-verifying after every fix
+- Asking user for path when none provided
+- Continuing past 2-3 failed fix attempts without recommending `/sd-debug`
+- Spawning 4+ agents (only 3: typecheck, lint, test)
 
-### Using wrong model for agents
-❌ **Wrong**: `model: opus` or `model: sonnet` for verification agents
-✅ **Right**: `model: haiku` for command execution (cheaper, faster)
+**All of these violate the skill's core principles. Go back to Step 1 and follow the workflow exactly.**
 
 ## Completion Criteria
 
-Complete when all 3 checks pass without errors.
+**Complete when:**
+- All 3 checks (typecheck, lint, test) pass without errors
+- Report: "All checks passed - code verified"
+
+**Do NOT complete if:**
+- Any check has errors
+- Haven't re-verified after a fix
+- Environment pre-checks failed
+
+## Rationalization Table
+
+| Excuse | Reality |
+|--------|---------|
+| "I'm following the spirit, not the letter" | Violating the letter IS violating the spirit - follow EXACTLY |
+| "I'll create a better workflow with teams/tasks" | Follow the 4 steps EXACTLY - no teams, no task lists |
+| "I'll split tests into multiple agents" | Only 3 agents total: typecheck, lint, test |
+| "Stratified parallel is faster" | Run ALL 3 in parallel via separate agents - truly parallel |
+| "I only fixed lint, typecheck still passes" | Always re-verify ALL - fixes can cascade |
+| "Build is part of verification" | Build is deployment, not verification - NEVER include it |
+| "Let me ask which path to check" | Default to full project - explicit behavior |
+| "I'll try one more fix approach" | After 2-3 attempts → recommend /sd-debug |
+| "Tests are independent of types" | Type fixes affect tests - always re-run ALL |
+| "I'll invoke sd-check skill with args" | sd-check is EXACT STEPS, not a command |
+| "4 agents: typecheck, lint, test, build" | Only 3 agents - build is FORBIDDEN |

package/claude/skills/sd-check/baseline-analysis.md

@@ -0,0 +1,129 @@
+# Baseline Test Analysis - sd-check Skill
+
+## Summary
+
+Tested 6 scenarios with agents WITHOUT sd-check skill. All agents failed to follow optimal verification patterns.
+
+## Common Failures Across All Scenarios
+
+### 1. No Cost Optimization
+**Failure:** All agents planned direct command execution instead of using haiku subagents.
+
+**Observed in:** All scenarios (1-6)
+
+**Impact:** Higher cost, no isolation
+
+**What skill must prevent:** Skill must explicitly require haiku subagent usage
+
+### 2. Incomplete Parallelization
+**Failure:** Agents either ran sequentially or only partially parallelized.
+
+**Examples:**
+- Scenario 1: Used `&` for typecheck/lint but ran tests sequentially ("stratified parallel")
+- Scenario 2: No parallelization at all
+- Scenario 3: Sequential fix → verify → fix → verify
+
+**Impact:** Slower verification (60s → 120s+)
+
+**What skill must prevent:** Skill must require ALL 3 checks (typecheck, lint, test) in parallel via 3 separate haiku agents
+
+### 3. Missing Environment Pre-checks
+**Failure:** No systematic environment validation before running checks.
+
+**Observed:**
+- Scenario 1: Checked Docker for ORM tests, but not other prerequisites
+- Scenario 6: Only checked pnpm-lock.yaml, missed package.json version, scripts, vitest.config.ts
+
+**Impact:** Confusing errors if environment misconfigured
+
+**What skill must prevent:** Skill must require 4 pre-checks (package.json v13, pnpm workspace, scripts, vitest config)
+
+### 4. Unclear Re-verification Loop
+**Failure:** After fixing errors, no clear "re-run ALL checks" loop.
+
+**Examples:**
+- Scenario 3: Phase 1 verify → Phase 2 verify → Phase 3 verify (but no final "all phases" re-verify)
+- Agents treated it as linear progression, not a loop
+
+**Impact:** Fixes in one area may break another (cascade errors)
+
+**What skill must prevent:** Skill must explicitly state "re-run ALL 3 checks until ALL pass"
+
+### 5. No sd-debug Recommendation
+**Failure:** When root cause unclear after multiple attempts, agents didn't recommend sd-debug.
+
+**Observed:**
+- Scenario 4: After 4 failed attempts, agent suggested various debugging approaches but NOT `/sd-debug` skill
+
+**Impact:** User wastes time when systematic root-cause investigation needed
+
+**What skill must prevent:** Skill must state "after 2-3 failed fix attempts → recommend /sd-debug"
+
+### 6. Incorrect Default Behavior
+**Failure:** When no path argument provided, agents asked user for clarification instead of defaulting to full project.
+
+**Observed:**
+- Scenario 5: Agent wanted to ask "which package?" instead of running on entire project
+
+**Impact:** Unnecessary user friction
+
+**What skill must prevent:** Skill must state "if no path argument → run on entire project (omit path in commands)"
+
+### 7. Scope Creep (Unnecessary Steps)
+**Failure:** Agents included steps not relevant to "verification".
+
+**Examples:**
+- Scenario 1: Included `pnpm build` (verification doesn't need build)
+- Scenario 2: Included dev server test (not verification)
+
+**Impact:** Wasted time, confusion about scope
+
+**What skill must prevent:** Skill must clarify scope: typecheck, lint, test ONLY (no build, no dev)
+
+## Rationalization Patterns (Verbatim)
+
+### "Parallelization while maintaining logical dependencies"
+- Used to justify partial parallelization
+- Agents ran typecheck & lint in parallel, but tests sequentially
+- **Counter:** ALL 3 checks are independent → all 3 in parallel
+
+### "Stratified parallel execution"
+- Used to justify sequential test runs grouped by environment
+- **Counter:** Vitest projects are independent → run all via single command
+
+### "Faster to fail fast on static checks"
+- Good principle, but used to justify including build step
+- **Counter:** Build is not a static check, and not required for verification
+
+### "Type safety first" / "Incremental verification"
+- Used to justify Phase 1 → Phase 2 → Phase 3 linear progression
+- **Counter:** After fixes, must re-verify ALL phases (loop), not just next phase
+
+### "Understanding first, then ONE comprehensive fix"
+- Used to justify continued debugging without tools
+- **Counter:** After 2-3 attempts, recommend /sd-debug for systematic investigation
+
+### "Ask for clarification" / "Explicit and predictable"
+- Used to justify asking user for path when none provided
+- **Counter:** Default to full project is explicit and predictable behavior
+
+## Success Criteria for Skill
+
+Skill is effective if agents:
+1. ✅ Launch 3 haiku agents in parallel (typecheck, lint, test)
+2. ✅ Run environment pre-checks before verification
+3. ✅ Default to full project when no path argument
+4. ✅ Fix errors in priority order (typecheck → lint → test)
+5. ✅ Re-run ALL 3 checks after any fix (loop until all pass)
+6. ✅ Recommend /sd-debug after 2-3 failed fix attempts
+7. ✅ Do NOT include build or dev server steps
+
+## Test Scenarios for GREEN Phase
+
+After writing skill, re-run scenarios 1-6. Agents should now exhibit correct behavior above.
+
+Focus on:
+- Scenario 1: Verify parallel haiku agents + env checks
+- Scenario 3: Verify re-verification loop + priority
+- Scenario 4: Verify sd-debug recommendation
+- Scenario 5: Verify default to full project

package/claude/skills/sd-check/test-scenarios.md

@@ -0,0 +1,172 @@
+# sd-check Pressure Test Scenarios
+
+## Scenario 1: Basic Application - Full Project Check (Time Pressure)
+
+**Setup:**
+- Simulated project with typecheck, lint, test configured
+- No existing errors
+
+**Pressure:**
+- Time constraint: "Need results quickly for deployment"
+
+**Agent Prompt:**
+```
+I need to verify the entire simplysm project before deployment. Can you run all checks? We need to deploy soon, so please be fast.
+```
+
+**Expected Baseline Failures (without skill):**
+- May run checks sequentially instead of parallel (slower)
+- May skip environment pre-checks
+- May not use haiku model (more expensive)
+
+**Success Criteria (with skill):**
+- Runs environment pre-checks first
+- Launches 3 haiku agents in parallel
+- Reports results correctly
+
+---
+
+## Scenario 2: Variation - Specific Path Check (Complex Path)
+
+**Setup:**
+- Project with multiple packages
+- Target path: `packages/solid-demo`
+
+**Pressure:**
+- Complex path with potential typos
+- User expects path to be handled correctly
+
+**Agent Prompt:**
+```
+Can you verify just the packages/solid-demo directory? I only changed files there.
+```
+
+**Expected Baseline Failures:**
+- May forget to pass path argument to commands
+- May run full project check instead
+- May incorrectly format path in commands
+
+**Success Criteria:**
+- Correctly passes `packages/solid-demo` to all 3 commands
+- Only reports errors from that path
+
+---
+
+## Scenario 3: Edge Case - Typecheck Errors (Fix Priority)
+
+**Setup:**
+- Simulated project with typecheck errors that cascade to lint/test
+
+**Pressure:**
+- Multiple failing checks (frustration)
+- Desire to "just make it work"
+
+**Agent Prompt:**
+```
+Please verify the project. (Note: project has typecheck errors that cause lint and test failures)
+```
+
+**Expected Baseline Failures:**
+- May fix lint or test errors first (wrong priority)
+- May not understand cascade relationship
+- May fix all errors simultaneously without priority
+
+**Success Criteria:**
+- Fixes typecheck errors first
+- Recognizes cascade relationship
+- Re-verifies after each fix round
+
+---
+
+## Scenario 4: Edge Case - Repeated Failures (Loop Exit)
+
+**Setup:**
+- Simulated project with obscure test failure
+- Root cause is unclear
+
+**Pressure:**
+- Repeated verification failures (fatigue)
+- Temptation to give up or skip
+
+**Agent Prompt:**
+```
+Verify the project. (Note: test failures persist after 2-3 fix attempts)
+```
+
+**Expected Baseline Failures:**
+- May keep trying same fix repeatedly (infinite loop)
+- May skip re-verification to "save time"
+- May not recommend sd-debug
+
+**Success Criteria:**
+- After 2-3 failed attempts, recommends `/sd-debug`
+- Does not enter infinite loop
+- Always re-verifies after fixes
+
+---
+
+## Scenario 5: Missing Information Test - No Path Argument
+
+**Setup:**
+- Standard project setup
+
+**Pressure:**
+- Ambiguous user request
+
+**Agent Prompt:**
+```
+Run sd-check.
+```
+
+**Expected Baseline Failures:**
+- May ask user for path (skill should default to full project)
+- May incorrectly assume a path
+
+**Success Criteria:**
+- Runs on entire project (no path argument)
+- Does not ask user for clarification
+
+---
+
+## Scenario 6: Missing Information Test - Invalid Environment
+
+**Setup:**
+- Project missing pnpm-lock.yaml or vitest.config.ts
+
+**Pressure:**
+- User expects check to work
+
+**Agent Prompt:**
+```
+Please run sd-check on the project.
+```
+
+**Expected Baseline Failures:**
+- May proceed without environment checks
+- May report confusing errors from missing dependencies
+
+**Success Criteria:**
+- Runs environment pre-checks
+- Stops with clear error message if environment invalid
+- Reports which specific check failed
+
+---
+
+## Testing Methodology
+
+### RED Phase (Current)
+1. Run each scenario WITHOUT sd-check skill loaded
+2. Document exact agent behavior verbatim
+3. Record rationalizations used
+4. Identify patterns in failures
+
+### GREEN Phase
+1. Write skill addressing specific baseline failures
+2. Run same scenarios WITH skill
+3. Verify compliance
+
+### REFACTOR Phase
+1. Identify new rationalizations from GREEN testing
+2. Add explicit counters
+3. Build rationalization table
+4. Re-test until bulletproof