@simplysm/sd-claude 13.0.45 → 13.0.47

package/claude/rules/sd-workflow-rules.md

@@ -16,3 +16,8 @@
 - Before modifying functions/classes: Read the file to understand existing code style
 - When unsure about API/method usage: Check signatures in source code
 - **If confidence is low, ask the user instead of writing code**
+
+## Memory Policy
+
+- **Do NOT use auto memory** (`~/.claude/projects/.../memory/`). It is environment-specific and does not persist across machines.
+- All persistent knowledge belongs in `.claude/rules/` or project docs (committed to git).

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

@@ -39,53 +39,13 @@ Start by understanding the current project context, then ask questions one at a
 - Write the validated design to `docs/plans/YYYY-MM-DD-<topic>-design.md`
 - Commit the design document to git
 
-**Next Steps Guide:**
+**Next Step:**
 
-Present the following two workflow paths so the user can see the full process and choose.
-Display the guide in the **user's configured language** (follow the language settings from CLAUDE.md or system instructions).
+Display in the **system's configured language**:
 
-Before presenting, check git status for uncommitted changes. If there are any uncommitted changes (staged, unstaged, or untracked files), append the warning line (shown below) at the end of the guide block.
+**"Design complete and saved to `docs/plans/<filename>.md`. Next step: `/sd-plan` to create the implementation plan."**
 
-```
-Design complete! Here's how to proceed:
-
---- Path A: With branch isolation (recommended for features/large changes) ---
-
-1. /sd-worktree add <name>  — Create a worktree branch
-2. /sd-plan                 — Break into detailed tasks
-3. /sd-plan-dev             — Execute tasks in parallel (includes TDD + review)
-4. /sd-check                — Verify (modified + dependents)
-5. /sd-commit               — Commit
-6. /sd-worktree merge       — Merge back to main
-7. /sd-worktree clean       — Remove worktree
-
---- Path B: Direct on current branch (quick fixes/small changes) ---
-
-1. /sd-plan                 — Break into detailed tasks
-2. /sd-plan-dev             — Execute tasks in parallel (includes TDD + review)
-3. /sd-check                — Verify (modified + dependents)
-4. /sd-commit               — Commit
-
-You can start from any step or skip steps as needed.
-
-💡 "Path A: yolo" or "Path B: yolo" to auto-run all steps
-
-⚠️ You have uncommitted changes. To use Path A, run `/sd-commit all` first.
-```
-
-- The last `⚠️` line is only shown when uncommitted changes exist. Omit it when working tree is clean.
-
-- After presenting both paths, **recommend one** based on the design's scope:
-  - Path A recommended: new features, multi-file changes, architectural changes, anything that benefits from isolation
-  - Path B recommended: small bug fixes, single-file changes, config tweaks, minor adjustments
-  - Briefly explain why (1 sentence)
-- Do NOT auto-proceed to any step. Present the overview with recommendation and wait for the user's choice.
-- **Yolo mode**: If the user responds with "Path A: yolo" or "Path B: yolo" (or similar intent like "A yolo", "B 자동"), execute all steps of the chosen path sequentially without stopping between steps.
-- **Yolo sd-check — include dependents**: NEVER check only modified packages. Also check all packages that depend on them:
-  1. Identify modified packages from `git diff --name-only`
-  2. Trace reverse dependencies (packages that import from modified packages) using `package.json` or project dependency graph
-  3. Include integration/e2e tests that cover the modified packages
-  4. Run `/sd-check` with all affected paths, or `/sd-check` without path (whole project) when changes are widespread
+Do NOT auto-proceed. Wait for the user's explicit instruction.
 
 ## Key Principles
 

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

@@ -1,7 +1,7 @@
 ---
 name: sd-check
 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.
-allowed-tools: Bash(node .claude/skills/sd-check/env-check.mjs), Bash(pnpm typecheck), Bash(pnpm lint --fix), Bash(pnpm vitest), Bash(pnpm lint:fix)
+allowed-tools: Bash(node .claude/skills/sd-check/run-checks.mjs), Bash(pnpm typecheck), Bash(pnpm lint --fix), Bash(pnpm vitest)
 ---
 
 # sd-check
@@ -14,19 +14,18 @@ Verify code quality through parallel execution of typecheck, lint, and test chec
 
 **Foundational Principle:** Violating the letter of these steps is violating the spirit of verification.
 
-When the user asks to verify code, YOU will manually execute **EXACTLY THESE 4 STEPS** (no more, no less):
+When the user asks to verify code, YOU will manually execute **EXACTLY THESE 3 STEPS** (no more, no less):
 
-**Step 1:** Environment Pre-check (4 checks in parallel)
-**Step 2:** Launch 3 background Bash commands 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
+**Step 1:** Run the unified check script (single background command)
+**Step 2:** Collect results, fix errors in priority order
+**Step 3:** Re-verify (go back to Step 1) until all pass
 
 **Core principle:** Always re-run ALL checks after any fix - changes can cascade.
 
 **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
+- Do NOT create your own "better" workflow - follow these 3 steps EXACTLY
 
 ## Usage
 
@@ -37,72 +36,48 @@ When the user asks to verify code, YOU will manually execute **EXACTLY THESE 4 S
 
 ## Quick Reference
 
-| Check | Command | Purpose |
-|-------|---------|---------|
-| Typecheck | `pnpm typecheck [path]` | Type errors |
-| Lint | `pnpm lint --fix [path]` | Code quality |
-| Test | `pnpm vitest [path] --run` | Functionality |
+| Check | Purpose |
+|-------|---------|
+| Typecheck | Type errors |
+| Lint | Code quality (with auto-fix) |
+| Test | Functionality |
 
-**All 3 run in PARALLEL** (background Bash commands, single message)
+**All 3 run in PARALLEL** inside the unified script (single command).
 
 ## Workflow
 
-### Step 1: Environment Pre-check
+### Step 1: Run Unified Check Script
 
-Before ANY verification, run the environment check script:
+Launch the single check command in background:
 
-```bash
-node .claude/skills/sd-check/env-check.mjs
-```
-
-- **Exit 0 + "Environment OK"**: Proceed to Step 2
-- **Exit 1 + version error** (e.g., "simplysm v13+"): Tell the user this project is below v13 so automated checks are unavailable, and they should run typecheck, lint, and test manually. Then STOP — do not proceed to Step 2.
-- **Exit 1 + other errors**: STOP, report the listed errors to user
-
-The script checks: package.json version (v13+), pnpm workspace files, typecheck/lint scripts, vitest config.
-
-### Step 2: Launch 3 Background Bash Commands in Parallel
-
-Launch ALL 3 commands in a **single message** using Bash tool with `run_in_background: true`.
-
-**Replace `[path]` with user's argument, or OMIT if no argument (defaults to full project).**
-
-**Command 1 - Typecheck:**
 ```
 Bash tool:
-  command: "pnpm typecheck [path]"
-  description: "Run typecheck"
-  run_in_background: true
-  timeout: 300000
+  command: "node .claude/skills/sd-check/run-checks.mjs [path]"
+  description: "Run typecheck + lint + test"
+  timeout: 600000
 ```
 
-**Command 2 - Lint:**
-```
-Bash tool:
-  command: "pnpm lint --fix [path]"
-  description: "Run lint with auto-fix"
-  run_in_background: true
-  timeout: 300000
-```
+Replace `[path]` with user's argument, or OMIT if no argument (defaults to full project).
 
-**Command 3 - Test:**
-```
-Bash tool:
-  command: "pnpm vitest [path] --run"
-  description: "Run tests"
-  run_in_background: true
-  timeout: 300000
+**Output format:**
 ```
+====== TYPECHECK: PASS ======
+[last few lines]
 
-Each command returns a `task_id`. Use `TaskOutput` tool to collect results (with `block: true`).
+====== LINT: FAIL ======
+[full error output]
 
-### Step 3: Collect Results and Fix Errors
+====== TEST: PASS (47 tests) ======
+[last few lines]
 
-Collect ALL 3 outputs using `TaskOutput` tool (with `block: true, timeout: 300000`) in a **single message** (parallel calls).
+====== SUMMARY: 1/3 FAILED (lint) ======
+```
 
-**If all checks passed:** Complete (see Completion Criteria).
+- **ENV-CHECK FAIL**: Environment prerequisites missing. Report to user and STOP.
+- **SUMMARY: ALL PASSED**: Complete (see Completion Criteria).
+- **SUMMARY: N/3 FAILED**: Proceed to Step 2.
 
-**If any errors found:**
+### Step 2: Fix Errors
 
 1. **Analyze by priority:** Typecheck → Lint → Test
    - Typecheck errors may cause lint/test errors (cascade)
@@ -118,51 +93,47 @@ Collect ALL 3 outputs using `TaskOutput` tool (with `block: true, timeout: 30000
      - If source bug: Fix source
      - **If root cause unclear OR 2-3 fix attempts failed:** Recommend `/sd-debug`
 
-4. **Proceed to Step 4**
+4. **Proceed to Step 3**
 
-### Step 4: Re-verify (Loop Until All Pass)
+### Step 3: Re-verify (Loop Until All Pass)
 
 **CRITICAL:** After ANY fix, re-run ALL 3 checks.
 
-Go back to Step 2 and launch 3 background Bash commands again.
+Go back to Step 1 and run the unified script again.
 
 **Do NOT assume:** "I only fixed typecheck → skip lint/test". Fixes cascade.
 
-Repeat Steps 2-4 until all 3 checks pass.
+Repeat Steps 1-3 until all 3 checks pass.
 
 ## Common Mistakes
 
-### ❌ Running checks sequentially
-**Wrong:** Launch command 1, wait → command 2, wait → command 3
-**Right:** Launch ALL 3 in single message (parallel background Bash calls)
-
-### ❌ Fixing before collecting all results
-**Wrong:** Command 1 returns error → fix immediately → re-verify
-**Right:** Wait for all 3 → collect all errors → fix in priority order → re-verify
+### Fixing before reading full output
+**Wrong:** See first error in output → fix immediately
+**Right:** Read full SUMMARY → collect all errors → fix in priority order → re-verify
 
-### ❌ Skipping re-verification after fixes
+### Skipping re-verification after fixes
 **Wrong:** Fix typecheck → assume lint/test still pass
-**Right:** ALWAYS re-run all 3 checks after any fix
+**Right:** ALWAYS re-run the script after any fix
 
-### ❌ Using agents instead of background Bash
-**Wrong:** Launch haiku/sonnet/opus agents via Task tool to run commands
+### Using agents instead of background Bash
+**Wrong:** Launch haiku/sonnet/opus agents via Task tool to run the script
 **Right:** Use `Bash` with `run_in_background: true` (no model overhead)
 
-### ❌ Including build/dev steps
+### 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
+### Asking user for path
 **Wrong:** No path provided → ask "which package?"
-**Right:** No path → verify entire project (omit path in commands)
+**Right:** No path → verify entire project (omit path in command)
 
-### ❌ Infinite fix loop
+### Infinite fix loop
 **Wrong:** Keep trying same fix when tests fail repeatedly
 **Right:** After 2-3 failed attempts → recommend `/sd-debug`
 
-### ❌ Claiming success without fresh evidence
+### Claiming success without fresh evidence
 **Wrong:** "All checks should pass now" or "Great, that fixes it!"
-**Right:** Run all 3 → read output → cite results (e.g., "0 errors, 47 tests passed") → THEN claim
+**Right:** Run script → read output → cite results (e.g., "0 errors, 47 tests passed") → THEN claim
 
 ## Red Flags - STOP and Follow Workflow
 
@@ -170,12 +141,10 @@ If you find yourself doing ANY of these, you're violating the skill:
 
 - Treating sd-check as a command to invoke (`Skill: sd-check Args: ...`)
 - Including build or dev server in verification
-- Running commands sequentially instead of parallel
 - Using Task/agent instead of background Bash
 - 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+ commands (only 3: typecheck, lint, test)
 - Expressing satisfaction ("Great!", "Perfect!", "Done!") before all 3 checks pass
 - Using vague language: "should work", "probably passes", "seems fine"
 - Claiming completion based on a previous run, not the current one
@@ -204,8 +173,7 @@ If you find yourself doing ANY of these, you're violating the skill:
 | 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 commands" | Only 3 commands total: typecheck, lint, test |
+| "I'll create a better workflow with teams/tasks" | Follow the 3 steps EXACTLY - no teams, no task lists |
 | "Agents can analyze output better" | Background Bash is sufficient - analysis happens in main context |
 | "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 |
@@ -213,7 +181,6 @@ If you find yourself doing ANY of these, you're violating the skill:
 | "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 commands: typecheck, lint, test, build" | Only 3 commands - build is FORBIDDEN |
-| "I'm confident it passes" | Confidence ≠ evidence — run the check |
+| "I'm confident it passes" | Confidence is not evidence — run the check |
 | "It should work now" | "Should" = no evidence — run the check |
-| "I already verified earlier" | Earlier ≠ now — re-run after every change |
+| "I already verified earlier" | Earlier is not now — re-run after every change |

package/claude/skills/sd-check/run-checks.mjs

@@ -0,0 +1,128 @@
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { spawn } from "child_process";
+
+const root = resolve(import.meta.dirname, "../../..");
+const pathArg = process.argv[2];
+
+// ══════════════════════════════════════════
+// Phase 1: Environment Pre-check
+// ══════════════════════════════════════════
+
+const errors = [];
+
+const pkgPath = resolve(root, "package.json");
+if (!existsSync(pkgPath)) {
+  errors.push("package.json not found");
+} else {
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  const major = parseInt(pkg.version?.split(".")[0], 10);
+  if (Number.isNaN(major) || major < 13) {
+    errors.push(`This skill requires simplysm v13+. Current: ${pkg.version}`);
+  }
+  if (!pkg.scripts?.typecheck) {
+    errors.push("'typecheck' script not defined in package.json");
+  }
+  if (!pkg.scripts?.lint) {
+    errors.push("'lint' script not defined in package.json");
+  }
+}
+
+for (const f of ["pnpm-workspace.yaml", "pnpm-lock.yaml"]) {
+  if (!existsSync(resolve(root, f))) {
+    errors.push(`${f} not found`);
+  }
+}
+
+if (!existsSync(resolve(root, "vitest.config.ts"))) {
+  errors.push("vitest.config.ts not found");
+}
+
+if (errors.length > 0) {
+  console.log("ENV-CHECK FAIL");
+  for (const e of errors) console.log(`- ${e}`);
+  process.exit(1);
+}
+
+// ══════════════════════════════════════════
+// Phase 2: Run 3 checks in parallel
+// ══════════════════════════════════════════
+
+const TAIL_LINES = 15;
+
+function runCommand(name, cmd, args) {
+  return new Promise((res) => {
+    const child = spawn(cmd, args, { cwd: root, shell: true, stdio: "pipe" });
+    const chunks = [];
+
+    child.stdout.on("data", (d) => chunks.push(d));
+    child.stderr.on("data", (d) => chunks.push(d));
+
+    child.on("close", (code) => {
+      const output = Buffer.concat(chunks).toString("utf8");
+      res({ name, code, output });
+    });
+
+    child.on("error", (err) => {
+      res({ name, code: 1, output: err.message });
+    });
+  });
+}
+
+function tail(text, n) {
+  const lines = text.trimEnd().split("\n");
+  if (lines.length <= n) return text.trimEnd();
+  return "...\n" + lines.slice(-n).join("\n");
+}
+
+function extractTestCount(output) {
+  const match =
+    output.match(/(\d+)\s+tests?\s+passed/i) ??
+    output.match(/Tests\s+(\d+)\s+passed/i) ??
+    output.match(/(\d+)\s+pass/i);
+  return match ? match[1] : null;
+}
+
+const checks = [
+  { name: "TYPECHECK", cmd: "pnpm", args: pathArg ? ["typecheck", pathArg] : ["typecheck"] },
+  { name: "LINT", cmd: "pnpm", args: pathArg ? ["lint", "--fix", pathArg] : ["lint", "--fix"] },
+  { name: "TEST", cmd: "pnpm", args: pathArg ? ["vitest", pathArg, "--run"] : ["vitest", "--run"] },
+];
+
+const results = await Promise.all(checks.map((c) => runCommand(c.name, c.cmd, c.args)));
+
+// ══════════════════════════════════════════
+// Output results
+// ══════════════════════════════════════════
+
+const failed = [];
+
+for (const r of results) {
+  const passed = r.code === 0;
+  let label = passed ? "PASS" : "FAIL";
+
+  if (passed && r.name === "TEST") {
+    const count = extractTestCount(r.output);
+    if (count) label = `PASS (${count} tests)`;
+  }
+
+  console.log(`\n${"=".repeat(6)} ${r.name}: ${label} ${"=".repeat(6)}`);
+
+  if (passed) {
+    console.log(tail(r.output, TAIL_LINES));
+  } else {
+    console.log(r.output.trimEnd());
+    failed.push(r.name.toLowerCase());
+  }
+}
+
+console.log();
+if (failed.length === 0) {
+  console.log(`${"=".repeat(6)} SUMMARY: ALL PASSED ${"=".repeat(6)}`);
+} else {
+  console.log(
+    `${"=".repeat(6)} SUMMARY: ${failed.length}/3 FAILED (${failed.join(", ")}) ${"=".repeat(6)}`,
+  );
+}
+
+process.exit(failed.length > 0 ? 1 : 0);

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

@@ -16,6 +16,34 @@ Assume they are a skilled developer, but know almost nothing about our toolset o
 
 **Save plans to:** `docs/plans/YYYY-MM-DD-<feature-name>.md`
 
+## Clarification Phase
+
+**Before writing the plan**, read the design doc and explore the codebase. Then identify implementation decisions the design didn't specify.
+
+**Ask the user about:**
+- Core behavior choices (state management approach, error handling strategy, validation UX)
+- User-facing behavior not specified (what the user sees on error, how navigation works)
+- Architectural choices with multiple valid options (which pattern, which abstraction level)
+
+**Don't ask — just decide:**
+- Internal details covered by project conventions (file naming, export patterns)
+- Pure YAGNI decisions (features not mentioned = don't add)
+- Implementation details with only one reasonable option
+
+**Format:** Present all discovered gaps as a single numbered list with your recommended option for each. Wait for user confirmation before writing the plan.
+
+```
+Before writing the plan, I found these implementation decisions not covered in the design:
+
+1. **[Topic]**: [The gap]. I'd recommend [option A] because [reason]. Alternatively, [option B].
+2. **[Topic]**: [The gap]. I'd recommend [option] because [reason].
+...
+
+Should I proceed with these recommendations, or would you like to change any?
+```
+
+If no gaps are found, skip this phase and proceed directly to writing the plan.
+
 ## Bite-Sized Task Granularity
 
 **Each step is one action (2-5 minutes):**
@@ -96,11 +124,49 @@ git commit -m "feat: add specific feature"
 
 ## Execution Handoff
 
-After saving the plan:
+After saving the plan, present the following workflow paths in the **system's configured language**.
+
+Before presenting, check git status for uncommitted changes. If there are any, append the `⚠️` warning line.
+
+```
+Plan complete! Here's how to proceed:
+
+--- Path A: With branch isolation (recommended for features/large changes) ---
+
+1. /sd-worktree add <name>  — Create a worktree branch
+2. /sd-plan-dev             — Execute tasks in parallel (includes TDD + review)
+3. /sd-check                — Verify (modified + dependents)
+4. /sd-commit               — Commit
+5. /sd-worktree merge       — Merge back to main
+6. /sd-worktree clean       — Remove worktree
+
+--- Path B: Direct on current branch (quick fixes/small changes) ---
+
+1. /sd-plan-dev             — Execute tasks in parallel (includes TDD + review)
+2. /sd-check                — Verify (modified + dependents)
+3. /sd-commit               — Commit
+
+You can start from any step or skip steps as needed.
+
+💡 "Path A: yolo" or "Path B: yolo" to auto-run all steps
+
+⚠️ You have uncommitted changes. To use Path A, run `/sd-commit all` first.
+```
+
+- The `⚠️` line is only shown when uncommitted changes exist. Omit it when working tree is clean.
+- **Recommend one** based on the plan's scope:
+  - Path A: new features, multi-file changes, architectural changes
+  - Path B: small bug fixes, single-file changes, minor adjustments
+  - Briefly explain why (1 sentence)
+- Do NOT auto-proceed. Wait for user's choice.
+
+**Yolo mode:** If the user responds with "Path A: yolo" or "Path B: yolo" (or similar intent like "A yolo", "B 자동"), execute all steps of the chosen path sequentially without stopping between steps.
 
-- If in **yolo mode** (user chose "yolo" from sd-brainstorm): Immediately proceed to sd-plan-dev without asking. No confirmation needed.
-- Otherwise: Display this message **in the system's configured language** (detect from the language setting and translate accordingly):
-  **"Plan complete and saved to `docs/plans/<filename>.md`. Ready to execute with sd-plan-dev?"**
+**Yolo sd-check — include dependents:** NEVER check only modified packages. Also check all packages that depend on them:
+1. Identify modified packages from `git diff --name-only`
+2. Trace reverse dependencies (packages that import from modified packages) using `package.json` or project dependency graph
+3. Include integration/e2e tests that cover the modified packages
+4. Run `/sd-check` with all affected paths, or `/sd-check` without path (whole project) when changes are widespread
 
 - **REQUIRED SUB-SKILL:** Use sd-plan-dev
 - Fresh fork per task + two-stage review (spec compliance → code quality)

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

@@ -1,6 +1,6 @@
 ---
 name: sd-use
-description: Use when user doesn't know which sd-* skill or agent to use and wants automatic selection based on their request
+description: You MUST invoke this for any user request that does not explicitly use a /sd-* slash command. Do not bypass by selecting other sd-* skills directly, even when the match seems obvious.
 model: haiku
 ---
 

package/claude/skills/sd-worktree/sd-worktree.mjs

@@ -46,7 +46,7 @@ switch (cmd) {
     const branch = getMainBranch();
     console.log(`Creating worktree: .worktrees/${name} (from ${branch})`);
     run(`git worktree add "${worktreePath}" -b "${name}"`);
-    console.log("Installing dependencies...");
+    console.log("Installing dependencies...");/
     run("pnpm install", { cwd: worktreePath });
     console.log(`\nReady: ${worktreePath}`);
     break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-claude",
-  "version": "13.0.45",
+  "version": "13.0.47",
   "description": "Simplysm Claude Code CLI — asset installer and cross-platform npx wrapper",
   "author": "김석래",
   "license": "Apache-2.0",

package/claude/skills/sd-check/env-check.mjs

@@ -1,45 +0,0 @@
-import { readFileSync, existsSync } from "fs";
-import { resolve } from "path";
-
-const root = resolve(import.meta.dirname, "../../..");
-const errors = [];
-
-// 1. Root package.json version check
-const pkgPath = resolve(root, "package.json");
-if (!existsSync(pkgPath)) {
-  errors.push("package.json not found");
-} else {
-  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-  const major = parseInt(pkg.version?.split(".")[0], 10);
-  if (Number.isNaN(major) || major < 13) {
-    errors.push(`This skill requires simplysm v13+. Current: ${pkg.version}`);
-  }
-
-  // 3. Scripts check
-  if (!pkg.scripts?.typecheck) {
-    errors.push("'typecheck' script not defined in package.json");
-  }
-  if (!pkg.scripts?.lint) {
-    errors.push("'lint' script not defined in package.json");
-  }
-}
-
-// 2. pnpm workspace files
-for (const f of ["pnpm-workspace.yaml", "pnpm-lock.yaml"]) {
-  if (!existsSync(resolve(root, f))) {
-    errors.push(`${f} not found`);
-  }
-}
-
-// 4. Vitest config
-if (!existsSync(resolve(root, "vitest.config.ts"))) {
-  errors.push("vitest.config.ts not found");
-}
-
-if (errors.length > 0) {
-  console.log("FAIL");
-  for (const e of errors) console.log(`- ${e}`);
-  process.exit(1);
-} else {
-  console.log("Environment OK");
-}