@simplysm/sd-claude 13.0.77 → 13.0.80

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

@@ -4,7 +4,6 @@
 import sys
 import os
 import io
-import subprocess
 import email
 import html
 import re
@@ -19,6 +18,7 @@ sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="repla
 
 def ensure_packages():
     """Auto-install required packages."""
+    import subprocess
     packages = {"extract-msg": "extract_msg"}
     missing = []
     for pip_name, import_name in packages.items():
@@ -35,11 +35,6 @@ def ensure_packages():
         )
 
 
-ensure_packages()
-
-import extract_msg  # noqa: E402
-
-
 # ── Korean charset helpers ──────────────────────────────────────────
 
 KOREAN_CHARSET_MAP = {
@@ -81,39 +76,38 @@ def _parse_eml(filepath):
 
     body_plain = ""
     body_html = ""
+    attachments = []
+    inline_images = []
+    seen_cids = set()
 
-    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_eml(part)
-            elif ctype == "text/html" and not body_html:
-                body_html = _get_text_eml(part)
-    else:
+    if not msg.is_multipart():
         ctype = msg.get_content_type()
         if ctype == "text/html":
             body_html = _get_text_eml(msg)
         else:
             body_plain = _get_text_eml(msg)
-
-    attachments = []
-    inline_images = []
-    seen_cids = set()
+        return headers, body_plain, body_html, attachments, inline_images
 
     for part in msg.walk():
+        ctype = part.get_content_type()
+        cdisp = part.get_content_disposition()
         payload = part.get_payload(decode=True)
+
+        # Body extraction (non-attachment text parts)
+        if cdisp != "attachment" and payload is not None:
+            if ctype == "text/plain" and not body_plain:
+                body_plain = _get_text_eml(part)
+            elif ctype == "text/html" and not body_html:
+                body_html = _get_text_eml(part)
+
         if payload is None:
             continue
 
         content_id = (part.get("Content-ID") or "").strip("<> ")
-        ctype = part.get_content_type()
         filename = part.get_filename()
 
-        # Inline image: Content-ID + image type
-        if content_id and ctype.startswith("image/"):
+        # Inline image
+        if _is_inline_image(content_id, ctype):
             if content_id not in seen_cids:
                 seen_cids.add(content_id)
                 ext = _guess_image_ext(ctype, filename)
@@ -126,10 +120,9 @@ def _parse_eml(filepath):
                 })
             continue
 
-        # Regular attachment: has filename
+        # Regular attachment
         if not filename:
             continue
-        cdisp = part.get_content_disposition()
         if cdisp not in ("attachment", "inline", None):
             continue
         attachments.append({
@@ -143,6 +136,9 @@ def _parse_eml(filepath):
 
 
 def _parse_msg(filepath):
+    ensure_packages()
+    import extract_msg
+
     msg = extract_msg.openMsg(filepath)
     try:
         headers = {
@@ -186,7 +182,7 @@ def _parse_msg(filepath):
                 "data": data,
             }
 
-            if cid and mimetype.startswith("image/"):
+            if _is_inline_image(cid, mimetype):
                 entry["content_id"] = cid.strip("<> ")
                 inline_images.append(entry)
             else:
@@ -224,6 +220,25 @@ def _guess_image_ext(content_type, filename=None):
     return mapping.get(content_type, ".bin")
 
 
+def _is_inline_image(content_id, content_type):
+    """Check if a MIME part is an inline image (has Content-ID + image MIME type)."""
+    return bool(content_id) and content_type.startswith("image/")
+
+
+# ── Pre-compiled regexes ───────────────────────────────────────────
+
+_RE_DATA_URI = re.compile(
+    r'<img[^>]+src=["\']data:image/([^;]+);base64,([^"\']+)["\']',
+    re.IGNORECASE,
+)
+_RE_STYLE = re.compile(r"<style[^>]*>.*?</style>", re.DOTALL | re.I)
+_RE_SCRIPT = re.compile(r"<script[^>]*>.*?</script>", re.DOTALL | re.I)
+_RE_BR = re.compile(r"<br\s*/?>", re.I)
+_RE_BLOCK_CLOSE = re.compile(r"</(?:p|div|tr|li)>", re.I)
+_RE_TAG = re.compile(r"<[^>]+>")
+_RE_MULTI_NEWLINE = re.compile(r"\n{3,}")
+
+
 # ── File saving ────────────────────────────────────────────────────
 
 
@@ -232,10 +247,10 @@ def save_files(files, output_dir):
     os.makedirs(output_dir, exist_ok=True)
     result = []
     for f in files:
+        stem = Path(f["filename"]).stem
+        ext = Path(f["filename"]).suffix
         filepath = os.path.join(output_dir, f["filename"])
         if os.path.exists(filepath):
-            stem = Path(filepath).stem
-            ext = Path(filepath).suffix
             n = 1
             while os.path.exists(filepath):
                 filepath = os.path.join(output_dir, f"{stem}_{n}{ext}")
@@ -248,44 +263,41 @@ def save_files(files, output_dir):
 
 def extract_data_uri_images(html_body, output_dir):
     """Extract base64 data URI images embedded in HTML body."""
-    pattern = r'<img[^>]+src=["\']data:image/([^;]+);base64,([^"\']+)["\']'
-    matches = re.findall(pattern, html_body, re.IGNORECASE)
+    matches = _RE_DATA_URI.findall(html_body)
     if not matches:
         return []
 
-    os.makedirs(output_dir, exist_ok=True)
     images = []
     for i, (img_type, b64data) in enumerate(matches, 1):
         try:
             data = base64.b64decode(b64data)
-            ext_map = {"jpeg": ".jpg", "svg+xml": ".svg"}
-            ext = ext_map.get(img_type, f".{img_type}")
-            filename = f"datauri_{i}{ext}"
-            filepath = os.path.join(output_dir, filename)
-            with open(filepath, "wb") as f:
-                f.write(data)
+            content_type = f"image/{img_type}"
+            ext = _guess_image_ext(content_type)
             images.append({
-                "filename": filename,
-                "content_type": f"image/{img_type}",
+                "filename": f"datauri_{i}{ext}",
+                "content_type": content_type,
                 "size": len(data),
-                "saved_path": filepath,
+                "data": data,
             })
         except Exception:
             continue
-    return images
+
+    if not images:
+        return []
+    return save_files(images, output_dir)
 
 
 # ── HTML stripping ──────────────────────────────────────────────────
 
 
 def strip_html(text):
-    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 = _RE_STYLE.sub("", text)
+    text = _RE_SCRIPT.sub("", text)
+    text = _RE_BR.sub("\n", text)
+    text = _RE_BLOCK_CLOSE.sub("\n", text)
+    text = _RE_TAG.sub("", text)
     text = html.unescape(text)
-    text = re.sub(r"\n{3,}", "\n\n", text)
+    text = _RE_MULTI_NEWLINE.sub("\n\n", text)
     return text.strip()
 
 
@@ -303,6 +315,23 @@ def fmt_size(n):
 # ── Markdown report ─────────────────────────────────────────────────
 
 
+def _render_file_table(title, items):
+    """Render a Markdown table of files with #, Filename, Size, Saved path columns."""
+    if not items:
+        return []
+    lines = [
+        f"## {title}\n",
+        "| # | Filename | Size | Saved path |",
+        "|---|--------|------|-----------|",
+    ]
+    for i, item in enumerate(items, 1):
+        lines.append(
+            f"| {i} | {item['filename']} | {fmt_size(item['size'])} | `{item['saved_path']}` |"
+        )
+    lines.append("")
+    return lines
+
+
 def build_report(filepath):
     headers, body_plain, body_html, attachments, inline_images = parse_email(filepath)
 
@@ -352,23 +381,8 @@ def build_report(filepath):
     out.append(body.strip() if body else "_(No body)_")
     out.append("")
 
-    # ── Inline images
-    if all_inline:
-        out.append("## Inline Images\n")
-        out.append("| # | Filename | Size | Saved path |")
-        out.append("|---|--------|------|-----------|")
-        for i, img in enumerate(all_inline, 1):
-            out.append(f"| {i} | {img['filename']} | {fmt_size(img['size'])} | `{img['saved_path']}` |")
-        out.append("")
-
-    # ── Attachments
-    if saved_attachments:
-        out.append("## Attachments\n")
-        out.append("| # | Filename | Size | Saved path |")
-        out.append("|---|--------|------|-----------|")
-        for i, a in enumerate(saved_attachments, 1):
-            out.append(f"| {i} | {a['filename']} | {fmt_size(a['size'])} | `{a['saved_path']}` |")
-        out.append("")
+    out.extend(_render_file_table("Inline Images", all_inline))
+    out.extend(_render_file_table("Attachments", saved_attachments))
 
     return "\n".join(out)
 

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

@@ -0,0 +1,133 @@
+---
+name: sd-init
+description: "초기화", "init", "sd-init", "CLAUDE.md 생성" 등을 요청할 때 사용.
+---
+
+# SD Init — CLAUDE.md 자동 생성
+
+프로젝트를 분석하여 CLAUDE.md를 자동 생성한다. 기존 파일이 있으면 덮어쓴다.
+
+---
+
+## Step 1: 패키지 매니저 감지
+
+프로젝트 루트의 lock 파일로 PM을 판별하라:
+
+1. `pnpm-lock.yaml` → pnpm
+2. `yarn.lock` → yarn
+3. 그외 → npm
+
+## Step 2: 스크립트 분석
+
+`package.json`의 `scripts`를 읽고, 각 스크립트가 호출하는 CLI 도구에 대해 Bash로 `--help`등의 도움말 보기를 실행하여 사용 가능한 인자와 플래그를 파악하라.
+
+파악한 정보를 바탕으로 스크립트를 카테고리별(개발, 빌드, 테스트, 린트 등)로 그룹화하고, 각 스크립트의 기본 사용법과 주요 플래그 예시를 정리하라.
+
+## Step 3: 코딩 규칙 분석
+
+프로젝트 루트에서 아래 설정 파일들을 찾아 읽어라 (존재하는 것만):
+
+- ESLint: `eslint.config.*`, `.eslintrc.*`, `packages/*/eslint.*` 등
+- Prettier: `.prettierrc*`, `prettier.config.*`
+- EditorConfig: `.editorconfig`
+- TypeScript: `tsconfig.json` (루트)의 `compilerOptions` 중 `strict`, `noImplicitAny` 등 코드 스타일에 영향을 주는 옵션
+- Stylelint: `.stylelintrc*`, `stylelint.config.*`
+
+Claude가 규칙과 반대로 수정하기를 제안할 정도의 자주 실수할 내용들만 대폭 간결하게 정리하라.
+
+## Step 4: CLAUDE.md 생성
+
+아래 정보를 종합하여 프로젝트 루트에 `CLAUDE.md`를 작성하라:
+
+- **프로젝트 정보**: `package.json`의 `name`, `description`
+- **PM**: Step 1에서 감지한 패키지 매니저
+- **모노레포 구조**: `workspaces` 필드 또는 `pnpm-workspace.yaml`이 있으면 워크스페이스 경로를 간단히 기술
+- **기술스택**: `dependencies`/`devDependencies`에서 주요 기술(프레임워크, 번들러, 테스트 도구 등)을 파악하여 아주 간단히 기술
+- **명령어**: Step 2에서 정리한 스크립트 사용법
+- **코딩 규칙**: Step 3에서 분석한 규칙 중 Claude가 지켜야 할 것들. `## 코딩 규칙` 섹션으로 작성
+
+### 참고 예시
+
+아래는 잘 작성된 CLAUDE.md의 예시다. 형식을 그대로 복사하지 말고, 프로젝트 특성에 맞게 유연하게 작성하라.
+
+```markdown
+# Simplysm
+
+pnpm 모노레포. 패키지 경로: `packages/*`, 테스트: `tests/*`
+
+## 명령어
+
+모든 명령어는 내부적으로 `pnpm sd-cli <명령>`을 실행한다. 모든 명령에 `--debug` 플래그 사용 가능.
+`[targets..]`를 지정하지 않으면 `sd.config.ts`에 정의된 전체 패키지 대상으로 실행된다.
+타겟은 패키지 경로로 지정한다 (예: `packages/core-common`, `tests/orm`).
+
+### 개발
+
+​```bash
+pnpm dev [targets..]                     # client+server 패키지 개발 모드 실행
+pnpm dev packages/solid-demo             # 특정 패키지만 dev 모드
+pnpm dev -o key=value                    # sd.config.ts에 옵션 전달
+
+pnpm watch [targets..]                   # 라이브러리 패키지 빌드 워치 모드
+pnpm watch packages/core-common          # 특정 패키지만 워치
+​```
+
+### 빌드 & 배포
+
+​```bash
+pnpm build [targets..]                   # 프로덕션 빌드
+pnpm build packages/solid                # 특정 패키지만 빌드
+
+pnpm pub [targets..]                     # 빌드 후 배포 (npm/sftp)
+pnpm pub --no-build                      # 빌드 생략하고 배포만
+pnpm pub --dry-run                       # 실제 배포 없이 시뮬레이션
+​```
+
+### 코드 품질 검사
+
+​```bash
+pnpm typecheck [targets..]               # TypeScript 타입 체크
+pnpm lint [targets..]                    # ESLint + Stylelint 실행
+pnpm lint:fix [targets..]               # 린트 자동 수정 (--fix)
+pnpm check [targets..]                   # 전체 검사 (typecheck + lint + test 병렬)
+pnpm vitest [targets..]                  # vitest 워치 모드
+pnpm vitest run [targets..]              # 테스트 1회 실행
+​```
+
+## 아키텍처
+
+의존 방향: 위 → 아래. `core-common`은 내부 의존 없는 leaf 패키지.
+
+​```
+Apps:     solid-demo (client) / solid-demo-server (server)
+UI:       solid (SolidJS + Tailwind)
+Service:  service-server (Fastify) / service-client / service-common
+ORM:      orm-node (MySQL/PostgreSQL/MSSQL) / orm-common
+Core:     core-common (neutral) / core-browser / core-node
+Tools:    sd-cli, lint, excel, storage, sd-claude, mcp-playwright
+​```
+
+
+## 통합 테스트
+
+`tests/` 폴더에 위치. `pnpm vitest run tests/orm` 등으로 실행.
+
+- `tests/orm` — DB 커넥션, DbContext, 이스케이프 테스트 (MySQL, PostgreSQL, MSSQL). Docker 필요.
+- `tests/service` — 서비스 클라이언트-서버 통신 테스트.
+
+## 코딩 규칙
+
+- `import type` 필수 (`verbatimModuleSyntax`), `#private` 금지 → `private` 사용                                                                             
+- `console.*` 금지, `if (str)` 금지 → `str !== ""` 명시 비교 (nullable boolean/object는 허용)                                                               
+- `Buffer` 금지 → `Uint8Array`, `events` 금지 → `@simplysm/core-common`의 `EventEmitter`                                                                    
+- SolidJS: props 구조 분해 금지, `.map()` 대신 `<For>`, `className` 대신 `class`                                                                            
+- Prettier: 100자, 2칸 스페이스, 세미콜론, trailing comma, LF
+```
+
+## Step 5: 완료 안내
+
+생성이 완료되면 아래를 출력하라:
+
+```
+CLAUDE.md가 생성되었습니다. 커밋하려면 /sd-commit 을 실행하세요.
+```

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

@@ -1,154 +1,103 @@
 ---
 name: sd-plan
-description: "Implementation plan from brainstorm designs (explicit invocation only)"
+description: 이 스킬은 사용자가 "계획 세워줘", "plan 만들어", "sd-plan", "구현 계획", "작업 계획" 등을 요청할 때 사용한다.
 ---
 
-# Writing Plans
+# SD Plan — 명확한 계획서 생성
 
-## Prerequisite Check
-
-**MANDATORY:** Before proceeding, verify that `sd-brainstorm` has already been completed in this conversation.
-
-- If a brainstorm design document exists (discussed or saved in this session) → proceed.
-- If NOT → **STOP** and tell the user (in the system's configured language) that sd-plan requires sd-brainstorm to be completed first, then invoke sd-brainstorm instead.
-
-## Overview
-
-Write comprehensive implementation plans assuming the engineer has zero context for our codebase and questionable taste. Document everything they need to know: which files to touch for each task, code, testing, docs they might need to check, how to test it. Give them the whole plan as bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.
-
-Assume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.
-
-When a task uses a codebase-specific utility (hook, helper, style token) or test pattern, add a one-line explanation of what it does and the source file path. Example: "`createMountTransition(open)` — manages mount/unmount with CSS transitions (`packages/solid/src/hooks/createMountTransition.ts`)". This applies to test utilities and patterns too — if a test uses a framework-specific pattern (e.g., SolidJS `createRoot` for reactive context), explain why that pattern is needed.
-
-**Announce at start:** "I'm using the sd-plan skill to create the implementation plan."
-
-**Save plans to:** `docs/plans/YYYY-MM-DD-<feature-name>.md`
-
-## Bite-Sized Task Granularity
-
-**Each step is one action (2-5 minutes):**
-- "Write the failing test" - step
-- "Run it to make sure it fails" - step
-- "Implement the minimal code to make the test pass" - step
-- "Run the tests and make sure they pass" - step
-- "Commit" - step
-
-**Step size limit:** If a single step produces more than ~30 lines of code, it is too large. Split it into multiple steps (e.g., "Define types and interfaces" → "Create context and hook" → "Implement provider component").
-
-**TDD means YAGNI per step:** Step 3 ("Write minimal implementation") must implement ONLY what's needed to pass Step 1's test — nothing more. If the component needs additional behavior (e.g., FIFO eviction, remove), that behavior goes in a SUBSEQUENT task with its own failing test first. Do NOT implement the full component in one task and then test it after the fact.
-
-## Task Ordering
-
-**Shared resources BEFORE consumers.** Tasks must be ordered so that every file a task imports already exists from a prior task.
-
-- Types, config, i18n entries → before components that use them
-- Provider → before components that call useX() hooks
-- If Task B imports from Task A's file → Task A must come first
-
-## Plan Document Header
-
-**Every plan MUST start with this header:**
-
-```markdown
-# [Feature Name] Implementation Plan
-
-> **For Claude:** REQUIRED SUB-SKILL: Use sd-plan-dev to implement this plan task-by-task.
-
-**Goal:** [One sentence describing what this builds]
-
-**Architecture:** [2-3 sentences about approach]
-
-**Tech Stack:** [Key technologies/libraries]
+사용자의 작업 요청을 받아 초기 계획서를 생성한 뒤, 불명확한 부분을 반복적으로 검토하고 질문하여 완벽히 명확한 계획서를 만든다.
 
 ---
-```
 
-## Package Manager Detection
+## Step 1: 입력 확인
 
-When writing run commands in the plan, detect the package manager:
-- If `pnpm-lock.yaml` exists in project root → use `pnpm`
-- If `yarn.lock` exists in project root → use `yarn`
-- Otherwise → use `npm`
+- 작업 설명을 아래 우선순위로 확보하라:
+  1. **작업 요청**: 사용자가 스킬 호출 시 함께 전달한 작업 설명
+  2. **현재 대화**: 작업 요청이 없으면 현재 대화 컨텍스트에서 작업 내용을 파악
+  3. **AskUserQuestion**: 위 둘로도 파악이 안 되면 "어떤 작업에 대한 계획서를 만들까요? 작업 내용을 설명해 주세요."라고 질문
+- 충분한 작업 설명을 확보한 후 Step 2로 진행하라.
 
-`$PM` in the task template below refers to the detected package manager.
+---
 
-## Task Structure
+## Step 2: 계획서 생성 + 명확화 반복
 
-```markdown
-### Task N: [Component Name]
+### 2-1. 초안 작성
 
-**Files:**
-- Create: `exact/path/to/file.ts`
-- Modify: `exact/path/to/existing.ts:123-145`
-- Test: `exact/path/to/tests/file.spec.ts`
+계획서 초안을 작성하라. 각 구현 단계는 **검증 → 구현 → 확인** 순서로 배치하라:
+- 테스트 프레임워크가 있으면 → 테스트 코드 먼저 작성
+- 테스트 프레임워크가 없으면 → CLI 실행, dry-run 등 검증 방법 명시
+- 비코드 작업이면 → 자체 검증 체크리스트 먼저 정의
 
-**Step 1: Write the failing test**
+### 2-2. 명확화 사이클
 
-```typescript
-test("specific behavior", () => {
-  const result = functionUnderTest(input);
-  expect(result).toBe(expected);
-});
-```
+아래를 **불명확 항목이 0개가 될 때까지** 반복하라:
 
-**Step 2: Run test to verify it fails**
+1. **추출**: 계획서를 아래 "불명확 판단 기준" 12개 항목에 전부 대조하여 불명확 항목을 나열하라.
+2. **의존성 분석**: 항목 간 의존 관계를 파악하라. ("A가 정해져야 B를 질문 가능" → B는 A에 의존)
+3. **질문**: 의존 대상이 없는 항목들을 AskUserQuestion 도구 **하나당 단 하나의 질문**만 하라. 각 질문에 2~5개 선택지를 제시하라.
+4. **반영**: 답변을 모두 반영하여 계획서를 업데이트하고, 1번으로 돌아가라.
 
-Run: `$PM run vitest exact/path/to/tests/file.spec.ts --run`
-Expected: FAIL with "functionUnderTest is not defined"
+불명확 항목 0개 → **Step 2.5 최종 검증**으로 이동.
 
-**Step 3: Write minimal implementation**
+### 불명확 판단 기준
 
-```typescript
-function functionUnderTest(input: InputType): OutputType {
-  return expected;
-}
-```
+> **핵심 원칙**: 사용자가 명시하지 않았고, 코드베이스에서 확인되지 않은 것은 **모두 추측/가정으로 간주**하여 불명확 항목으로 취급하라. Claude가 자신있게 작성했더라도 출처가 불분명하면 불명확이다.
 
-**Step 4: Run test to verify it passes**
+아래 12개 항목을 **매 검토 시 전부** 대조하라. "해당 없음"이라고 넘기려면 구체적 근거(사용자 발언 또는 코드베이스 확인)가 있어야 한다.
 
-Run: `$PM run vitest exact/path/to/tests/file.spec.ts --run`
-Expected: PASS
+1. **사용자 미명시 가정**: 사용자가 말하지 않았는데 Claude가 채워넣은 결정사항
+2. **구체성 부족**: HOW 없이 "적절히 처리", "필요에 따라" 등의 표현
+3. **범위 모호**: IN/OUT 스코프가 정의되지 않음
+4. **미지정 동작**: 에러, 유효하지 않은 입력, 기본값 등이 지정되지 않음
+5. **알 수 없는 제약조건**: 성능, 호환성, 플랫폼 요구사항이 불분명
+6. **누락된 엣지케이스**: 경계 조건, 동시성, 빈 상태 등
+7. **모호한 파일/함수 참조**: 구체적 경로 없이 "관련 파일을 수정" 등
+8. **불명확한 순서/의존성**: 단계 간 선후 관계 미명시
+9. **추측 표현**: "아마", "~일 수 있음", "TBD", "???" 등
+10. **통합 세부사항 누락**: API 계약, 데이터 형식, 인터페이스 미정의
+11. **실패/롤백 전략 부재**: 실패 시 대응 방안 없음
+12. **검증 방법 미정의**: 구현 단계에 대응하는 검증 방법이 없음
 
-**Step 5: Commit**
+---
 
-```bash
-git add exact/path/to/tests/file.spec.ts exact/path/to/file.ts
-git commit -m "feat: add specific feature"
-```
-```
+## Step 2.5: 최종 검증 (불명확 없음 선언 전 필수)
 
-## Test Requirement
+"불명확 없음"을 선언하기 **직전에 반드시** 아래를 수행하라:
 
-**Every task that creates or modifies logic MUST include a test.** No exceptions.
+1. 계획서의 **모든 단계를 처음부터 끝까지** 다시 읽으며, 위 12개 기준을 한 번 더 전수 대조하라.
+2. 특히 다음을 집중 확인하라:
+   - Claude가 스스로 결정한 부분 중 사용자 확인을 받지 않은 것이 있는가?
+   - "~한다", "~로 처리한다" 등 단정적으로 쓴 부분의 근거가 사용자 발언 또는 코드베이스에 있는가?
+   - 구체적 파일 경로, 함수명, 데이터 구조가 빠진 곳은 없는가?
+3. 이 검증에서 **하나라도** 불명확 항목이 발견되면 Step 2의 질문 사이클로 돌아가라.
+4. 진짜로 없으면 → Step 3으로 이동.
 
-- If the logic is testable with unit tests → write a vitest test file. This includes: pure functions, state management, timers/lifecycle logic (use `vi.useFakeTimers()`), event handlers, and state transitions.
-- If the logic is UI-only (visual rendering, Portal placement, CSS animation) → include a manual verification step with exact instructions ("Open the browser, click X, expect Y")
-- The **Files:** section must list the test file: `Test: exact/path/to/tests/file.spec.ts`
-- If you find yourself writing a task with no test step → **STOP and add one**
+---
 
-## Remember
-- Exact file paths always
-- Cross-check the design document's file structure — every file listed in the design MUST appear in the plan (create or modify)
-- Complete code in plan (not "add validation")
-- When modifying an existing file, show ALL necessary import additions/changes — not just the appended code
-- Code must compile cleanly — no unused imports or variables
-- Exact commands with expected output
-- DRY, YAGNI, TDD, frequent commits
+## Step 3: 최종 출력
 
-## Related Skills
+모든 불명확 항목이 해소되었으면 완성된 계획서를 사용자에게 제시하고, AskUserQuestion으로 구현 승인을 요청하라.
 
-- **sd-brainstorm** — prerequisite: creates the design this skill plans from
-- **sd-plan-dev** — executes the plan this skill creates
+사용자가 승인하면 `.tmp/plans/{yyMMddHHmmss}_{topic}.md`에 계획서를 Write하라.
+- 파일명 예시: `260311143052_progress-컴포넌트-추가.md`
+- `yyMMddHHmmss`: 연월일시분초 (예: 260311143052)
+- `{topic}`: 작업 내용 기반 짧은 케밥케이스 (예: progress-컴포넌트-추가)
 
-## Execution Handoff
+---
 
-After saving the plan, **commit the plan document to git** before proceeding.
+## Step 4: 구현 완료 후 안내
 
-Then:
+사용자가 구현을 승인하면, 계획서에 따라 구현하라. 구현이 완료되면 아래 안내를 출력하라:
 
-- 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?"**
+- **코드 수정이 포함된 경우**:
+  ```
+  구현이 완료되었습니다. 다음 단계를 순서대로 실행하는 것을 권장합니다:
+  1. /sd-check — 타입체크 + 린트 + 테스트 검사 및 자동 수정
+  2. /sd-simplify — 변경된 코드 단순화 리뷰
+  3. /sd-commit — 변경사항 커밋
+  ```
 
-- **REQUIRED SUB-SKILL:** Use sd-plan-dev
-- Fresh fork per task + two-stage review (spec compliance → code quality)
+- **코드 수정이 없는 경우** (설정, 문서 등):
+  ```
+  구현이 완료되었습니다. 커밋하려면 /sd-commit 을 실행하세요.
+  ```