@simplysm/sd-claude 13.0.44 → 13.0.45

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

@@ -54,7 +54,7 @@ Design complete! Here's how to proceed:
 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
+4. /sd-check                — Verify (modified + dependents)
 5. /sd-commit               — Commit
 6. /sd-worktree merge       — Merge back to main
 7. /sd-worktree clean       — Remove worktree
@@ -63,7 +63,7 @@ Design complete! Here's how to proceed:
 
 1. /sd-plan                 — Break into detailed tasks
 2. /sd-plan-dev             — Execute tasks in parallel (includes TDD + review)
-3. /sd-check            — Verify All
+3. /sd-check                — Verify (modified + dependents)
 4. /sd-commit               — Commit
 
 You can start from any step or skip steps as needed.
@@ -81,6 +81,11 @@ You can start from any step or skip steps as needed.
   - 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
 
 ## Key Principles
 

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

@@ -56,9 +56,10 @@ 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
+- **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.
+The script checks: package.json version (v13+), pnpm workspace files, typecheck/lint scripts, vitest config.
 
 ### Step 2: Launch 3 Background Bash Commands in Parallel
 
@@ -159,6 +160,10 @@ Repeat Steps 2-4 until all 3 checks pass.
 **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 all 3 → 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:
@@ -171,19 +176,28 @@ If you find yourself doing ANY of these, you're violating the skill:
 - 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
 
@@ -200,3 +214,6 @@ If you find yourself doing ANY of these, you're violating the skill:
 | "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 |
+| "It should work now" | "Should" = no evidence — run the check |
+| "I already verified earlier" | Earlier ≠ now — re-run after every change |

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

@@ -10,9 +10,9 @@ 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}`);
+  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

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-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/package.json

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