@simplysm/sd-claude 13.0.44 → 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,48 +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 All
-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 All
-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.
+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,71 +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 + "FAIL"**: 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)
@@ -117,81 +93,87 @@ 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
+**Wrong:** "All checks should pass now" or "Great, that fixes it!"
+**Right:** Run script → read output → cite results (e.g., "0 errors, 47 tests passed") → THEN claim
+
 ## Red Flags - STOP and Follow Workflow
 
 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
 
 **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 (typecheck, lint, test) pass without errors
-- Report: "All checks passed - code verified"
+- All 3 checks (typecheck, lint, test) pass without errors **in the most recent run**
+- Report with evidence: "All checks passed" + cite actual output (e.g., "0 errors", "47 tests passed")
+
+**Fresh evidence required:**
+- "Passes" = you ran it THIS iteration and saw it pass in the output
+- Previous run results are NOT evidence for current state
+- Confidence is NOT evidence — run the check
 
 **Do NOT complete if:**
 - Any check has errors
 - Haven't re-verified after a fix
 - Environment pre-checks failed
+- Using "should", "probably", or "seems to" instead of actual output
 
 ## 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 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 |
@@ -199,4 +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 is not evidence — run the check |
+| "It should work now" | "Should" = no evidence — run the check |
+| "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-eml-analyze/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: sd-eml-analyze
+description: Use when user asks to analyze, read, or summarize .eml email files, or when encountering .eml attachments that need content extraction including embedded PDF, XLSX, PPTX files
+---
+
+# EML Email Analyzer
+
+## Overview
+
+Python script that parses .eml files and extracts content from all attachments (PDF, XLSX, PPTX) into a single structured markdown report. Handles Korean encodings (EUC-KR, CP949, ks_c_5601-1987) automatically.
+
+## When to Use
+
+- User provides a `.eml` file to analyze or summarize
+- Need to extract text from email attachments (PDF, XLSX, PPTX)
+- Korean email content needs proper decoding
+
+## Usage
+
+```bash
+python .claude/skills/sd-eml-analyze/eml-analyzer.py <eml_file_path>
+```
+
+First run auto-installs: `pdfminer.six`, `python-pptx`, `openpyxl`.
+
+## Output Format
+
+Markdown report with sections:
+1. **Mail info table**: Subject, From, To, Cc, Date, attachment count
+2. **Body text**: Plain text (HTML stripped if no plain text)
+3. **Attachment analysis**: Summary table + extracted text per file
+
+## Supported Attachments
+
+| Format | Method |
+|--------|--------|
+| PDF | pdfminer.six text extraction |
+| XLSX/XLS | openpyxl cell data as markdown table |
+| PPTX | python-pptx slide text + tables + notes |
+| Text files (.txt, .csv, .json, .xml, .html, .md) | UTF-8/CP949 decode |
+| Images | Filename and size only |
+
+## Common Mistakes
+
+- **Wrong Python**: Ensure `python` points to Python 3.8+
+- **Firewall blocking pip**: First run needs internet for package install
+- **Legacy .ppt/.xls**: Only modern Office formats (.pptx/.xlsx) supported

package/claude/skills/sd-eml-analyze/eml-analyzer.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+"""EML Email Analyzer - Parses EML files and attachments into structured markdown."""
+
+import sys
+import os
+import io
+import subprocess
+import email
+import html
+import re
+import tempfile
+from email.policy import default as default_policy
+from email.header import decode_header
+from pathlib import Path
+
+# stdout UTF-8 강제 (Windows 호환)
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
+sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace")
+
+
+def ensure_packages():
+    """필요한 패키지 자동 설치."""
+    packages = {
+        "pdfminer.six": "pdfminer",
+        "python-pptx": "pptx",
+        "openpyxl": "openpyxl",
+    }
+    missing = []
+    for pip_name, import_name in packages.items():
+        try:
+            __import__(import_name)
+        except ImportError:
+            missing.append(pip_name)
+    if missing:
+        print(f"패키지 설치 중: {', '.join(missing)}...", file=sys.stderr)
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", "-q", *missing],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+
+ensure_packages()
+
+from pdfminer.high_level import extract_text as pdf_extract_text  # noqa: E402
+from pptx import Presentation  # noqa: E402
+from openpyxl import load_workbook  # noqa: E402
+
+
+# ── Korean charset helpers ──────────────────────────────────────────
+
+KOREAN_CHARSET_MAP = {
+    "ks_c_5601-1987": "cp949",
+    "ks_c_5601": "cp949",
+    "euc_kr": "cp949",
+    "euc-kr": "cp949",
+}
+
+
+def fix_charset(charset: str) -> str:
+    if charset is None:
+        return "utf-8"
+    return KOREAN_CHARSET_MAP.get(charset.lower(), charset)
+
+
+# ── EML parsing ─────────────────────────────────────────────────────
+
+
+def parse_eml(filepath: str):
+    with open(filepath, "rb") as f:
+        msg = email.message_from_binary_file(f, policy=default_policy)
+
+    # Headers
+    headers = {
+        "subject": str(msg["Subject"] or ""),
+        "from": str(msg["From"] or ""),
+        "to": str(msg["To"] or ""),
+        "cc": str(msg["Cc"] or ""),
+        "date": str(msg["Date"] or ""),
+    }
+
+    # Body
+    body_plain = ""
+    body_html = ""
+
+    if msg.is_multipart():
+        for part in msg.walk():
+            ctype = part.get_content_type()
+            cdisp = part.get_content_disposition()
+            if cdisp == "attachment":
+                continue
+            if ctype == "text/plain" and not body_plain:
+                body_plain = _get_text(part)
+            elif ctype == "text/html" and not body_html:
+                body_html = _get_text(part)
+    else:
+        body_plain = _get_text(msg)
+
+    # Attachments
+    attachments = []
+    for part in msg.walk():
+        filename = part.get_filename()
+        if not filename:
+            continue
+        cdisp = part.get_content_disposition()
+        if cdisp not in ("attachment", "inline", None):
+            continue
+        payload = part.get_payload(decode=True)
+        if payload is None:
+            continue
+        attachments.append(
+            {
+                "filename": filename,
+                "content_type": part.get_content_type(),
+                "size": len(payload),
+                "data": payload,
+            }
+        )
+
+    return headers, body_plain, body_html, attachments
+
+
+def _get_text(part) -> str:
+    try:
+        return part.get_content()
+    except Exception:
+        payload = part.get_payload(decode=True)
+        if not payload:
+            return ""
+        charset = fix_charset(part.get_content_charset())
+        return payload.decode(charset, errors="replace")
+
+
+# ── Attachment extractors ───────────────────────────────────────────
+
+
+def extract_pdf(data: bytes) -> str:
+    with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as f:
+        f.write(data)
+        tmp = f.name
+    try:
+        text = pdf_extract_text(tmp)
+        return text.strip() if text else "(텍스트 추출 실패)"
+    except Exception as e:
+        return f"(PDF 파싱 오류: {e})"
+    finally:
+        os.unlink(tmp)
+
+
+def extract_pptx(data: bytes) -> str:
+    with tempfile.NamedTemporaryFile(suffix=".pptx", delete=False) as f:
+        f.write(data)
+        tmp = f.name
+    try:
+        prs = Presentation(tmp)
+        slides = []
+        for i, slide in enumerate(prs.slides, 1):
+            lines = [f"#### 슬라이드 {i}"]
+            for shape in slide.shapes:
+                if shape.has_text_frame:
+                    for para in shape.text_frame.paragraphs:
+                        line = "".join(run.text for run in para.runs)
+                        if line.strip():
+                            lines.append(line)
+                if shape.has_table:
+                    header = " | ".join(
+                        cell.text for cell in shape.table.rows[0].cells
+                    )
+                    sep = " | ".join(
+                        "---" for _ in shape.table.rows[0].cells
+                    )
+                    lines.append(f"| {header} |")
+                    lines.append(f"| {sep} |")
+                    for row in list(shape.table.rows)[1:]:
+                        row_text = " | ".join(cell.text for cell in row.cells)
+                        lines.append(f"| {row_text} |")
+            if slide.has_notes_slide:
+                notes = slide.notes_slide.notes_text_frame.text
+                if notes.strip():
+                    lines.append(f"> 노트: {notes}")
+            slides.append("\n".join(lines))
+        return "\n\n".join(slides) if slides else "(텍스트 없음)"
+    except Exception as e:
+        return f"(PPTX 파싱 오류: {e})"
+    finally:
+        os.unlink(tmp)
+
+
+def extract_xlsx(data: bytes) -> str:
+    with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as f:
+        f.write(data)
+        tmp = f.name
+    try:
+        wb = load_workbook(tmp, data_only=True)
+        sheets = []
+        for name in wb.sheetnames:
+            ws = wb[name]
+            lines = [f"#### 시트: {name}"]
+            rows = list(ws.iter_rows(values_only=True))
+            if not rows:
+                lines.append("(데이터 없음)")
+                sheets.append("\n".join(lines))
+                continue
+            # 마크다운 테이블
+            first_row = rows[0]
+            col_count = len(first_row)
+            header = " | ".join(str(c) if c is not None else "" for c in first_row)
+            sep = " | ".join("---" for _ in range(col_count))
+            lines.append(f"| {header} |")
+            lines.append(f"| {sep} |")
+            for row in rows[1:]:
+                vals = " | ".join(str(c) if c is not None else "" for c in row)
+                if any(c is not None for c in row):
+                    lines.append(f"| {vals} |")
+            sheets.append("\n".join(lines))
+        return "\n\n".join(sheets) if sheets else "(데이터 없음)"
+    except Exception as e:
+        return f"(XLSX 파싱 오류: {e})"
+    finally:
+        os.unlink(tmp)
+
+
+def extract_text_file(data: bytes) -> str:
+    for enc in ("utf-8", "cp949", "euc-kr", "latin-1"):
+        try:
+            return data.decode(enc)
+        except (UnicodeDecodeError, LookupError):
+            continue
+    return data.decode("utf-8", errors="replace")
+
+
+# ── HTML stripping ──────────────────────────────────────────────────
+
+
+def strip_html(text: str) -> str:
+    text = re.sub(r"<style[^>]*>.*?</style>", "", text, flags=re.DOTALL | re.I)
+    text = re.sub(r"<script[^>]*>.*?</script>", "", text, flags=re.DOTALL | re.I)
+    text = re.sub(r"<br\s*/?>", "\n", text, flags=re.I)
+    text = re.sub(r"</(?:p|div|tr|li)>", "\n", text, flags=re.I)
+    text = re.sub(r"<[^>]+>", "", text)
+    text = html.unescape(text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+# ── Size formatting ─────────────────────────────────────────────────
+
+
+def fmt_size(n: int) -> str:
+    if n < 1024:
+        return f"{n} B"
+    if n < 1024 * 1024:
+        return f"{n / 1024:.1f} KB"
+    return f"{n / (1024 * 1024):.1f} MB"
+
+
+# ── Markdown report ─────────────────────────────────────────────────
+
+PARSEABLE_EXTS = {".pdf", ".xlsx", ".xls", ".pptx", ".txt", ".csv", ".log", ".json", ".xml", ".html", ".htm", ".md"}
+IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".svg"}
+
+
+def build_report(filepath: str) -> str:
+    headers, body_plain, body_html, attachments = parse_eml(filepath)
+
+    out = []
+    out.append("# 이메일 분석서\n")
+    out.append(f"**원본 파일**: `{os.path.basename(filepath)}`\n")
+
+    # ── 메일 정보
+    out.append("## 메일 정보\n")
+    out.append("| 항목 | 내용 |")
+    out.append("|------|------|")
+    out.append(f"| **제목** | {headers['subject']} |")
+    out.append(f"| **보낸 사람** | {headers['from']} |")
+    out.append(f"| **받는 사람** | {headers['to']} |")
+    if headers["cc"]:
+        out.append(f"| **참조** | {headers['cc']} |")
+    out.append(f"| **날짜** | {headers['date']} |")
+    out.append(f"| **첨부파일** | {len(attachments)}개 |")
+    out.append("")
+
+    # ── 본문
+    out.append("## 본문 내용\n")
+    body = body_plain
+    if not body and body_html:
+        body = strip_html(body_html)
+    out.append(body.strip() if body else "_(본문 없음)_")
+    out.append("")
+
+    # ── 첨부파일
+    if attachments:
+        out.append("## 첨부파일 분석\n")
+        out.append("| # | 파일명 | 형식 | 크기 |")
+        out.append("|---|--------|------|------|")
+        for i, a in enumerate(attachments, 1):
+            out.append(f"| {i} | {a['filename']} | {a['content_type']} | {fmt_size(a['size'])} |")
+        out.append("")
+
+        for i, a in enumerate(attachments, 1):
+            ext = Path(a["filename"]).suffix.lower()
+            out.append(f"### 첨부 {i}: {a['filename']}\n")
+
+            if ext == ".pdf":
+                out.append(extract_pdf(a["data"]))
+            elif ext in (".xlsx", ".xls"):
+                out.append(extract_xlsx(a["data"]))
+            elif ext == ".pptx":
+                out.append(extract_pptx(a["data"]))
+            elif ext == ".ppt":
+                out.append("_(.ppt 레거시 형식 미지원, .pptx만 지원)_")
+            elif ext in (".txt", ".csv", ".log", ".json", ".xml", ".html", ".htm", ".md"):
+                out.append(f"```\n{extract_text_file(a['data'])}\n```")
+            elif ext in IMAGE_EXTS:
+                out.append(f"_(이미지 파일 - {fmt_size(a['size'])})_")
+            else:
+                out.append(f"_(지원하지 않는 형식: {ext}, {fmt_size(a['size'])})_")
+            out.append("")
+
+    return "\n".join(out)
+
+
+# ── Main ────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python eml-analyzer.py <eml_file_path>", file=sys.stderr)
+        sys.exit(1)
+
+    path = sys.argv[1]
+    if not os.path.isfile(path):
+        print(f"파일을 찾을 수 없습니다: {path}", file=sys.stderr)
+        sys.exit(1)
+
+    print(build_report(path))

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-plan-dev/SKILL.md

@@ -90,7 +90,8 @@ digraph process {
     "Re-review failed aspects (parallel sub-Task)" -> "Any issues?";
     "Any issues?" -> "Report results" [label="no"];
     "Report results" -> "More batches?";
-    "More batches?" -> "Implement the task" [label="yes, next batch"];
+    "More batches?" -> "Batch integration check (typecheck + lint)" [label="yes"];
+    "Batch integration check (typecheck + lint)" -> "Implement the task" [label="next batch"];
     "More batches?" -> "Task: final review for entire implementation" [label="no"];
     "Task: final review for entire implementation" -> "Done";
 }
@@ -139,14 +140,16 @@ You are implementing and reviewing Task N: [task name]
 2. Write tests (following TDD if task says to)
 3. Verify implementation works
 4. Self-review: did I implement everything? Did I over-build?
-5. Launch TWO parallel sub-Tasks (spec review + quality review):
+5. Commit your work (record the BASE_SHA before and HEAD_SHA after)
+6. Launch TWO parallel sub-Tasks (spec review + quality review):
    - Sub-Task 1: spec reviewer — send spec-reviewer-prompt.md based prompt
-   - Sub-Task 2: quality reviewer — send code-quality-reviewer-prompt.md based prompt
-6. If either reviewer finds issues → fix them → re-review only failed aspects (parallel sub-Tasks again)
-7. Repeat until both reviewers approve
-8. Report back with: what you implemented, test results, files changed, review outcomes
+   - Sub-Task 2: quality reviewer — send code-quality-reviewer-prompt.md based prompt, include BASE_SHA and HEAD_SHA
+7. If either reviewer finds issues → fix them → re-review only failed aspects (parallel sub-Tasks again)
+8. Repeat until both reviewers approve
+9. Report back with: what you implemented, test results, files changed, commit SHA, review outcomes
 
 If you have questions about requirements — return them immediately WITHOUT implementing. Don't guess.
+If you encounter unexpected issues mid-implementation — ask rather than guess.
 
 Work from: [directory]
 ```
@@ -230,6 +233,17 @@ Final reviewer: All requirements met, ready to merge
 Done!
 ```
 
+## Batch Integration Check
+
+Between batches, run targeted verification on affected packages before starting the next batch:
+
+```bash
+pnpm typecheck [affected packages]
+pnpm lint [affected packages]
+```
+
+This catches cross-task integration issues early — especially when the next batch depends on the current batch's output. Do NOT skip this even if individual task reviews passed.
+
 ## Red Flags
 
 **Never:**
@@ -242,6 +256,7 @@ Done!
 - Skip scene-setting context
 - Accept "close enough" on spec compliance
 - Skip review loops (issue found → fix → re-review)
+- Skip batch integration checks between batches
 
 **If task agent returns questions:**
 - Answer clearly and completely
@@ -253,6 +268,13 @@ Done!
 - Re-review only the failed aspects (parallel sub-Tasks)
 - Repeat until both approved
 
+**If task agent fails or times out:**
+- Do NOT silently proceed — the affected files may be in an indeterminate state
+- Check if other tasks in the same batch depend on the failed task's output
+- Independent tasks' results still stand
+- Escalate to user with specific error details before proceeding
+- Do NOT re-launch on potentially partially-modified files without inspection
+
 ## After Completion
 
 When all tasks and final review are done, if the current working directory is inside a worktree (`.worktrees/`), guide the user to:

package/claude/skills/sd-plan-dev/code-quality-reviewer-prompt.md

@@ -10,9 +10,16 @@ You are reviewing code quality for a completed implementation.
 
 [Paste the implementer's report: files changed, what they built]
 
-## Changed Files
+## Review Scope
 
-[List all files to review]
+Use git diff to review only what changed:
+```
+git diff [BASE_SHA]..[HEAD_SHA]
+```
+BASE_SHA: [commit before task started]
+HEAD_SHA: [implementer's commit SHA from report]
+
+Focus your review on the diff output. Read surrounding code for context only when needed.
 
 ## Your Job
 

package/claude/skills/sd-plan-dev/implementer-prompt.md

@@ -20,24 +20,30 @@ You are implementing Task [N]: [task name]
 
 If anything is unclear about requirements or approach, return your questions under a `## Questions` heading and STOP. Do not guess — do not implement.
 
+## While You Work
+
+If you encounter something unexpected mid-implementation (missing APIs, unexpected patterns, ambiguous behavior), **ask questions rather than guess**. Return your questions under `## Questions` and STOP. It's always OK to pause and clarify.
+
 ## Your Job
 
 1. Implement exactly what the task specifies — nothing more, nothing less
 2. Write tests (follow TDD if the plan says to)
 3. Verify: tests pass, no type errors
 4. Self-review:
-   - Every requirement implemented?
-   - Nothing overbuilt (YAGNI)?
-   - Names clear, code clean?
-   - Following project conventions?
+   - **Completeness**: Every requirement implemented? Edge cases handled?
+   - **Quality**: Names clear? Code clean and maintainable?
+   - **Discipline**: Nothing overbuilt (YAGNI)? Only what was requested?
+   - **Testing**: Tests verify behavior (not implementation)? Comprehensive?
 5. Fix anything found in self-review
-6. Report back
+6. Commit your work with a descriptive message (this is required for review)
+7. Report back
 
 Work from: [directory path]
 
 ## Report
 
 When done, provide:
+- Commit SHA (from step 6)
 - Files created/modified (with brief description of changes)
 - Test results
 - Self-review findings (if any were fixed)

package/claude/skills/sd-plan-dev/spec-reviewer-prompt.md

@@ -20,15 +20,26 @@ Read the ACTUAL CODE. Do NOT trust the report — verify everything independentl
 
 ### Checklist
 
-1. **Every requirement implemented?** Compare spec line by line against code.
-2. **Nothing extra?** Did the implementer build things not in the spec?
-3. **Correct interpretation?** Did they solve the right problem?
-4. **Tests exist?** Do tests verify the specified behavior?
-5. **Exports correct?** New public APIs exported in the package's index.ts?
+Categorize every finding as:
+
+**MISSING** — requirement in spec but absent from code:
+1. Compare spec line by line against code. Every requirement present?
+2. Tests exist for each specified behavior?
+3. New public APIs exported in the package's index.ts?
+
+**EXTRA** — code present but not in spec:
+4. Did the implementer build things not requested? (Public methods, new exports, "nice to have" features)
+5. Private helpers are OK; public API additions without spec approval are not.
+
+**WRONG** — present but incorrectly implemented:
+6. Did they solve the right problem? Correct interpretation of requirements?
+7. Do test assertions match spec expectations (not just implementation behavior)?
 
 ### Report
 
-- ✅ APPROVED — all requirements verified in code
+- ✅ APPROVED — all requirements verified in code, nothing extra
 - ❌ CHANGES_NEEDED:
-  - [What's missing/wrong/extra — with file:line references]
+  - MISSING: [requirement not implemented] (file:line)
+  - EXTRA: [built but not requested] (file:line)
+  - WRONG: [incorrect interpretation] (file:line)
 ```

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.44",
+  "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 = pkg.version?.split(".")[0];
-  if (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");
-}