sdd-tool 1.0.1 → 1.1.0

package/dist/cli/index.js

@@ -130,10 +130,10 @@ var init_base = __esm({
     };
     FileSystemError = class extends SddError {
       path;
-      constructor(code, path42) {
-        super(code, formatMessage(code, path42), ExitCode.FILE_SYSTEM_ERROR);
+      constructor(code, path44) {
+        super(code, formatMessage(code, path44), ExitCode.FILE_SYSTEM_ERROR);
         this.name = "FileSystemError";
-        this.path = path42;
+        this.path = path44;
       }
     };
     ValidationError = class extends SddError {
@@ -1216,7 +1216,7 @@ var init_checklist = __esm({
 });
 
 // src/core/new/counter.ts
-import path11 from "path";
+import path13 from "path";
 function getDefaultCounterData() {
   return {
     nextFeatureNumber: 1,
@@ -1225,7 +1225,7 @@ function getDefaultCounterData() {
   };
 }
 function getCounterPath(sddPath) {
-  return path11.join(sddPath, "counter.json");
+  return path13.join(sddPath, "counter.json");
 }
 async function readCounter(sddPath) {
   const counterPath = getCounterPath(sddPath);
@@ -1413,7 +1413,8 @@ import { createRequire } from "module";
 // src/cli/commands/init.ts
 init_fs();
 init_errors();
-import path2 from "path";
+import path4 from "path";
+import readline from "readline";
 
 // src/utils/logger.ts
 var logger_exports = {};
@@ -1624,9 +1625,47 @@ function generateClaudeCommands() {
 
 ## \uC9C0\uC2DC\uC0AC\uD56D
 
-1. \`sdd start\` \uBA85\uB839\uC5B4\uB97C \uC2E4\uD589\uD558\uC5EC \uD504\uB85C\uC81D\uD2B8 \uC0C1\uD0DC\uB97C \uD655\uC778\uD558\uC138\uC694
-2. \uC81C\uC2DC\uB418\uB294 \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uBA54\uB274\uC5D0\uC11C \uC801\uC808\uD55C \uC791\uC5C5\uC744 \uC120\uD0DD\uD558\uC138\uC694
-3. \uAC01 \uC6CC\uD06C\uD50C\uB85C\uC6B0\uC758 \uC548\uB0B4\uC5D0 \uB530\uB77C \uC9C4\uD589\uD558\uC138\uC694
+1. \uBA3C\uC800 \uD504\uB85C\uC81D\uD2B8 \uAD6C\uC870\uB97C \uBD84\uC11D\uD558\uC138\uC694:
+   - .sdd/ \uB514\uB809\uD1A0\uB9AC \uC874\uC7AC \uC5EC\uBD80 \uD655\uC778
+   - .git/ \uB514\uB809\uD1A0\uB9AC \uC874\uC7AC \uC5EC\uBD80 \uD655\uC778
+   - .git/hooks/ \uB514\uB809\uD1A0\uB9AC\uC758 SDD \uD6C5 \uC124\uCE58 \uC5EC\uBD80 \uD655\uC778
+   - .github/workflows/ \uB514\uB809\uD1A0\uB9AC\uC758 SDD \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC874\uC7AC \uC5EC\uBD80 \uD655\uC778
+
+2. \uBD84\uC11D \uACB0\uACFC\uC5D0 \uB530\uB77C \uC0AC\uC6A9\uC790\uC5D0\uAC8C \uC548\uB0B4\uD558\uC138\uC694:
+   - SDD \uBBF8\uCD08\uAE30\uD654: \`sdd init\` \uC2E4\uD589 \uAD8C\uC7A5
+   - Git Hooks \uBBF8\uC124\uCE58: Git \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC124\uC815 \uAD8C\uC7A5
+   - CI/CD \uBBF8\uC124\uC815: GitHub Actions \uC124\uC815 \uAD8C\uC7A5
+
+3. \uC124\uC815\uC774 \uD544\uC694\uD55C \uACBD\uC6B0 \uC0AC\uC6A9\uC790\uC5D0\uAC8C **\uC9C8\uBB38**\uD558\uACE0 **\uC2B9\uC778**\uC744 \uBC1B\uC740 \uD6C4 \uC2E4\uD589\uD558\uC138\uC694
+
+## Git \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC124\uC815 \uD655\uC778
+
+\uB2E4\uC74C \uBA85\uB839\uC5B4\uB85C \uD504\uB85C\uC81D\uD2B8 \uC0C1\uD0DC\uB97C \uD655\uC778\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4:
+
+\`\`\`bash
+# \uD504\uB85C\uC81D\uD2B8 \uC0C1\uD0DC \uD655\uC778
+sdd status
+
+# Git \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC124\uC815
+sdd git setup
+
+# CI/CD \uC124\uC815
+sdd cicd setup github
+\`\`\`
+
+### \uC124\uC815 \uC81C\uC548 \uC2DC\uB098\uB9AC\uC624
+
+1. **Git Hooks\uAC00 \uC5C6\uB294 \uACBD\uC6B0**:
+   "Git Hooks\uAC00 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uCEE4\uBC0B/\uD478\uC2DC \uC2DC \uC790\uB3D9 \uC2A4\uD399 \uAC80\uC99D\uC744 \uD65C\uC131\uD654\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?"
+   \u2192 \uC2B9\uC778 \uC2DC: \`sdd git hooks install\` \uC2E4\uD589
+
+2. **\uCEE4\uBC0B \uD15C\uD50C\uB9BF\uC774 \uC5C6\uB294 \uACBD\uC6B0**:
+   "\uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uD15C\uD50C\uB9BF\uC744 \uC124\uCE58\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C? \uC77C\uAD00\uB41C \uCEE4\uBC0B \uD615\uC2DD\uC744 \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4."
+   \u2192 \uC2B9\uC778 \uC2DC: \`sdd git template install\` \uC2E4\uD589
+
+3. **GitHub Actions\uAC00 \uC5C6\uB294 \uACBD\uC6B0**:
+   "GitHub Actions CI/CD\uB97C \uC124\uC815\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C? PR \uC2DC \uC790\uB3D9\uC73C\uB85C \uC2A4\uD399\uC744 \uAC80\uC99D\uD569\uB2C8\uB2E4."
+   \u2192 \uC2B9\uC778 \uC2DC: \`sdd cicd setup github\` \uC2E4\uD589
 
 ## \uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uC6CC\uD06C\uD50C\uB85C\uC6B0
 
@@ -1635,6 +1674,7 @@ function generateClaudeCommands() {
 - **validate**: \uBA85\uC138 \uAC80\uC99D
 - **status**: \uC0C1\uD0DC \uD655\uC778
 - **constitution**: Constitution \uAD00\uB9AC
+- **git-setup**: Git \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC124\uC815
 
 ## \uBA85\uB839\uC5B4
 
@@ -1654,9 +1694,26 @@ sdd start --workflow validate
 ## \uD504\uB85C\uC81D\uD2B8 \uBBF8\uCD08\uAE30\uD654 \uC2DC
 
 \uD504\uB85C\uC81D\uD2B8\uAC00 \uCD08\uAE30\uD654\uB418\uC9C0 \uC54A\uC740 \uACBD\uC6B0:
-1. \`sdd init\`\uC73C\uB85C \uD504\uB85C\uC81D\uD2B8\uB97C \uCD08\uAE30\uD654\uD558\uC138\uC694
+1. \`sdd init\`\uC73C\uB85C \uD504\uB85C\uC81D\uD2B8\uB97C \uCD08\uAE30\uD654\uD558\uC138\uC694 (Git/CI-CD \uC124\uC815 \uD3EC\uD568)
 2. \`/sdd.constitution\`\uC73C\uB85C \uD504\uB85C\uC81D\uD2B8 \uC6D0\uCE59\uC744 \uC815\uC758\uD558\uC138\uC694
 3. \`/sdd.new\`\uB85C \uCCAB \uAE30\uB2A5 \uBA85\uC138\uB97C \uC791\uC131\uD558\uC138\uC694
+
+## Git \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC0C1\uC138
+
+### \uC124\uCE58\uB418\uB294 Git Hooks
+
+| \uD6C5 | \uC2DC\uC810 | \uAE30\uB2A5 |
+|----|------|------|
+| pre-commit | \uCEE4\uBC0B \uC804 | \uBCC0\uACBD\uB41C \uC2A4\uD399 \uAC80\uC99D |
+| commit-msg | \uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uC791\uC131 \uD6C4 | \uBA54\uC2DC\uC9C0 \uD615\uC2DD \uAC80\uC99D |
+| pre-push | \uD478\uC2DC \uC804 | \uC804\uCCB4 \uC2A4\uD399 \uAC80\uC99D |
+
+### \uC0DD\uC131\uB418\uB294 GitHub Actions
+
+| \uC6CC\uD06C\uD50C\uB85C\uC6B0 | \uAE30\uB2A5 |
+|-----------|------|
+| sdd-validate.yml | PR/\uD478\uC2DC \uC2DC \uC2A4\uD399 \uC790\uB3D9 \uAC80\uC99D |
+| sdd-labeler.yml | PR\uC5D0 \uB3C4\uBA54\uC778\uBCC4 \uB77C\uBCA8 \uC790\uB3D9 \uCD94\uAC00 |
 `
     },
     {
@@ -3028,6 +3085,468 @@ sdd export user-auth --no-toc
 
 // src/cli/commands/init.ts
 init_types();
+
+// src/utils/project-analyzer.ts
+init_fs();
+import path2 from "path";
+async function analyzeProject(projectPath) {
+  const [
+    isGitRepo,
+    hasPreCommitHook,
+    hasCommitMsgHook,
+    hasPrePushHook,
+    hasGitMessageTemplate,
+    hasGitHubWorkflows,
+    hasGitLabCI,
+    isSddProject,
+    isNodeProject,
+    isTypeScriptProject,
+    hasSddValidateWorkflow,
+    hasSddLabelerWorkflow
+  ] = await Promise.all([
+    directoryExists(path2.join(projectPath, ".git")),
+    fileExists(path2.join(projectPath, ".git", "hooks", "pre-commit")),
+    fileExists(path2.join(projectPath, ".git", "hooks", "commit-msg")),
+    fileExists(path2.join(projectPath, ".git", "hooks", "pre-push")),
+    fileExists(path2.join(projectPath, ".gitmessage")),
+    directoryExists(path2.join(projectPath, ".github", "workflows")),
+    fileExists(path2.join(projectPath, ".gitlab-ci.yml")).then(
+      (exists) => exists || fileExists(path2.join(projectPath, ".gitlab-ci-sdd.yml"))
+    ),
+    directoryExists(path2.join(projectPath, ".sdd")),
+    fileExists(path2.join(projectPath, "package.json")),
+    fileExists(path2.join(projectPath, "tsconfig.json")),
+    fileExists(path2.join(projectPath, ".github", "workflows", "sdd-validate.yml")),
+    fileExists(path2.join(projectPath, ".github", "workflows", "sdd-labeler.yml"))
+  ]);
+  return {
+    isGitRepo,
+    hasGitHooks: hasPreCommitHook && hasCommitMsgHook && hasPrePushHook,
+    hasGitMessageTemplate,
+    hasGitHubActions: hasGitHubWorkflows,
+    hasGitLabCI,
+    isSddProject,
+    isNodeProject,
+    isTypeScriptProject,
+    hasSddValidateWorkflow,
+    hasSddLabelerWorkflow
+  };
+}
+function generateSuggestions(analysis) {
+  const suggestions = {
+    suggestGitHooks: false,
+    suggestGitTemplate: false,
+    suggestGitHubActions: false,
+    suggestGitLabCI: false,
+    reasons: []
+  };
+  if (!analysis.isGitRepo) {
+    suggestions.reasons.push("Git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4. git init \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694.");
+    return suggestions;
+  }
+  if (!analysis.hasGitHooks) {
+    suggestions.suggestGitHooks = true;
+    suggestions.reasons.push("Git Hooks\uAC00 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uCEE4\uBC0B/\uD478\uC2DC \uC2DC \uC790\uB3D9 \uAC80\uC99D\uC744 \uD65C\uC131\uD654\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+  }
+  if (!analysis.hasGitMessageTemplate) {
+    suggestions.suggestGitTemplate = true;
+    suggestions.reasons.push("\uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uD15C\uD50C\uB9BF\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uC77C\uAD00\uB41C \uCEE4\uBC0B \uD615\uC2DD\uC744 \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+  }
+  if (analysis.hasGitHubActions && !analysis.hasSddValidateWorkflow) {
+    suggestions.suggestGitHubActions = true;
+    suggestions.reasons.push(".github/workflows\uAC00 \uC874\uC7AC\uD558\uC9C0\uB9CC SDD \uAC80\uC99D \uC6CC\uD06C\uD50C\uB85C\uC6B0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  } else if (!analysis.hasGitHubActions && !analysis.hasGitLabCI) {
+    suggestions.suggestGitHubActions = true;
+    suggestions.reasons.push("CI/CD \uC124\uC815\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. PR \uC2DC \uC790\uB3D9 \uC2A4\uD399 \uAC80\uC99D\uC744 \uD65C\uC131\uD654\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+  }
+  if (!analysis.hasGitHubActions && !analysis.hasGitLabCI) {
+    suggestions.suggestGitLabCI = true;
+  }
+  return suggestions;
+}
+function formatAnalysis(analysis) {
+  const lines = [];
+  lines.push("=== \uD504\uB85C\uC81D\uD2B8 \uBD84\uC11D \uACB0\uACFC ===");
+  lines.push("");
+  lines.push("\u{1F4C1} \uD504\uB85C\uC81D\uD2B8 \uD0C0\uC785:");
+  if (analysis.isNodeProject) {
+    lines.push(`   ${analysis.isTypeScriptProject ? "TypeScript" : "JavaScript"} (Node.js)`);
+  } else {
+    lines.push("   (\uAC10\uC9C0\uB418\uC9C0 \uC54A\uC74C)");
+  }
+  lines.push("");
+  lines.push("\u{1F527} Git \uC0C1\uD0DC:");
+  lines.push(`   \uC800\uC7A5\uC18C: ${analysis.isGitRepo ? "\u2705 \uCD08\uAE30\uD654\uB428" : "\u274C \uBBF8\uCD08\uAE30\uD654"}`);
+  if (analysis.isGitRepo) {
+    lines.push(`   Hooks: ${analysis.hasGitHooks ? "\u2705 \uC124\uCE58\uB428" : "\u274C \uBBF8\uC124\uCE58"}`);
+    lines.push(`   \uCEE4\uBC0B \uD15C\uD50C\uB9BF: ${analysis.hasGitMessageTemplate ? "\u2705 \uC874\uC7AC" : "\u274C \uC5C6\uC74C"}`);
+  }
+  lines.push("");
+  lines.push("\u{1F680} CI/CD \uC0C1\uD0DC:");
+  if (analysis.hasGitHubActions) {
+    lines.push(`   GitHub Actions: \u2705 \uC124\uC815\uB428`);
+    lines.push(`     - SDD Validate: ${analysis.hasSddValidateWorkflow ? "\u2705" : "\u274C"}`);
+    lines.push(`     - SDD Labeler: ${analysis.hasSddLabelerWorkflow ? "\u2705" : "\u274C"}`);
+  } else {
+    lines.push("   GitHub Actions: \u274C \uBBF8\uC124\uC815");
+  }
+  lines.push(`   GitLab CI: ${analysis.hasGitLabCI ? "\u2705 \uC124\uC815\uB428" : "\u274C \uBBF8\uC124\uC815"}`);
+  lines.push("");
+  lines.push("\u{1F4CB} SDD \uC0C1\uD0DC:");
+  lines.push(`   \uCD08\uAE30\uD654: ${analysis.isSddProject ? "\u2705 \uC644\uB8CC" : "\u274C \uBBF8\uCD08\uAE30\uD654"}`);
+  return lines.join("\n");
+}
+
+// src/cli/commands/git.ts
+init_fs();
+init_errors();
+import path3 from "path";
+import fs2 from "fs/promises";
+init_types();
+function generatePreCommitHook() {
+  return `#!/bin/sh
+# SDD pre-commit hook
+# \uBCC0\uACBD\uB41C \uC2A4\uD399 \uD30C\uC77C\uC744 \uAC80\uC99D\uD569\uB2C8\uB2E4
+
+# \uC0C9\uC0C1 \uC815\uC758
+RED='\\033[0;31m'
+GREEN='\\033[0;32m'
+YELLOW='\\033[1;33m'
+NC='\\033[0m' # No Color
+
+# \uBCC0\uACBD\uB41C \uC2A4\uD399 \uD30C\uC77C \uD655\uC778
+CHANGED_SPECS=$(git diff --cached --name-only | grep "^\\.sdd/specs/")
+
+if [ -n "$CHANGED_SPECS" ]; then
+  echo "\${YELLOW}\u{1F50D} \uC2A4\uD399 \uAC80\uC99D \uC911...\${NC}"
+
+  # sdd validate \uC2E4\uD589
+  if command -v sdd &> /dev/null; then
+    sdd validate --ci
+    if [ $? -ne 0 ]; then
+      echo "\${RED}\u274C \uC2A4\uD399 \uAC80\uC99D \uC2E4\uD328. \uCEE4\uBC0B\uC774 \uCDE8\uC18C\uB429\uB2C8\uB2E4.\${NC}"
+      echo "\uC624\uB958\uB97C \uC218\uC815\uD558\uACE0 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694."
+      exit 1
+    fi
+    echo "\${GREEN}\u2705 \uC2A4\uD399 \uAC80\uC99D \uD1B5\uACFC\${NC}"
+  else
+    echo "\${YELLOW}\u26A0\uFE0F  sdd \uBA85\uB839\uC5B4\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uAC80\uC99D\uC744 \uAC74\uB108\uB701\uB2C8\uB2E4.\${NC}"
+  fi
+fi
+
+exit 0
+`;
+}
+function generateCommitMsgHook() {
+  return `#!/bin/sh
+# SDD commit-msg hook
+# \uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uD615\uC2DD\uC744 \uAC80\uC99D\uD569\uB2C8\uB2E4
+
+# \uC0C9\uC0C1 \uC815\uC758
+RED='\\033[0;31m'
+GREEN='\\033[0;32m'
+NC='\\033[0m'
+
+COMMIT_MSG_FILE=$1
+COMMIT_MSG=$(cat "$COMMIT_MSG_FILE")
+
+# \uBE48 \uC904\uACFC \uC8FC\uC11D \uC81C\uAC70
+COMMIT_MSG_CLEAN=$(echo "$COMMIT_MSG" | grep -v "^#" | grep -v "^$" | head -1)
+
+# \uC2A4\uD399 \uCEE4\uBC0B \uD328\uD134
+SPEC_PATTERN="^(spec|spec-update|spec-status|plan|tasks|constitution|sdd-config)(\\(.+\\))?: .+"
+
+# \uC77C\uBC18 \uCEE4\uBC0B \uD328\uD134 (Conventional Commits)
+GENERAL_PATTERN="^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\\(.+\\))?: .+"
+
+# \uBA38\uC9C0 \uCEE4\uBC0B \uD328\uD134
+MERGE_PATTERN="^Merge "
+
+# \uB9AC\uBC84\uD2B8 \uCEE4\uBC0B \uD328\uD134
+REVERT_PATTERN="^Revert "
+
+# \uD328\uD134 \uAC80\uC0AC
+if echo "$COMMIT_MSG_CLEAN" | grep -qE "$SPEC_PATTERN"; then
+  echo "\${GREEN}\u2705 \uC2A4\uD399 \uCEE4\uBC0B \uD615\uC2DD \uD655\uC778\uB428\${NC}"
+  exit 0
+elif echo "$COMMIT_MSG_CLEAN" | grep -qE "$GENERAL_PATTERN"; then
+  echo "\${GREEN}\u2705 Conventional Commit \uD615\uC2DD \uD655\uC778\uB428\${NC}"
+  exit 0
+elif echo "$COMMIT_MSG_CLEAN" | grep -qE "$MERGE_PATTERN"; then
+  exit 0
+elif echo "$COMMIT_MSG_CLEAN" | grep -qE "$REVERT_PATTERN"; then
+  exit 0
+else
+  echo "\${RED}\u274C \uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uD615\uC2DD \uC624\uB958\${NC}"
+  echo ""
+  echo "\uC62C\uBC14\uB978 \uD615\uC2DD:"
+  echo "  \uC2A4\uD399 \uCEE4\uBC0B: spec(<scope>): <message>"
+  echo "  \uC77C\uBC18 \uCEE4\uBC0B: feat(<scope>): <message>"
+  echo ""
+  echo "\uC2A4\uD399 \uD0C0\uC785: spec, spec-update, spec-status, plan, tasks, constitution, sdd-config"
+  echo "\uC77C\uBC18 \uD0C0\uC785: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert"
+  echo ""
+  echo "\uC790\uC138\uD55C \uB0B4\uC6A9: docs/guide/commit-convention.md"
+  exit 1
+fi
+`;
+}
+function generatePrePushHook() {
+  return `#!/bin/sh
+# SDD pre-push hook
+# \uD478\uC2DC \uC804 \uC804\uCCB4 \uAC80\uC99D\uC744 \uC218\uD589\uD569\uB2C8\uB2E4
+
+# \uC0C9\uC0C1 \uC815\uC758
+RED='\\033[0;31m'
+GREEN='\\033[0;32m'
+YELLOW='\\033[1;33m'
+NC='\\033[0m'
+
+echo "\${YELLOW}\u{1F50D} \uD478\uC2DC \uC804 \uAC80\uC99D \uC911...\${NC}"
+
+# sdd \uBA85\uB839\uC5B4 \uD655\uC778
+if ! command -v sdd &> /dev/null; then
+  echo "\${YELLOW}\u26A0\uFE0F  sdd \uBA85\uB839\uC5B4\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uAC80\uC99D\uC744 \uAC74\uB108\uB701\uB2C8\uB2E4.\${NC}"
+  exit 0
+fi
+
+# \uC804\uCCB4 \uC2A4\uD399 \uAC80\uC99D
+echo "\uC2A4\uD399 \uAC80\uC99D \uC911..."
+sdd validate --ci
+if [ $? -ne 0 ]; then
+  echo "\${RED}\u274C \uC2A4\uD399 \uAC80\uC99D \uC2E4\uD328. \uD478\uC2DC\uAC00 \uCDE8\uC18C\uB429\uB2C8\uB2E4.\${NC}"
+  exit 1
+fi
+
+# Constitution \uC815\uD569\uC131 \uD655\uC778
+echo "Constitution \uC815\uD569\uC131 \uD655\uC778 \uC911..."
+sdd validate --constitution --ci 2>/dev/null
+if [ $? -ne 0 ]; then
+  echo "\${YELLOW}\u26A0\uFE0F  Constitution \uAC80\uC99D \uACBD\uACE0 (\uACC4\uC18D \uC9C4\uD589)\${NC}"
+fi
+
+echo "\${GREEN}\u2705 \uAC80\uC99D \uC644\uB8CC\${NC}"
+exit 0
+`;
+}
+function generateGitMessageTemplate() {
+  return `# <type>(<scope>): <subject>
+# |<----  50\uC790 \uC774\uB0B4\uB85C \uC791\uC131\uD558\uC138\uC694  ---->|
+#
+# \uC2A4\uD399 \uD0C0\uC785: spec, spec-update, spec-status, plan, tasks, constitution, sdd-config
+# \uC77C\uBC18 \uD0C0\uC785: feat, fix, docs, style, refactor, test, chore
+#
+# \uC2A4\uCF54\uD504 \uC608\uC2DC:
+#   spec(auth): ...              - \uB3C4\uBA54\uC778 \uC804\uCCB4
+#   spec(auth/user-login): ...   - \uD2B9\uC815 \uC2A4\uD399
+#   spec(auth,billing): ...      - \uB2E4\uC911 \uB3C4\uBA54\uC778
+#   constitution: ...            - \uC2A4\uCF54\uD504 \uC5C6\uC74C
+
+# \uBCF8\uBB38 (\uC120\uD0DD\uC0AC\uD56D, 72\uC790 \uC904\uBC14\uAFC8)
+# |<----  72\uC790 \uC774\uB0B4\uB85C \uC791\uC131\uD558\uC138\uC694  ---->|
+
+# Footer (\uC120\uD0DD\uC0AC\uD56D)
+# Refs: #\uC774\uC288\uBC88\uD638
+# Breaking-Spec: \uC601\uD5A5\uBC1B\uB294-\uC2A4\uD399
+# Depends-On: \uC758\uC874-\uC2A4\uD399
+# Reviewed-By: @\uB9AC\uBDF0\uC5B4
+`;
+}
+async function installHooks(projectPath, options = {}) {
+  const gitPath = path3.join(projectPath, ".git");
+  const hooksPath = path3.join(gitPath, "hooks");
+  if (!await directoryExists(gitPath)) {
+    return failure(new Error("Git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4. \uBA3C\uC800 git init\uC744 \uC2E4\uD589\uD558\uC138\uC694."));
+  }
+  await ensureDir(hooksPath);
+  const hooks = [
+    { name: "pre-commit", content: generatePreCommitHook() },
+    { name: "commit-msg", content: generateCommitMsgHook() },
+    { name: "pre-push", content: generatePrePushHook() }
+  ];
+  const result = {
+    installed: [],
+    skipped: [],
+    backedUp: []
+  };
+  for (const hook of hooks) {
+    const hookPath = path3.join(hooksPath, hook.name);
+    const backupPath = path3.join(hooksPath, `${hook.name}.backup`);
+    if (await fileExists(hookPath)) {
+      if (!options.force) {
+        result.skipped.push(hook.name);
+        continue;
+      }
+      try {
+        const existingContent = await fs2.readFile(hookPath, "utf-8");
+        await fs2.writeFile(backupPath, existingContent);
+        result.backedUp.push(hook.name);
+      } catch {
+      }
+    }
+    await fs2.writeFile(hookPath, hook.content, { mode: 493 });
+    result.installed.push(hook.name);
+  }
+  return success(result);
+}
+async function uninstallHooks(projectPath) {
+  const gitPath = path3.join(projectPath, ".git");
+  const hooksPath = path3.join(gitPath, "hooks");
+  if (!await directoryExists(gitPath)) {
+    return failure(new Error("Git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4."));
+  }
+  const hookNames = ["pre-commit", "commit-msg", "pre-push"];
+  const removed = [];
+  for (const name of hookNames) {
+    const hookPath = path3.join(hooksPath, name);
+    const backupPath = path3.join(hooksPath, `${name}.backup`);
+    try {
+      if (await fileExists(hookPath)) {
+        await fs2.unlink(hookPath);
+        removed.push(name);
+      }
+      if (await fileExists(backupPath)) {
+        await fs2.rename(backupPath, hookPath);
+      }
+    } catch {
+    }
+  }
+  return success(removed);
+}
+async function installTemplate(projectPath) {
+  const templatePath = path3.join(projectPath, ".gitmessage");
+  await writeFile(templatePath, generateGitMessageTemplate());
+  let configured = false;
+  try {
+    const { exec: exec3 } = await import("child_process");
+    const { promisify: promisify3 } = await import("util");
+    const execAsync3 = promisify3(exec3);
+    await execAsync3(`git config commit.template .gitmessage`, { cwd: projectPath });
+    configured = true;
+  } catch {
+  }
+  return success({
+    installed: [".gitmessage"],
+    configured
+  });
+}
+async function setupGit(projectPath, options = {}) {
+  const hooksResult = await installHooks(projectPath, options);
+  if (!hooksResult.success) {
+    return failure(hooksResult.error);
+  }
+  const templateResult = await installTemplate(projectPath);
+  if (!templateResult.success) {
+    return failure(templateResult.error);
+  }
+  return success({
+    hooks: hooksResult.data,
+    template: templateResult.data
+  });
+}
+function registerGitCommand(program2) {
+  const git = program2.command("git").description("Git \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC124\uC815 (hooks, templates)");
+  git.command("hooks").description("Git hooks \uAD00\uB9AC").argument("<action>", "install \uB610\uB294 uninstall").option("-f, --force", "\uAE30\uC874 \uD6C5 \uB36E\uC5B4\uC4F0\uAE30").action(async (action, options) => {
+    try {
+      const cwd = process.cwd();
+      if (action === "install") {
+        info("Git hooks\uB97C \uC124\uCE58\uD569\uB2C8\uB2E4...");
+        const result = await installHooks(cwd, options);
+        if (!result.success) {
+          error(result.error.message);
+          process.exit(ExitCode.GENERAL_ERROR);
+        }
+        const { installed, skipped, backedUp } = result.data;
+        if (installed.length > 0) {
+          success2(`\uC124\uCE58\uB428: ${installed.join(", ")}`);
+        }
+        if (backedUp.length > 0) {
+          info(`\uBC31\uC5C5\uB428: ${backedUp.join(", ")}`);
+        }
+        if (skipped.length > 0) {
+          warn(`\uAC74\uB108\uB700 (\uC774\uBBF8 \uC874\uC7AC): ${skipped.join(", ")}`);
+          info("\uB36E\uC5B4\uC4F0\uB824\uBA74 --force \uC635\uC158\uC744 \uC0AC\uC6A9\uD558\uC138\uC694.");
+        }
+        newline();
+        info("\uC124\uCE58\uB41C \uD6C5:");
+        listItem("pre-commit: \uC2A4\uD399 \uAC80\uC99D");
+        listItem("commit-msg: \uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uD615\uC2DD \uAC80\uC99D");
+        listItem("pre-push: \uD478\uC2DC \uC804 \uC804\uCCB4 \uAC80\uC99D");
+      } else if (action === "uninstall") {
+        info("Git hooks\uB97C \uC81C\uAC70\uD569\uB2C8\uB2E4...");
+        const result = await uninstallHooks(cwd);
+        if (!result.success) {
+          error(result.error.message);
+          process.exit(ExitCode.GENERAL_ERROR);
+        }
+        if (result.data.length > 0) {
+          success2(`\uC81C\uAC70\uB428: ${result.data.join(", ")}`);
+        } else {
+          info("\uC81C\uAC70\uD560 \uD6C5\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+        }
+      } else {
+        error(`\uC54C \uC218 \uC5C6\uB294 \uC561\uC158: ${action}`);
+        info("\uC0AC\uC6A9\uBC95: sdd git hooks install|uninstall");
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+    } catch (error2) {
+      error(error2 instanceof Error ? error2.message : String(error2));
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+  });
+  git.command("template").description("\uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uD15C\uD50C\uB9BF \uC124\uCE58").argument("<action>", "install").action(async (action) => {
+    try {
+      if (action !== "install") {
+        error(`\uC54C \uC218 \uC5C6\uB294 \uC561\uC158: ${action}`);
+        info("\uC0AC\uC6A9\uBC95: sdd git template install");
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      const cwd = process.cwd();
+      info("\uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uD15C\uD50C\uB9BF\uC744 \uC124\uCE58\uD569\uB2C8\uB2E4...");
+      const result = await installTemplate(cwd);
+      if (!result.success) {
+        error(result.error.message);
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      success2(".gitmessage \uD30C\uC77C\uC774 \uC0DD\uC131\uB418\uC5C8\uC2B5\uB2C8\uB2E4.");
+      if (result.data.configured) {
+        success2("git config commit.template\uC774 \uC124\uC815\uB418\uC5C8\uC2B5\uB2C8\uB2E4.");
+      } else {
+        warn("git config \uC124\uC815\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4.");
+        info("\uC218\uB3D9 \uC124\uC815: git config commit.template .gitmessage");
+      }
+    } catch (error2) {
+      error(error2 instanceof Error ? error2.message : String(error2));
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+  });
+  git.command("setup").description("Git \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC804\uCCB4 \uC124\uC815 (hooks + template)").option("-f, --force", "\uAE30\uC874 \uC124\uC815 \uB36E\uC5B4\uC4F0\uAE30").action(async (options) => {
+    try {
+      const cwd = process.cwd();
+      info("Git \uC6CC\uD06C\uD50C\uB85C\uC6B0\uB97C \uC124\uC815\uD569\uB2C8\uB2E4...");
+      const result = await setupGit(cwd, options);
+      if (!result.success) {
+        error(result.error.message);
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      newline();
+      success2("Git \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC124\uC815 \uC644\uB8CC!");
+      newline();
+      info("\uC124\uCE58\uB41C \uAD6C\uC131:");
+      listItem("Git Hooks: pre-commit, commit-msg, pre-push");
+      listItem(".gitmessage: \uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uD15C\uD50C\uB9BF");
+      newline();
+      info("\uB2E4\uC74C \uB2E8\uACC4:");
+      listItem("spec/domain/feature \uD615\uC2DD\uC73C\uB85C \uBE0C\uB79C\uCE58 \uC0DD\uC131");
+      listItem("\uCEE4\uBC0B \uC2DC \uC790\uB3D9\uC73C\uB85C \uD615\uC2DD \uAC80\uC99D");
+    } catch (error2) {
+      error(error2 instanceof Error ? error2.message : String(error2));
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+  });
+}
+
+// src/cli/commands/init.ts
 function getInitDirectories() {
   return [
     ".sdd",
@@ -3109,8 +3628,8 @@ depends: null
 `;
 }
 async function executeInit(projectPath, options) {
-  const sddPath = path2.join(projectPath, ".sdd");
-  const claudePath = path2.join(projectPath, ".claude");
+  const sddPath = path4.join(projectPath, ".sdd");
+  const claudePath = path4.join(projectPath, ".claude");
   if (await directoryExists(sddPath)) {
     if (!options.force) {
       return failure(new Error(".sdd/ \uB514\uB809\uD1A0\uB9AC\uAC00 \uC774\uBBF8 \uC874\uC7AC\uD569\uB2C8\uB2E4. --force \uC635\uC158\uC73C\uB85C \uB36E\uC5B4\uC4F8 \uC218 \uC788\uC2B5\uB2C8\uB2E4."));
@@ -3119,19 +3638,19 @@ async function executeInit(projectPath, options) {
   const directories = getInitDirectories();
   const createdDirs = [];
   for (const dir of directories) {
-    const result = await ensureDir(path2.join(projectPath, dir));
+    const result = await ensureDir(path4.join(projectPath, dir));
     if (!result.success) {
       return failure(new Error(`\uB514\uB809\uD1A0\uB9AC \uC0DD\uC131 \uC2E4\uD328: ${dir}`));
     }
     createdDirs.push(dir);
   }
   const createdFiles = [];
-  const projectName = path2.basename(projectPath);
+  const projectName = path4.basename(projectPath);
   const constitutionContent = generateConstitutionContent(projectName);
-  await writeFile(path2.join(sddPath, "constitution.md"), constitutionContent);
+  await writeFile(path4.join(sddPath, "constitution.md"), constitutionContent);
   createdFiles.push(".sdd/constitution.md");
   const agentsContent = generateAgentsMd({ projectName });
-  await writeFile(path2.join(sddPath, "AGENTS.md"), agentsContent);
+  await writeFile(path4.join(sddPath, "AGENTS.md"), agentsContent);
   createdFiles.push(".sdd/AGENTS.md");
   const templateFiles = await createTemplateFiles(projectPath);
   createdFiles.push(...templateFiles);
@@ -3145,24 +3664,24 @@ async function executeInit(projectPath, options) {
   });
 }
 async function createTemplateFiles(projectPath) {
-  const templatesPath = path2.join(projectPath, ".sdd", "templates");
+  const templatesPath = path4.join(projectPath, ".sdd", "templates");
   const files = [];
-  await writeFile(path2.join(templatesPath, "spec.md"), generateSpecTemplate());
+  await writeFile(path4.join(templatesPath, "spec.md"), generateSpecTemplate());
   files.push(".sdd/templates/spec.md");
-  await writeFile(path2.join(templatesPath, "proposal.md"), generateProposalTemplate());
+  await writeFile(path4.join(templatesPath, "proposal.md"), generateProposalTemplate());
   files.push(".sdd/templates/proposal.md");
-  await writeFile(path2.join(templatesPath, "delta.md"), generateDeltaTemplate());
+  await writeFile(path4.join(templatesPath, "delta.md"), generateDeltaTemplate());
   files.push(".sdd/templates/delta.md");
-  await writeFile(path2.join(templatesPath, "tasks.md"), generateTasksTemplate());
+  await writeFile(path4.join(templatesPath, "tasks.md"), generateTasksTemplate());
   files.push(".sdd/templates/tasks.md");
   return files;
 }
 async function createCommandFiles(projectPath) {
-  const commandsPath = path2.join(projectPath, ".claude", "commands");
+  const commandsPath = path4.join(projectPath, ".claude", "commands");
   const files = [];
   const commands = generateClaudeCommands();
   for (const cmd of commands) {
-    await writeFile(path2.join(commandsPath, `${cmd.name}.md`), cmd.content);
+    await writeFile(path4.join(commandsPath, `${cmd.name}.md`), cmd.content);
     files.push(`.claude/commands/${cmd.name}.md`);
   }
   return files;
@@ -3321,8 +3840,194 @@ graph LR
 | [US] | \uBD88\uD655\uC2E4/\uAC80\uD1A0 \uD544\uC694 |
 `;
 }
+async function askYesNo(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`${question} (y/n): `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve(normalized === "y" || normalized === "yes" || normalized === "\uC608");
+    });
+  });
+}
+async function promptGitSetup(projectPath, autoApprove) {
+  newline();
+  info("\u{1F50D} \uD504\uB85C\uC81D\uD2B8 \uAD6C\uC870\uB97C \uBD84\uC11D\uD569\uB2C8\uB2E4...");
+  newline();
+  const analysis = await analyzeProject(projectPath);
+  const suggestions = generateSuggestions(analysis);
+  console.log(formatAnalysis(analysis));
+  newline();
+  if (!analysis.isGitRepo) {
+    warn("Git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4.");
+    info("Git \uC124\uC815\uC744 \uD65C\uC131\uD654\uD558\uB824\uBA74:");
+    listItem("git init");
+    listItem("sdd git setup");
+    return;
+  }
+  if (!suggestions.suggestGitHooks && !suggestions.suggestGitTemplate && !suggestions.suggestGitHubActions) {
+    success2("Git \uC6CC\uD06C\uD50C\uB85C\uC6B0\uAC00 \uC774\uBBF8 \uC124\uC815\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4!");
+    return;
+  }
+  info("\u{1F4CB} \uAD8C\uC7A5 \uC124\uC815:");
+  if (suggestions.suggestGitHooks) {
+    listItem("Git Hooks: \uCEE4\uBC0B/\uD478\uC2DC \uC2DC \uC790\uB3D9 \uC2A4\uD399 \uAC80\uC99D");
+  }
+  if (suggestions.suggestGitTemplate) {
+    listItem("\uCEE4\uBC0B \uD15C\uD50C\uB9BF: \uC77C\uAD00\uB41C \uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uD615\uC2DD");
+  }
+  if (suggestions.suggestGitHubActions) {
+    listItem("GitHub Actions: PR \uC2DC \uC790\uB3D9 \uAC80\uC99D \uBC0F \uB77C\uBCA8\uB9C1");
+  }
+  newline();
+  if (suggestions.suggestGitHooks || suggestions.suggestGitTemplate) {
+    const setupGitWorkflow = autoApprove || await askYesNo("Git \uC6CC\uD06C\uD50C\uB85C\uC6B0(Hooks + \uD15C\uD50C\uB9BF)\uB97C \uC124\uCE58\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?");
+    if (setupGitWorkflow) {
+      info("Git \uC6CC\uD06C\uD50C\uB85C\uC6B0\uB97C \uC124\uCE58\uD569\uB2C8\uB2E4...");
+      const result = await setupGit(projectPath, { force: false });
+      if (result.success) {
+        success2("Git \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC124\uCE58 \uC644\uB8CC!");
+        if (result.data.hooks.installed.length > 0) {
+          listItem(`Hooks: ${result.data.hooks.installed.join(", ")}`);
+        }
+        if (result.data.template.installed.length > 0) {
+          listItem(`\uD15C\uD50C\uB9BF: ${result.data.template.installed.join(", ")}`);
+        }
+      } else {
+        warn("Git \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC124\uCE58 \uC2E4\uD328: " + result.error.message);
+      }
+      newline();
+    }
+  }
+  if (suggestions.suggestGitHubActions) {
+    const setupCicd = autoApprove || await askYesNo("GitHub Actions CI/CD\uB97C \uC124\uC815\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?");
+    if (setupCicd) {
+      info("GitHub Actions\uB97C \uC124\uC815\uD569\uB2C8\uB2E4...");
+      try {
+        const workflowDir = path4.join(projectPath, ".github", "workflows");
+        await ensureDir(workflowDir);
+        const validateContent = generateGitHubValidateWorkflow();
+        await writeFile(path4.join(workflowDir, "sdd-validate.yml"), validateContent);
+        success2("sdd-validate.yml \uC0DD\uC131 \uC644\uB8CC");
+        const labelerContent = generateGitHubLabelerWorkflow();
+        await writeFile(path4.join(workflowDir, "sdd-labeler.yml"), labelerContent);
+        success2("sdd-labeler.yml \uC0DD\uC131 \uC644\uB8CC");
+      } catch (error2) {
+        warn("GitHub Actions \uC124\uC815 \uC2E4\uD328: " + (error2 instanceof Error ? error2.message : String(error2)));
+      }
+      newline();
+    }
+  }
+}
+function generateGitHubValidateWorkflow() {
+  return `# SDD \uC2A4\uD399 \uAC80\uC99D \uC6CC\uD06C\uD50C\uB85C\uC6B0
+# \uC774 \uD30C\uC77C\uC740 sdd init\uC73C\uB85C \uC0DD\uC131\uB418\uC5C8\uC2B5\uB2C8\uB2E4.
+
+name: SDD Validation
+
+on:
+  push:
+    branches: [main, master, develop]
+    paths:
+      - '.sdd/**'
+  pull_request:
+    branches: [main, master, develop]
+    paths:
+      - '.sdd/**'
+
+jobs:
+  validate:
+    name: Validate Specs
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Install SDD Tool
+        run: npm install -g sdd-tool
+
+      - name: Validate specifications
+        run: sdd validate
+`;
+}
+function generateGitHubLabelerWorkflow() {
+  return `# SDD PR \uB77C\uBCA8\uB7EC \uC6CC\uD06C\uD50C\uB85C\uC6B0
+# \uBCC0\uACBD\uB41C \uB3C4\uBA54\uC778\uC5D0 \uB530\uB77C \uC790\uB3D9\uC73C\uB85C \uB77C\uBCA8\uC744 \uCD94\uAC00\uD569\uB2C8\uB2E4
+
+name: SDD Labeler
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+    paths:
+      - '.sdd/**'
+
+jobs:
+  label:
+    name: Add Labels
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Detect Changes
+        id: changes
+        run: |
+          # \uBCC0\uACBD\uB41C \uB3C4\uBA54\uC778 \uAC10\uC9C0
+          DOMAINS=$(git diff --name-only origin/\${{ github.base_ref }} | \\
+            grep "^\\.sdd/specs/" | \\
+            cut -d'/' -f3 | \\
+            sort -u | \\
+            tr '\\n' ' ')
+          echo "domains=$DOMAINS" >> $GITHUB_OUTPUT
+
+          # Constitution \uBCC0\uACBD \uAC10\uC9C0
+          if git diff --name-only origin/\${{ github.base_ref }} | grep -q "constitution.md"; then
+            echo "constitution=true" >> $GITHUB_OUTPUT
+          else
+            echo "constitution=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Apply Labels
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const labels = [];
+            const domains = '\${{ steps.changes.outputs.domains }}'.trim().split(' ').filter(Boolean);
+            labels.push(...domains.map(d => \`spec:\${d}\`));
+
+            if ('\${{ steps.changes.outputs.constitution }}' === 'true') {
+              labels.push('constitution');
+            }
+
+            if (labels.length > 0) {
+              await github.rest.issues.addLabels({
+                issue_number: context.issue.number,
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                labels: labels,
+              });
+            }
+`;
+}
 function registerInitCommand(program2) {
-  program2.command("init").description("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCD08\uAE30\uD654\uD569\uB2C8\uB2E4").option("-f, --force", "\uAE30\uC874 .sdd/ \uB514\uB809\uD1A0\uB9AC \uB36E\uC5B4\uC4F0\uAE30").action(async (options) => {
+  program2.command("init").description("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCD08\uAE30\uD654\uD569\uB2C8\uB2E4").option("-f, --force", "\uAE30\uC874 .sdd/ \uB514\uB809\uD1A0\uB9AC \uB36E\uC5B4\uC4F0\uAE30").option("--skip-git-setup", "Git/CI-CD \uC124\uC815 \uAC74\uB108\uB6F0\uAE30").option("--auto-approve", "\uBAA8\uB4E0 \uC124\uC815\uC744 \uC790\uB3D9 \uC2B9\uC778").action(async (options) => {
     try {
       await runInit(options);
     } catch (error2) {
@@ -3333,7 +4038,7 @@ function registerInitCommand(program2) {
 }
 async function runInit(options) {
   const cwd = process.cwd();
-  if (await directoryExists(path2.join(cwd, ".sdd"))) {
+  if (await directoryExists(path4.join(cwd, ".sdd"))) {
     if (options.force) {
       warn("\uAE30\uC874 .sdd/ \uB514\uB809\uD1A0\uB9AC\uB97C \uB36E\uC5B4\uC501\uB2C8\uB2E4.");
     }
@@ -3367,6 +4072,9 @@ async function runInit(options) {
   listItem("/sdd.validate - \uC2A4\uD399 \uAC80\uC99D");
   listItem("/sdd.status - \uC0C1\uD0DC \uD655\uC778");
   listItem("/sdd.change - \uBCC0\uACBD \uC81C\uC548");
+  if (!options.skipGitSetup) {
+    await promptGitSetup(cwd, options.autoApprove || false);
+  }
   newline();
   info("\uB2E4\uC74C \uB2E8\uACC4:");
   listItem("constitution.md\uB97C \uC218\uC815\uD558\uC5EC \uD504\uB85C\uC81D\uD2B8 \uC6D0\uCE59\uC744 \uC815\uC758\uD558\uC138\uC694");
@@ -3374,11 +4082,11 @@ async function runInit(options) {
 }
 
 // src/cli/commands/validate.ts
-import path4 from "path";
+import path6 from "path";
 import chalk2 from "chalk";
 
 // src/core/spec/validator.ts
-import path3 from "path";
+import path5 from "path";
 
 // src/core/spec/parser.ts
 import matter from "gray-matter";
@@ -4058,7 +4766,7 @@ async function validateSpecFile(filePath, options = {}) {
     }
   }
   if (options.checkConstitution && options.sddRoot) {
-    const constitutionPath = path3.join(options.sddRoot, ".sdd", "constitution.md");
+    const constitutionPath = path5.join(options.sddRoot, ".sdd", "constitution.md");
     const constReadResult = await readFile(constitutionPath);
     if (constReadResult.success) {
       const constParseResult = parseConstitution(constReadResult.data);
@@ -4120,7 +4828,7 @@ async function validateSpecFile(filePath, options = {}) {
 async function validateLinks(content, filePath, specsRoot) {
   const brokenLinks = [];
   const lines = content.split("\n");
-  const fileDir = path3.dirname(filePath);
+  const fileDir = path5.dirname(filePath);
   const linkPattern = /\[([^\]]+)\]\(([^)]+)\)/g;
   const specRefPattern = /(?:`([a-z0-9-]+)`|\[\[([a-z0-9-]+)\]\])/g;
   for (let lineNum = 0; lineNum < lines.length; lineNum++) {
@@ -4131,7 +4839,7 @@ async function validateLinks(content, filePath, specsRoot) {
       if (target.startsWith("http://") || target.startsWith("https://") || target.startsWith("#")) {
         continue;
       }
-      const targetPath = path3.resolve(fileDir, target);
+      const targetPath = path5.resolve(fileDir, target);
       if (!await fileExists(targetPath)) {
         brokenLinks.push({
           text,
@@ -4150,8 +4858,8 @@ async function validateLinks(content, filePath, specsRoot) {
       if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)+$/.test(specId)) {
         continue;
       }
-      const specPath = path3.join(specsRoot, specId);
-      const specFilePath = path3.join(specPath, "spec.md");
+      const specPath = path5.join(specsRoot, specId);
+      const specFilePath = path5.join(specPath, "spec.md");
       if (!await directoryExists(specPath) && !await fileExists(specFilePath)) {
         brokenLinks.push({
           text: specId,
@@ -4204,11 +4912,11 @@ async function validateSpecs(targetPath, options = {}) {
 async function findSpecFiles(dirPath) {
   const files = [];
   async function scanDir(dir) {
-    const { promises: fs27 } = await import("fs");
+    const { promises: fs28 } = await import("fs");
     try {
-      const entries = await fs27.readdir(dir, { withFileTypes: true });
+      const entries = await fs28.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path3.join(dir, entry.name);
+        const fullPath = path5.join(dir, entry.name);
         if (entry.isDirectory()) {
           await scanDir(fullPath);
         } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -4239,20 +4947,20 @@ async function createValidateContext(targetPath, options, sddRoot) {
   let resolvedPath;
   let specsRoot;
   if (targetPath) {
-    resolvedPath = path4.resolve(targetPath);
+    resolvedPath = path6.resolve(targetPath);
   } else {
     if (!sddRoot) {
       return failure(new Error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694."));
     }
-    resolvedPath = path4.join(sddRoot, ".sdd", "specs");
+    resolvedPath = path6.join(sddRoot, ".sdd", "specs");
   }
   if (options.checkLinks && sddRoot) {
-    specsRoot = path4.join(sddRoot, ".sdd", "specs");
+    specsRoot = path6.join(sddRoot, ".sdd", "specs");
   }
   const checkConstitution = options.constitution !== false;
   let hasConstitution = false;
   if (checkConstitution && sddRoot) {
-    const constitutionPath = path4.join(sddRoot, ".sdd", "constitution.md");
+    const constitutionPath = path6.join(sddRoot, ".sdd", "constitution.md");
     hasConstitution = await fileExists(constitutionPath);
   }
   return success({
@@ -4329,7 +5037,7 @@ async function runValidate(targetPath, options) {
   }
 }
 function printFileResult(result, basePath) {
-  const relativePath = path4.relative(basePath, result.file);
+  const relativePath = path6.relative(basePath, result.file);
   if (result.valid) {
     console.log(chalk2.green("\u2713") + " " + relativePath);
   } else {
@@ -4957,8 +5665,8 @@ async function runPrompt(command, options) {
 }
 
 // src/cli/commands/change.ts
-import path6 from "path";
-import { promises as fs3 } from "fs";
+import path8 from "path";
+import { promises as fs4 } from "fs";
 
 // src/core/change/schemas.ts
 import { z as z3 } from "zod";
@@ -5372,32 +6080,32 @@ function validateDelta(content) {
 init_types();
 init_errors();
 init_fs();
-import path5 from "path";
-import { promises as fs2 } from "fs";
+import path7 from "path";
+import { promises as fs3 } from "fs";
 async function archiveChange(sddPath, changeId) {
   try {
-    const changesPath = path5.join(sddPath, "changes");
-    const archivePath = path5.join(sddPath, "archive");
-    const sourceDir = path5.join(changesPath, changeId);
+    const changesPath = path7.join(sddPath, "changes");
+    const archivePath = path7.join(sddPath, "archive");
+    const sourceDir = path7.join(changesPath, changeId);
     if (!await directoryExists(sourceDir)) {
       return failure(new ChangeError(`\uBCC0\uACBD \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${changeId}`));
     }
     const today = /* @__PURE__ */ new Date();
     const yearMonth = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, "0")}`;
-    const archiveMonthDir = path5.join(archivePath, yearMonth);
+    const archiveMonthDir = path7.join(archivePath, yearMonth);
     await ensureDir(archiveMonthDir);
     const datePrefix = today.toISOString().split("T")[0];
-    const archiveDir = path5.join(archiveMonthDir, `${datePrefix}-${changeId}`);
+    const archiveDir = path7.join(archiveMonthDir, `${datePrefix}-${changeId}`);
     const copyResult = await copyDir(sourceDir, archiveDir);
     if (!copyResult.success) {
       return failure(new ChangeError(`\uC544\uCE74\uC774\uBE0C \uBCF5\uC0AC \uC2E4\uD328: ${copyResult.error?.message}`));
     }
-    const proposalPath = path5.join(archiveDir, "proposal.md");
+    const proposalPath = path7.join(archiveDir, "proposal.md");
     try {
-      const proposalContent = await fs2.readFile(proposalPath, "utf-8");
+      const proposalContent = await fs3.readFile(proposalPath, "utf-8");
       const updateResult = updateProposalStatus(proposalContent, "archived");
       if (updateResult.success) {
-        await fs2.writeFile(proposalPath, updateResult.data);
+        await fs3.writeFile(proposalPath, updateResult.data);
       }
     } catch {
     }
@@ -5421,20 +6129,20 @@ async function archiveChange(sddPath, changeId) {
 }
 async function listArchives(sddPath) {
   try {
-    const archivePath = path5.join(sddPath, "archive");
+    const archivePath = path7.join(sddPath, "archive");
     if (!await directoryExists(archivePath)) {
       return success([]);
     }
     const archives = [];
-    const months = await fs2.readdir(archivePath);
+    const months = await fs3.readdir(archivePath);
     for (const month of months) {
-      const monthPath = path5.join(archivePath, month);
-      const stat = await fs2.stat(monthPath);
+      const monthPath = path7.join(archivePath, month);
+      const stat = await fs3.stat(monthPath);
       if (!stat.isDirectory()) continue;
-      const changes = await fs2.readdir(monthPath);
+      const changes = await fs3.readdir(monthPath);
       for (const change of changes) {
-        const changePath = path5.join(monthPath, change);
-        const changeStat = await fs2.stat(changePath);
+        const changePath = path7.join(monthPath, change);
+        const changeStat = await fs3.stat(changePath);
         if (!changeStat.isDirectory()) continue;
         const idMatch = change.match(/\d{4}-\d{2}-\d{2}-(CHG-\d+)/);
         const id = idMatch ? idMatch[1] : change;
@@ -5442,8 +6150,8 @@ async function listArchives(sddPath) {
         const archivedAt = dateMatch ? dateMatch[1] : month;
         let title2;
         try {
-          const proposalPath = path5.join(changePath, "proposal.md");
-          const proposalContent = await fs2.readFile(proposalPath, "utf-8");
+          const proposalPath = path7.join(changePath, "proposal.md");
+          const proposalContent = await fs3.readFile(proposalPath, "utf-8");
           const parseResult = parseProposal(proposalContent);
           if (parseResult.success) {
             title2 = parseResult.data.title;
@@ -5470,22 +6178,22 @@ async function listArchives(sddPath) {
 }
 async function listPendingChanges(sddPath) {
   try {
-    const changesPath = path5.join(sddPath, "changes");
+    const changesPath = path7.join(sddPath, "changes");
     if (!await directoryExists(changesPath)) {
       return success([]);
     }
     const changes = [];
-    const dirs = await fs2.readdir(changesPath);
+    const dirs = await fs3.readdir(changesPath);
     for (const dir of dirs) {
-      const changePath = path5.join(changesPath, dir);
-      const stat = await fs2.stat(changePath);
+      const changePath = path7.join(changesPath, dir);
+      const stat = await fs3.stat(changePath);
       if (!stat.isDirectory()) continue;
       let status = "draft";
       let title2;
       let createdAt;
       try {
-        const proposalPath = path5.join(changePath, "proposal.md");
-        const proposalContent = await fs2.readFile(proposalPath, "utf-8");
+        const proposalPath = path7.join(changePath, "proposal.md");
+        const proposalContent = await fs3.readFile(proposalPath, "utf-8");
         const parseResult = parseProposal(proposalContent);
         if (parseResult.success) {
           status = parseResult.data.metadata.status;
@@ -5529,7 +6237,7 @@ async function getChangeListItems(sddPath) {
   })));
 }
 async function getChangeInfo(changePath) {
-  const proposalPath = path6.join(changePath, "proposal.md");
+  const proposalPath = path8.join(changePath, "proposal.md");
   if (!await fileExists(proposalPath)) {
     return failure(new Error("proposal.md\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
   }
@@ -5550,31 +6258,31 @@ async function getChangeInfo(changePath) {
   });
 }
 async function createChange(sddPath, options) {
-  const changesPath = path6.join(sddPath, "changes");
+  const changesPath = path8.join(sddPath, "changes");
   await ensureDir(changesPath);
   const existingIds = [];
   try {
-    const dirs = await fs3.readdir(changesPath);
+    const dirs = await fs4.readdir(changesPath);
     existingIds.push(...dirs.filter((d) => d.startsWith("CHG-")));
   } catch {
   }
   const newId = generateChangeId(existingIds);
   const title2 = options.title || "\uC0C8 \uBCC0\uACBD \uC81C\uC548";
   const affectedSpecs = options.spec ? [options.spec] : [];
-  const changePath = path6.join(changesPath, newId);
+  const changePath = path8.join(changesPath, newId);
   await ensureDir(changePath);
   const proposal = generateProposal({
     id: newId,
     title: title2,
     affectedSpecs
   });
-  const proposalPath = path6.join(changePath, "proposal.md");
+  const proposalPath = path8.join(changePath, "proposal.md");
   await writeFile(proposalPath, proposal);
   const delta = generateDelta({
     proposalId: newId,
     title: title2
   });
-  const deltaPath = path6.join(changePath, "delta.md");
+  const deltaPath = path8.join(changePath, "delta.md");
   await writeFile(deltaPath, delta);
   return success({
     id: newId,
@@ -5583,7 +6291,7 @@ async function createChange(sddPath, options) {
   });
 }
 async function applyChange(changePath) {
-  const proposalPath = path6.join(changePath, "proposal.md");
+  const proposalPath = path8.join(changePath, "proposal.md");
   if (!await fileExists(proposalPath)) {
     return failure(new Error("proposal.md\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
   }
@@ -5599,7 +6307,7 @@ async function applyChange(changePath) {
   return success(void 0);
 }
 async function getDeltaInfo(changePath) {
-  const deltaPath = path6.join(changePath, "delta.md");
+  const deltaPath = path8.join(changePath, "delta.md");
   if (!await fileExists(deltaPath)) {
     return failure(new Error("delta.md\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
   }
@@ -5623,7 +6331,7 @@ async function validateChange(changePath) {
     deltaValid: false,
     hasDelta: false
   };
-  const proposalPath = path6.join(changePath, "proposal.md");
+  const proposalPath = path8.join(changePath, "proposal.md");
   if (await fileExists(proposalPath)) {
     const proposalResult = await readFile(proposalPath);
     if (proposalResult.success) {
@@ -5638,7 +6346,7 @@ async function validateChange(changePath) {
   } else {
     result.proposalError = "proposal.md\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.";
   }
-  const deltaPath = path6.join(changePath, "delta.md");
+  const deltaPath = path8.join(changePath, "delta.md");
   if (await fileExists(deltaPath)) {
     result.hasDelta = true;
     const deltaResult = await readFile(deltaPath);
@@ -5707,7 +6415,7 @@ async function runChange(id, options) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path6.join(projectRoot, ".sdd");
+  const sddPath = path8.join(projectRoot, ".sdd");
   if (options.list) {
     const result = await getChangeListItems(sddPath);
     if (!result.success) {
@@ -5727,7 +6435,7 @@ async function runChange(id, options) {
     return;
   }
   if (id) {
-    const changePath = path6.join(sddPath, "changes", id);
+    const changePath = path8.join(sddPath, "changes", id);
     if (!await directoryExists(changePath)) {
       error(`\uBCC0\uACBD\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${id}`);
       process.exit(ExitCode.GENERAL_ERROR);
@@ -5769,8 +6477,8 @@ async function runApply(id) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path6.join(projectRoot, ".sdd");
-  const changePath = path6.join(sddPath, "changes", id);
+  const sddPath = path8.join(projectRoot, ".sdd");
+  const changePath = path8.join(sddPath, "changes", id);
   if (!await directoryExists(changePath)) {
     error(`\uBCC0\uACBD\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${id}`);
     process.exit(ExitCode.GENERAL_ERROR);
@@ -5792,7 +6500,7 @@ async function runArchive(id) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path6.join(projectRoot, ".sdd");
+  const sddPath = path8.join(projectRoot, ".sdd");
   const result = await archiveChange(sddPath, id);
   if (!result.success) {
     error(result.error.message);
@@ -5807,8 +6515,8 @@ async function runDiff(id) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path6.join(projectRoot, ".sdd");
-  const changePath = path6.join(sddPath, "changes", id);
+  const sddPath = path8.join(projectRoot, ".sdd");
+  const changePath = path8.join(sddPath, "changes", id);
   if (!await directoryExists(changePath)) {
     error(`\uBCC0\uACBD\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${id}`);
     process.exit(ExitCode.GENERAL_ERROR);
@@ -5860,8 +6568,8 @@ async function runValidateChange(id) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path6.join(projectRoot, ".sdd");
-  const changePath = path6.join(sddPath, "changes", id);
+  const sddPath = path8.join(projectRoot, ".sdd");
+  const changePath = path8.join(sddPath, "changes", id);
   if (!await directoryExists(changePath)) {
     error(`\uBCC0\uACBD\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${id}`);
     process.exit(ExitCode.GENERAL_ERROR);
@@ -5909,7 +6617,7 @@ async function runValidateChange(id) {
 }
 
 // src/cli/commands/impact.ts
-import path10 from "path";
+import path12 from "path";
 
 // src/core/impact/schemas.ts
 import { z as z6 } from "zod";
@@ -5948,8 +6656,8 @@ function getImpactLevel(score) {
 init_types();
 init_errors();
 init_fs();
-import { promises as fs4 } from "fs";
-import path7 from "path";
+import { promises as fs5 } from "fs";
+import path9 from "path";
 import matter5 from "gray-matter";
 async function buildDependencyGraph(specsPath) {
   try {
@@ -5962,8 +6670,8 @@ async function buildDependencyGraph(specsPath) {
     }
     const specFiles = await collectSpecFiles(specsPath);
     for (const filePath of specFiles) {
-      const content = await fs4.readFile(filePath, "utf-8");
-      const relativePath = path7.relative(specsPath, filePath);
+      const content = await fs5.readFile(filePath, "utf-8");
+      const relativePath = path9.relative(specsPath, filePath);
       const specId = getSpecId(relativePath);
       const node = {
         id: specId,
@@ -5987,7 +6695,7 @@ async function buildDependencyGraph(specsPath) {
           }
         }
       }
-      const references = extractReferences(content, specFiles.map((f) => getSpecId(path7.relative(specsPath, f))));
+      const references = extractReferences(content, specFiles.map((f) => getSpecId(path9.relative(specsPath, f))));
       for (const ref of references) {
         if (ref !== specId && !node.dependsOn.includes(ref)) {
           node.dependsOn.push(ref);
@@ -6018,9 +6726,9 @@ async function buildDependencyGraph(specsPath) {
 }
 async function collectSpecFiles(dirPath) {
   const files = [];
-  const entries = await fs4.readdir(dirPath, { withFileTypes: true });
+  const entries = await fs5.readdir(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path7.join(dirPath, entry.name);
+    const fullPath = path9.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       files.push(...await collectSpecFiles(fullPath));
     } else if (entry.name.endsWith(".md") && entry.name !== "AGENTS.md") {
@@ -6084,13 +6792,13 @@ function sanitizeId(id) {
 }
 
 // src/core/impact/analyzer.ts
-import path8 from "path";
+import path10 from "path";
 init_types();
 init_errors();
 init_fs();
 async function analyzeImpact(sddPath, targetSpec) {
   try {
-    const specsPath = path8.join(sddPath, "specs");
+    const specsPath = path10.join(sddPath, "specs");
     if (!await directoryExists(specsPath)) {
       return failure(new ChangeError("\uC2A4\uD399 \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
     }
@@ -6286,7 +6994,7 @@ function formatImpactResult(result) {
 }
 async function generateImpactReport(sddPath) {
   try {
-    const specsPath = path8.join(sddPath, "specs");
+    const specsPath = path10.join(sddPath, "specs");
     if (!await directoryExists(specsPath)) {
       return failure(new ChangeError("\uC2A4\uD399 \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
     }
@@ -6330,19 +7038,19 @@ function detectCircularDependencies(graph) {
   const cycles = [];
   const visited = /* @__PURE__ */ new Set();
   const recStack = /* @__PURE__ */ new Set();
-  function dfs(nodeId, path42) {
+  function dfs(nodeId, path44) {
     visited.add(nodeId);
     recStack.add(nodeId);
     const node = graph.nodes.get(nodeId);
     if (!node) return false;
     for (const depId of node.dependsOn) {
       if (!visited.has(depId)) {
-        if (dfs(depId, [...path42, nodeId])) {
+        if (dfs(depId, [...path44, nodeId])) {
           return true;
         }
       } else if (recStack.has(depId)) {
-        const cycleStart = path42.indexOf(depId);
-        const cycle = cycleStart >= 0 ? [...path42.slice(cycleStart), nodeId, depId] : [nodeId, depId];
+        const cycleStart = path44.indexOf(depId);
+        const cycle = cycleStart >= 0 ? [...path44.slice(cycleStart), nodeId, depId] : [nodeId, depId];
         cycles.push({
           cycle,
           description: `\uC21C\uD658 \uC758\uC874\uC131: ${cycle.join(" \u2192 ")}`
@@ -6388,8 +7096,8 @@ function generateReportSummary(totalSpecs, totalEdges, orphanCount, circularCoun
 }
 async function analyzeChangeImpact(sddPath, changeId) {
   try {
-    const changePath = path8.join(sddPath, "changes", changeId);
-    const proposalPath = path8.join(changePath, "proposal.md");
+    const changePath = path10.join(sddPath, "changes", changeId);
+    const proposalPath = path10.join(changePath, "proposal.md");
     if (!await fileExists(proposalPath)) {
       return failure(new ChangeError(`\uBCC0\uACBD \uC81C\uC548\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${changeId}`));
     }
@@ -6402,7 +7110,7 @@ async function analyzeChangeImpact(sddPath, changeId) {
       return failure(new ChangeError(`\uC81C\uC548\uC11C \uD30C\uC2F1 \uC2E4\uD328: ${parseResult.error.message}`));
     }
     const proposal = parseResult.data;
-    const specsPath = path8.join(sddPath, "specs");
+    const specsPath = path10.join(sddPath, "specs");
     const graphResult = await buildDependencyGraph(specsPath);
     if (!graphResult.success) {
       return failure(graphResult.error);
@@ -6501,7 +7209,7 @@ function formatImpactReport(report) {
 }
 
 // src/core/impact/simulator.ts
-import { promises as fs5 } from "fs";
+import { promises as fs6 } from "fs";
 init_types();
 init_errors();
 init_fs();
@@ -6510,7 +7218,7 @@ async function parseDeltaFromProposal(proposalPath) {
     if (!await fileExists(proposalPath)) {
       return failure(new ChangeError(`\uC81C\uC548\uC11C \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${proposalPath}`));
     }
-    const content = await fs5.readFile(proposalPath, "utf-8");
+    const content = await fs6.readFile(proposalPath, "utf-8");
     const deltas = [];
     const addedSection = content.match(/##\s*ADDED([\s\S]*?)(?=##\s*(?:MODIFIED|REMOVED)|---|\n$)/i);
     if (addedSection) {
@@ -6907,8 +7615,8 @@ function formatSimulationResult(result, targetSpec) {
 init_types();
 init_errors();
 init_fs();
-import path9 from "path";
-import { promises as fs6 } from "fs";
+import path11 from "path";
+import { promises as fs7 } from "fs";
 var SPEC_REFERENCE_PATTERNS = [
   /\/\/\s*spec:\s*([\w-]+)/gi,
   // // spec: feature-id
@@ -6930,7 +7638,7 @@ async function analyzeCodeImpact(projectRoot, sddPath, targetSpec) {
     );
     const directFiles = links.map((link) => ({
       path: link.filePath,
-      relativePath: path9.relative(projectRoot, link.filePath),
+      relativePath: path11.relative(projectRoot, link.filePath),
       impactLevel: getLinkImpactLevel(link.confidence),
       impactType: "direct",
       reason: getLinkReason(link.linkType),
@@ -6969,7 +7677,7 @@ async function analyzeCodeImpact(projectRoot, sddPath, targetSpec) {
   }
 }
 async function loadCodeMappingConfig(sddPath) {
-  const configPath = path9.join(sddPath, "code-mapping.json");
+  const configPath = path11.join(sddPath, "code-mapping.json");
   if (!await fileExists(configPath)) {
     return null;
   }
@@ -7000,15 +7708,15 @@ async function scanCodeFiles(projectRoot, maxDepth = 10) {
   async function scan(dir, depth) {
     if (depth > maxDepth) return;
     try {
-      const entries = await fs6.readdir(dir, { withFileTypes: true });
+      const entries = await fs7.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path9.join(dir, entry.name);
+        const fullPath = path11.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (!excludeDirs.has(entry.name) && !entry.name.startsWith(".")) {
             await scan(fullPath, depth + 1);
           }
         } else if (entry.isFile()) {
-          const ext = path9.extname(entry.name).toLowerCase();
+          const ext = path11.extname(entry.name).toLowerCase();
           if (isCodeFile(ext)) {
             const codeFile = await analyzeCodeFile(fullPath, projectRoot);
             if (codeFile) {
@@ -7038,14 +7746,14 @@ function isCodeFile(ext) {
 }
 async function analyzeCodeFile(filePath, projectRoot) {
   try {
-    const content = await fs6.readFile(filePath, "utf-8");
-    const ext = path9.extname(filePath).toLowerCase();
+    const content = await fs7.readFile(filePath, "utf-8");
+    const ext = path11.extname(filePath).toLowerCase();
     const specReferences = extractSpecReferences(content);
     const imports = extractImports(content);
     const exports = extractExports(content);
     return {
       path: filePath,
-      relativePath: path9.relative(projectRoot, filePath),
+      relativePath: path11.relative(projectRoot, filePath),
       type: ext === ".ts" || ext === ".tsx" ? "typescript" : ext === ".js" || ext === ".jsx" ? "javascript" : "other",
       specReferences,
       imports,
@@ -7145,8 +7853,8 @@ async function findSpecLinks(targetSpec, codeFiles, mappingConfig) {
     }
   }
   for (const file of codeFiles) {
-    const fileName = path9.basename(file.path, path9.extname(file.path)).toLowerCase();
-    const dirName = path9.basename(path9.dirname(file.path)).toLowerCase();
+    const fileName = path11.basename(file.path, path11.extname(file.path)).toLowerCase();
+    const dirName = path11.basename(path11.dirname(file.path)).toLowerCase();
     if (fileName === normalizedSpec || fileName === normalizedSpec.replace(/-/g, "")) {
       if (!links.some((l) => l.filePath === file.path)) {
         links.push({
@@ -7184,10 +7892,10 @@ async function findIndirectImpact(projectRoot, directFilePaths, allFiles) {
             visited.add(file.path);
             indirectFiles.push({
               path: file.path,
-              relativePath: path9.relative(projectRoot, file.path),
+              relativePath: path11.relative(projectRoot, file.path),
               impactLevel: "medium",
               impactType: "indirect",
-              reason: `${path9.basename(directPath)}\uB97C import\uD568`
+              reason: `${path11.basename(directPath)}\uB97C import\uD568`
             });
           }
         }
@@ -7200,8 +7908,8 @@ function resolveImport(fromFile, importPath) {
   if (!importPath.startsWith(".")) {
     return importPath;
   }
-  const dir = path9.dirname(fromFile);
-  return path9.resolve(dir, importPath);
+  const dir = path11.dirname(fromFile);
+  return path11.resolve(dir, importPath);
 }
 function isImportMatch(resolvedImport, targetFile) {
   const importWithoutExt = resolvedImport.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
@@ -7332,14 +8040,14 @@ init_fs();
 init_errors();
 init_types();
 function resolveProposalPath(proposalPath, sddPath) {
-  if (path10.isAbsolute(proposalPath)) {
+  if (path12.isAbsolute(proposalPath)) {
     return proposalPath;
   }
-  const changesPath = path10.join(sddPath, "changes", proposalPath);
+  const changesPath = path12.join(sddPath, "changes", proposalPath);
   if (proposalPath.endsWith(".md")) {
     return changesPath;
   }
-  return path10.join(changesPath, "proposal.md");
+  return path12.join(changesPath, "proposal.md");
 }
 async function executeImpactAnalysis(sddPath, feature) {
   const result = await analyzeImpact(sddPath, feature);
@@ -7472,8 +8180,8 @@ async function runImpact(feature, options) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path10.join(projectRoot, ".sdd");
-  const specsPath = path10.join(sddPath, "specs");
+  const sddPath = path12.join(projectRoot, ".sdd");
+  const specsPath = path12.join(sddPath, "specs");
   if (options.graph) {
     const graphResult = await executeGraphAnalysis(specsPath, feature, options.json);
     if (!graphResult.success) {
@@ -7540,7 +8248,7 @@ async function runImpactReport(options) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path10.join(projectRoot, ".sdd");
+  const sddPath = path12.join(projectRoot, ".sdd");
   const result = await executeImpactReport(sddPath);
   if (!result.success) {
     error(result.error.message);
@@ -7558,7 +8266,7 @@ async function runChangeImpact(changeId, options) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path10.join(projectRoot, ".sdd");
+  const sddPath = path12.join(projectRoot, ".sdd");
   const result = await executeChangeImpact(sddPath, changeId);
   if (!result.success) {
     error(result.error.message);
@@ -7576,8 +8284,8 @@ async function runSimulate(feature, proposalPath, options) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path10.join(projectRoot, ".sdd");
-  const specsPath = path10.join(sddPath, "specs");
+  const sddPath = path12.join(projectRoot, ".sdd");
+  const specsPath = path12.join(sddPath, "specs");
   const fullProposalPath = resolveProposalPath(proposalPath, sddPath);
   info(`\u{1F4CA} What-if \uC2DC\uBBAC\uB808\uC774\uC158`);
   info(`\uB300\uC0C1 \uC2A4\uD399: ${feature}`);
@@ -7609,7 +8317,7 @@ async function runSimulate(feature, proposalPath, options) {
 
 // src/cli/commands/new.ts
 init_new();
-import path12 from "path";
+import path14 from "path";
 
 // src/utils/index.ts
 init_fs();
@@ -7618,7 +8326,7 @@ init_fs();
 init_fs();
 init_types();
 async function getConstitutionVersion(sddPath) {
-  const constitutionPath = path12.join(sddPath, "constitution.md");
+  const constitutionPath = path14.join(sddPath, "constitution.md");
   if (!await fileExists(constitutionPath)) {
     return void 0;
   }
@@ -7647,7 +8355,7 @@ async function createFeature(sddPath, name, options) {
   }
   const title2 = options.title || name;
   const description = options.description || `${title2} \uAE30\uB2A5 \uBA85\uC138`;
-  const featurePath = path12.join(sddPath, "specs", featureId);
+  const featurePath = path14.join(sddPath, "specs", featureId);
   const dirResult = await ensureDir(featurePath);
   if (!dirResult.success) {
     return failure(new Error(`\uB514\uB809\uD1A0\uB9AC \uC0DD\uC131 \uC2E4\uD328: ${featurePath}`));
@@ -7660,7 +8368,7 @@ async function createFeature(sddPath, name, options) {
     description,
     constitutionVersion
   });
-  await writeFile(path12.join(featurePath, "spec.md"), specContent);
+  await writeFile(path14.join(featurePath, "spec.md"), specContent);
   filesCreated.push("spec.md");
   if (options.plan || options.all) {
     const planContent = generatePlan({
@@ -7668,7 +8376,7 @@ async function createFeature(sddPath, name, options) {
       featureTitle: title2,
       overview: description
     });
-    await writeFile(path12.join(featurePath, "plan.md"), planContent);
+    await writeFile(path14.join(featurePath, "plan.md"), planContent);
     filesCreated.push("plan.md");
   }
   if (options.tasks || options.all) {
@@ -7682,12 +8390,12 @@ async function createFeature(sddPath, name, options) {
         { title: "\uBB38\uC11C \uC5C5\uB370\uC774\uD2B8", priority: "low" }
       ]
     });
-    await writeFile(path12.join(featurePath, "tasks.md"), tasksContent);
+    await writeFile(path14.join(featurePath, "tasks.md"), tasksContent);
     filesCreated.push("tasks.md");
   }
   if (options.checklist || options.all) {
     const checklistContent = generateFullChecklistMarkdown();
-    await writeFile(path12.join(featurePath, "checklist.md"), checklistContent);
+    await writeFile(path14.join(featurePath, "checklist.md"), checklistContent);
     filesCreated.push("checklist.md");
   }
   return success({
@@ -7702,7 +8410,7 @@ async function createPlan(featurePath, featureId, title2) {
     return failure(new Error(`\uAE30\uB2A5 '${featureId}'\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`));
   }
   let featureTitle = title2 || featureId;
-  const specPath = path12.join(featurePath, "spec.md");
+  const specPath = path14.join(featurePath, "spec.md");
   if (await fileExists(specPath)) {
     const specResult = await readFile(specPath);
     if (specResult.success) {
@@ -7717,7 +8425,7 @@ async function createPlan(featurePath, featureId, title2) {
     featureTitle,
     overview: `${featureTitle} \uAD6C\uD604 \uACC4\uD68D`
   });
-  const planPath = path12.join(featurePath, "plan.md");
+  const planPath = path14.join(featurePath, "plan.md");
   await writeFile(planPath, planContent);
   return success(planPath);
 }
@@ -7726,7 +8434,7 @@ async function createTasks(featurePath, featureId) {
     return failure(new Error(`\uAE30\uB2A5 '${featureId}'\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`));
   }
   let featureTitle = featureId;
-  const specPath = path12.join(featurePath, "spec.md");
+  const specPath = path14.join(featurePath, "spec.md");
   if (await fileExists(specPath)) {
     const specResult = await readFile(specPath);
     if (specResult.success) {
@@ -7746,7 +8454,7 @@ async function createTasks(featurePath, featureId) {
       { title: "\uBB38\uC11C \uC5C5\uB370\uC774\uD2B8", priority: "low" }
     ]
   });
-  const tasksPath = path12.join(featurePath, "tasks.md");
+  const tasksPath = path14.join(featurePath, "tasks.md");
   await writeFile(tasksPath, tasksContent);
   return success(tasksPath);
 }
@@ -7755,7 +8463,7 @@ async function createChecklist2(sddPath) {
     return failure(new Error(".sdd \uB514\uB809\uD1A0\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4."));
   }
   const checklistContent = generateFullChecklistMarkdown();
-  const outputPath = path12.join(sddPath, "checklist.md");
+  const outputPath = path14.join(sddPath, "checklist.md");
   await writeFile(outputPath, checklistContent);
   return success(outputPath);
 }
@@ -7796,7 +8504,7 @@ async function handleNew(name, options) {
     process.exit(1);
   }
   const cwd = process.cwd();
-  const sddPath = path12.join(cwd, ".sdd");
+  const sddPath = path14.join(cwd, ".sdd");
   if (!await fileExists(sddPath)) {
     logger_exports.error(".sdd \uB514\uB809\uD1A0\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 sdd init\uC744 \uC2E4\uD589\uD574\uC8FC\uC138\uC694.");
     process.exit(1);
@@ -7844,7 +8552,7 @@ async function handleNew(name, options) {
 }
 async function handlePlan(feature, options) {
   const cwd = process.cwd();
-  const featurePath = path12.join(cwd, ".sdd", "specs", feature);
+  const featurePath = path14.join(cwd, ".sdd", "specs", feature);
   const result = await createPlan(featurePath, feature, options.title);
   if (!result.success) {
     logger_exports.error(result.error.message);
@@ -7858,7 +8566,7 @@ async function handlePlan(feature, options) {
 }
 async function handleTasks(feature) {
   const cwd = process.cwd();
-  const featurePath = path12.join(cwd, ".sdd", "specs", feature);
+  const featurePath = path14.join(cwd, ".sdd", "specs", feature);
   const result = await createTasks(featurePath, feature);
   if (!result.success) {
     logger_exports.error(result.error.message);
@@ -7872,7 +8580,7 @@ async function handleTasks(feature) {
 }
 async function handleChecklist() {
   const cwd = process.cwd();
-  const sddPath = path12.join(cwd, ".sdd");
+  const sddPath = path14.join(cwd, ".sdd");
   const result = await createChecklist2(sddPath);
   if (!result.success) {
     logger_exports.error(result.error.message);
@@ -7882,7 +8590,7 @@ async function handleChecklist() {
 }
 async function handleCounter(options) {
   const cwd = process.cwd();
-  const sddPath = path12.join(cwd, ".sdd");
+  const sddPath = path14.join(cwd, ".sdd");
   if (!await fileExists(sddPath)) {
     logger_exports.error(".sdd \uB514\uB809\uD1A0\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 sdd init\uC744 \uC2E4\uD589\uD574\uC8FC\uC138\uC694.");
     process.exit(1);
@@ -7955,8 +8663,8 @@ async function handleCounter(options) {
 }
 
 // src/cli/commands/status.ts
-import path13 from "path";
-import { promises as fs7 } from "fs";
+import path15 from "path";
+import { promises as fs8 } from "fs";
 init_fs();
 init_spec_generator();
 init_task_generator();
@@ -7970,21 +8678,21 @@ async function getFeatureInfo(id, featurePath) {
     hasPlan: false,
     hasTasks: false
   };
-  const specPath = path13.join(featurePath, "spec.md");
+  const specPath = path15.join(featurePath, "spec.md");
   if (await fileExists(specPath)) {
     info2.hasSpec = true;
-    const content = await fs7.readFile(specPath, "utf-8");
+    const content = await fs8.readFile(specPath, "utf-8");
     const metadata = parseSpecMetadata(content);
     if (metadata) {
       info2.title = metadata.title;
       info2.status = metadata.status;
     }
   }
-  info2.hasPlan = await fileExists(path13.join(featurePath, "plan.md"));
-  const tasksPath = path13.join(featurePath, "tasks.md");
+  info2.hasPlan = await fileExists(path15.join(featurePath, "plan.md"));
+  const tasksPath = path15.join(featurePath, "tasks.md");
   if (await fileExists(tasksPath)) {
     info2.hasTasks = true;
-    const content = await fs7.readFile(tasksPath, "utf-8");
+    const content = await fs8.readFile(tasksPath, "utf-8");
     const tasks = parseTasks(content);
     const completed = tasks.filter((t) => t.status === "completed").length;
     info2.taskProgress = {
@@ -7995,7 +8703,7 @@ async function getFeatureInfo(id, featurePath) {
   return info2;
 }
 async function getProjectStatus(projectPath) {
-  const sddPath = path13.join(projectPath, ".sdd");
+  const sddPath = path15.join(projectPath, ".sdd");
   const status = {
     initialized: false,
     hasConstitution: false,
@@ -8009,15 +8717,15 @@ async function getProjectStatus(projectPath) {
   if (!status.initialized) {
     return status;
   }
-  status.hasConstitution = await fileExists(path13.join(sddPath, "constitution.md"));
-  status.hasAgents = await fileExists(path13.join(sddPath, "AGENTS.md"));
-  const specsPath = path13.join(sddPath, "specs");
+  status.hasConstitution = await fileExists(path15.join(sddPath, "constitution.md"));
+  status.hasAgents = await fileExists(path15.join(sddPath, "AGENTS.md"));
+  const specsPath = path15.join(sddPath, "specs");
   if (await fileExists(specsPath)) {
     const specsResult = await readDir(specsPath);
     if (specsResult.success) {
       for (const entry of specsResult.data) {
-        const featurePath = path13.join(specsPath, entry);
-        const stat = await fs7.stat(featurePath);
+        const featurePath = path15.join(specsPath, entry);
+        const stat = await fs8.stat(featurePath);
         if (stat.isDirectory()) {
           const featureInfo = await getFeatureInfo(entry, featurePath);
           status.features.push(featureInfo);
@@ -8165,8 +8873,8 @@ function printStatus(status, verbose) {
 }
 
 // src/cli/commands/list.ts
-import path14 from "path";
-import { promises as fs8 } from "fs";
+import path16 from "path";
+import { promises as fs9 } from "fs";
 init_fs();
 init_spec_generator();
 function getListStatusIcon(status) {
@@ -8188,7 +8896,7 @@ function getListStatusIcon(status) {
   }
 }
 async function getFeatureList(projectPath, options = {}) {
-  const specsPath = path14.join(projectPath, ".sdd", "specs");
+  const specsPath = path16.join(projectPath, ".sdd", "specs");
   if (!await fileExists(specsPath)) {
     return [];
   }
@@ -8198,12 +8906,12 @@ async function getFeatureList(projectPath, options = {}) {
   }
   const features = [];
   for (const entry of result.data) {
-    const featurePath = path14.join(specsPath, entry);
-    const stat = await fs8.stat(featurePath);
+    const featurePath = path16.join(specsPath, entry);
+    const stat = await fs9.stat(featurePath);
     if (stat.isDirectory()) {
-      const specPath = path14.join(featurePath, "spec.md");
+      const specPath = path16.join(featurePath, "spec.md");
       if (await fileExists(specPath)) {
-        const content = await fs8.readFile(specPath, "utf-8");
+        const content = await fs9.readFile(specPath, "utf-8");
         const metadata = parseSpecMetadata(content);
         if (metadata) {
           if (!options.status || metadata.status === options.status) {
@@ -8220,7 +8928,7 @@ async function getFeatureList(projectPath, options = {}) {
   return features;
 }
 async function getChangeList(projectPath, options = {}) {
-  const sddPath = path14.join(projectPath, ".sdd");
+  const sddPath = path16.join(projectPath, ".sdd");
   const result = {
     pending: [],
     archived: []
@@ -8253,8 +8961,8 @@ async function walkSpecsTree(basePath) {
   if (!result.success) return [];
   const items = [];
   for (const entry of result.data) {
-    const fullPath = path14.join(basePath, entry);
-    const stat = await fs8.stat(fullPath);
+    const fullPath = path16.join(basePath, entry);
+    const stat = await fs9.stat(fullPath);
     if (stat.isDirectory()) {
       const children = await walkSpecsTree(fullPath);
       items.push({
@@ -8274,7 +8982,7 @@ async function walkSpecsTree(basePath) {
   return items;
 }
 async function getTemplateList(projectPath) {
-  const templatesPath = path14.join(projectPath, ".sdd", "templates");
+  const templatesPath = path16.join(projectPath, ".sdd", "templates");
   if (!await fileExists(templatesPath)) {
     return [];
   }
@@ -8285,17 +8993,17 @@ async function getTemplateList(projectPath) {
   return result.data.filter((f) => f.endsWith(".md"));
 }
 async function getProjectSummary(projectPath) {
-  const sddPath = path14.join(projectPath, ".sdd");
+  const sddPath = path16.join(projectPath, ".sdd");
   if (!await fileExists(sddPath)) {
     return null;
   }
-  const specsPath = path14.join(sddPath, "specs");
+  const specsPath = path16.join(sddPath, "specs");
   let featureCount = 0;
   if (await fileExists(specsPath)) {
     const result = await readDir(specsPath);
     if (result.success) {
       for (const entry of result.data) {
-        const stat = await fs8.stat(path14.join(specsPath, entry));
+        const stat = await fs9.stat(path16.join(specsPath, entry));
         if (stat.isDirectory()) featureCount++;
       }
     }
@@ -8372,7 +9080,7 @@ async function listChanges(options) {
   }
 }
 async function listSpecs() {
-  const specsPath = path14.join(process.cwd(), ".sdd", "specs");
+  const specsPath = path16.join(process.cwd(), ".sdd", "specs");
   const tree = await getSpecFileTree(specsPath);
   if (tree.length === 0) {
     logger_exports.warn("\uC2A4\uD399 \uB514\uB809\uD1A0\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
@@ -8434,7 +9142,7 @@ async function listSummary() {
 // src/cli/commands/constitution.ts
 init_fs();
 init_errors();
-import path15 from "path";
+import path17 from "path";
 init_types();
 function determineBumpType(options) {
   if (options.major) return "major";
@@ -8443,7 +9151,7 @@ function determineBumpType(options) {
   return null;
 }
 async function readConstitution(projectPath) {
-  const constitutionPath = path15.join(projectPath, ".sdd", "constitution.md");
+  const constitutionPath = path17.join(projectPath, ".sdd", "constitution.md");
   if (!await fileExists(constitutionPath)) {
     return failure(new Error("Constitution\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC73C\uB85C \uD504\uB85C\uC81D\uD2B8\uB97C \uCD08\uAE30\uD654\uD558\uC138\uC694."));
   }
@@ -8473,8 +9181,8 @@ function constitutionToJson(constitution) {
   };
 }
 async function executeBump(projectPath, bumpType, message) {
-  const constitutionPath = path15.join(projectPath, ".sdd", "constitution.md");
-  const changelogPath = path15.join(projectPath, ".sdd", "CHANGELOG.md");
+  const constitutionPath = path17.join(projectPath, ".sdd", "constitution.md");
+  const changelogPath = path17.join(projectPath, ".sdd", "CHANGELOG.md");
   const readResult = await readConstitution(projectPath);
   if (!readResult.success) {
     return failure(readResult.error);
@@ -8540,7 +9248,7 @@ async function executeValidateConstitution(projectPath) {
   return success(readResult.data.parsed);
 }
 async function getHistory(projectPath, count = 10) {
-  const changelogPath = path15.join(projectPath, ".sdd", "CHANGELOG.md");
+  const changelogPath = path17.join(projectPath, ".sdd", "CHANGELOG.md");
   if (!await fileExists(changelogPath)) {
     return success({ entries: [], totalCount: 0 });
   }
@@ -8719,8 +9427,8 @@ async function runValidate2() {
 }
 
 // src/cli/commands/start.ts
-import path16 from "path";
-import { promises as fs9 } from "fs";
+import path18 from "path";
+import { promises as fs10 } from "fs";
 init_errors();
 init_fs();
 function registerStartCommand(program2) {
@@ -8769,11 +9477,11 @@ async function getProjectStatus2() {
       specs: []
     };
   }
-  const sddPath = path16.join(projectRoot, ".sdd");
-  const specsPath = path16.join(sddPath, "specs");
+  const sddPath = path18.join(projectRoot, ".sdd");
+  const specsPath = path18.join(sddPath, "specs");
   let hasConstitution = false;
   let constitutionVersion;
-  const constitutionPath = path16.join(sddPath, "constitution.md");
+  const constitutionPath = path18.join(sddPath, "constitution.md");
   if (await fileExists(constitutionPath)) {
     hasConstitution = true;
     const content = await readFile(constitutionPath);
@@ -8787,9 +9495,9 @@ async function getProjectStatus2() {
   const specs = [];
   if (await directoryExists(specsPath)) {
     try {
-      const dirs = await fs9.readdir(specsPath);
+      const dirs = await fs10.readdir(specsPath);
       for (const dir of dirs) {
-        const specPath = path16.join(specsPath, dir, "spec.md");
+        const specPath = path18.join(specsPath, dir, "spec.md");
         if (await fileExists(specPath)) {
           specs.push(dir);
         }
@@ -9023,8 +9731,8 @@ function displayConstitutionGuide() {
 }
 
 // src/cli/commands/migrate.ts
-import path18 from "path";
-import { promises as fs11 } from "fs";
+import path20 from "path";
+import { promises as fs12 } from "fs";
 init_errors();
 init_fs();
 init_new();
@@ -9034,8 +9742,8 @@ init_schemas();
 init_types();
 init_errors();
 init_fs();
-import path17 from "path";
-import fs10 from "fs/promises";
+import path19 from "path";
+import fs11 from "fs/promises";
 async function detectExternalTools(projectRoot) {
   try {
     const results = [];
@@ -9057,13 +9765,13 @@ async function detectExternalTools(projectRoot) {
   }
 }
 async function detectOpenSpec(projectRoot) {
-  const openspecPath = path17.join(projectRoot, "openspec");
+  const openspecPath = path19.join(projectRoot, "openspec");
   if (!await directoryExists(openspecPath)) {
     return null;
   }
-  const specsPath = path17.join(openspecPath, "specs");
-  const changesPath = path17.join(openspecPath, "changes");
-  const agentsPath = path17.join(openspecPath, "AGENTS.md");
+  const specsPath = path19.join(openspecPath, "specs");
+  const changesPath = path19.join(openspecPath, "changes");
+  const agentsPath = path19.join(openspecPath, "AGENTS.md");
   const hasAgents = await fileExists(agentsPath);
   const hasSpecs = await directoryExists(specsPath);
   const hasChanges = await directoryExists(changesPath);
@@ -9072,13 +9780,13 @@ async function detectOpenSpec(projectRoot) {
   }
   const specs = [];
   if (hasSpecs) {
-    const specDirs = await fs10.readdir(specsPath, { withFileTypes: true });
+    const specDirs = await fs11.readdir(specsPath, { withFileTypes: true });
     for (const entry of specDirs) {
       if (entry.isDirectory()) {
-        const specPath = path17.join(specsPath, entry.name);
-        const specFile = path17.join(specPath, "spec.md");
+        const specPath = path19.join(specsPath, entry.name);
+        const specFile = path19.join(specPath, "spec.md");
         if (await fileExists(specFile)) {
-          const content = await fs10.readFile(specFile, "utf-8");
+          const content = await fs11.readFile(specFile, "utf-8");
           const title2 = extractTitle2(content);
           const status = extractFrontmatterField(content, "status");
           specs.push({
@@ -9100,26 +9808,26 @@ async function detectOpenSpec(projectRoot) {
   };
 }
 async function detectSpecKit(projectRoot) {
-  const specifyPath = path17.join(projectRoot, ".specify");
+  const specifyPath = path19.join(projectRoot, ".specify");
   if (!await directoryExists(specifyPath)) {
     return null;
   }
-  const specsPath = path17.join(specifyPath, "specs");
-  const memoryPath = path17.join(projectRoot, "memory");
-  const constitutionPath = path17.join(memoryPath, "constitution.md");
+  const specsPath = path19.join(specifyPath, "specs");
+  const memoryPath = path19.join(projectRoot, "memory");
+  const constitutionPath = path19.join(memoryPath, "constitution.md");
   const hasSpecs = await directoryExists(specsPath);
   const hasConstitution = await fileExists(constitutionPath);
   if (!hasSpecs) {
     return null;
   }
   const specs = [];
-  const specDirs = await fs10.readdir(specsPath, { withFileTypes: true });
+  const specDirs = await fs11.readdir(specsPath, { withFileTypes: true });
   for (const entry of specDirs) {
     if (entry.isDirectory()) {
-      const specPath = path17.join(specsPath, entry.name);
-      const specFile = path17.join(specPath, "spec.md");
-      const planFile = path17.join(specPath, "plan.md");
-      const tasksFile = path17.join(specPath, "tasks.md");
+      const specPath = path19.join(specsPath, entry.name);
+      const specFile = path19.join(specPath, "spec.md");
+      const planFile = path19.join(specPath, "plan.md");
+      const tasksFile = path19.join(specPath, "tasks.md");
       const hasSpec = await fileExists(specFile);
       const hasPlan = await fileExists(planFile);
       const hasTasks = await fileExists(tasksFile);
@@ -9127,7 +9835,7 @@ async function detectSpecKit(projectRoot) {
         let title2;
         let status;
         if (hasSpec) {
-          const content = await fs10.readFile(specFile, "utf-8");
+          const content = await fs11.readFile(specFile, "utf-8");
           title2 = extractTitle2(content);
           status = extractFrontmatterField(content, "status");
         }
@@ -9149,23 +9857,23 @@ async function detectSpecKit(projectRoot) {
   };
 }
 async function detectSdd(projectRoot) {
-  const sddPath = path17.join(projectRoot, ".sdd");
+  const sddPath = path19.join(projectRoot, ".sdd");
   if (!await directoryExists(sddPath)) {
     return null;
   }
-  const specsPath = path17.join(sddPath, "specs");
-  const configPath = path17.join(sddPath, "config.yaml");
+  const specsPath = path19.join(sddPath, "specs");
+  const configPath = path19.join(sddPath, "config.yaml");
   if (!await directoryExists(specsPath)) {
     return null;
   }
   const specs = [];
-  const specDirs = await fs10.readdir(specsPath, { withFileTypes: true });
+  const specDirs = await fs11.readdir(specsPath, { withFileTypes: true });
   for (const entry of specDirs) {
     if (entry.isDirectory()) {
-      const specPath = path17.join(specsPath, entry.name);
-      const specFile = path17.join(specPath, "spec.md");
+      const specPath = path19.join(specsPath, entry.name);
+      const specFile = path19.join(specPath, "spec.md");
       if (await fileExists(specFile)) {
-        const content = await fs10.readFile(specFile, "utf-8");
+        const content = await fs11.readFile(specFile, "utf-8");
         const title2 = extractTitle2(content);
         const status = extractFrontmatterField(content, "status");
         specs.push({
@@ -9187,19 +9895,19 @@ async function detectSdd(projectRoot) {
 }
 async function migrateFromOpenSpec(sourcePath, targetPath, options = {}) {
   try {
-    const specsPath = path17.join(sourcePath, "specs");
-    const targetSpecsPath = path17.join(targetPath, "specs");
+    const specsPath = path19.join(sourcePath, "specs");
+    const targetSpecsPath = path19.join(targetPath, "specs");
     let specsCreated = 0;
     let specsSkipped = 0;
     const errors = [];
     if (!await directoryExists(specsPath)) {
       return failure(new ChangeError("OpenSpec specs \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
     }
-    const specDirs = await fs10.readdir(specsPath, { withFileTypes: true });
+    const specDirs = await fs11.readdir(specsPath, { withFileTypes: true });
     for (const entry of specDirs) {
       if (!entry.isDirectory()) continue;
-      const sourceSpecPath = path17.join(specsPath, entry.name);
-      const targetSpecPath = path17.join(targetSpecsPath, entry.name);
+      const sourceSpecPath = path19.join(specsPath, entry.name);
+      const targetSpecPath = path19.join(targetSpecsPath, entry.name);
       if (await directoryExists(targetSpecPath)) {
         if (!options.overwrite) {
           specsSkipped++;
@@ -9208,18 +9916,18 @@ async function migrateFromOpenSpec(sourcePath, targetPath, options = {}) {
       }
       try {
         if (!options.dryRun) {
-          await fs10.mkdir(targetSpecPath, { recursive: true });
-          const files = await fs10.readdir(sourceSpecPath);
+          await fs11.mkdir(targetSpecPath, { recursive: true });
+          const files = await fs11.readdir(sourceSpecPath);
           for (const file of files) {
-            const sourceFile = path17.join(sourceSpecPath, file);
-            const targetFile = path17.join(targetSpecPath, file);
-            const stat = await fs10.stat(sourceFile);
+            const sourceFile = path19.join(sourceSpecPath, file);
+            const targetFile = path19.join(targetSpecPath, file);
+            const stat = await fs11.stat(sourceFile);
             if (stat.isFile()) {
-              let content = await fs10.readFile(sourceFile, "utf-8");
+              let content = await fs11.readFile(sourceFile, "utf-8");
               if (file === "spec.md") {
                 content = convertOpenSpecToSdd(content, entry.name);
               }
-              await fs10.writeFile(targetFile, content);
+              await fs11.writeFile(targetFile, content);
             }
           }
         }
@@ -9241,19 +9949,19 @@ async function migrateFromOpenSpec(sourcePath, targetPath, options = {}) {
 }
 async function migrateFromSpecKit(sourcePath, targetPath, options = {}) {
   try {
-    const specsPath = path17.join(sourcePath, "specs");
-    const targetSpecsPath = path17.join(targetPath, "specs");
+    const specsPath = path19.join(sourcePath, "specs");
+    const targetSpecsPath = path19.join(targetPath, "specs");
     let specsCreated = 0;
     let specsSkipped = 0;
     const errors = [];
     if (!await directoryExists(specsPath)) {
       return failure(new ChangeError("Spec Kit specs \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
     }
-    const specDirs = await fs10.readdir(specsPath, { withFileTypes: true });
+    const specDirs = await fs11.readdir(specsPath, { withFileTypes: true });
     for (const entry of specDirs) {
       if (!entry.isDirectory()) continue;
-      const sourceSpecPath = path17.join(specsPath, entry.name);
-      const targetSpecPath = path17.join(targetSpecsPath, entry.name);
+      const sourceSpecPath = path19.join(specsPath, entry.name);
+      const targetSpecPath = path19.join(targetSpecsPath, entry.name);
       if (await directoryExists(targetSpecPath)) {
         if (!options.overwrite) {
           specsSkipped++;
@@ -9262,18 +9970,18 @@ async function migrateFromSpecKit(sourcePath, targetPath, options = {}) {
       }
       try {
         if (!options.dryRun) {
-          await fs10.mkdir(targetSpecPath, { recursive: true });
-          const files = await fs10.readdir(sourceSpecPath);
+          await fs11.mkdir(targetSpecPath, { recursive: true });
+          const files = await fs11.readdir(sourceSpecPath);
           for (const file of files) {
-            const sourceFile = path17.join(sourceSpecPath, file);
-            const targetFile = path17.join(targetSpecPath, file);
-            const stat = await fs10.stat(sourceFile);
+            const sourceFile = path19.join(sourceSpecPath, file);
+            const targetFile = path19.join(targetSpecPath, file);
+            const stat = await fs11.stat(sourceFile);
             if (stat.isFile()) {
-              let content = await fs10.readFile(sourceFile, "utf-8");
+              let content = await fs11.readFile(sourceFile, "utf-8");
               if (file === "spec.md") {
                 content = convertSpecKitToSdd(content, entry.name);
               }
-              await fs10.writeFile(targetFile, content);
+              await fs11.writeFile(targetFile, content);
             }
           }
         }
@@ -9428,10 +10136,10 @@ async function runMigrateDocs(source, options) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. --output \uC635\uC158\uC744 \uC0AC\uC6A9\uD558\uAC70\uB098 sdd init\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sourcePath = path18.resolve(source);
+  const sourcePath = path20.resolve(source);
   let files = [];
   try {
-    const stat = await fs11.stat(sourcePath);
+    const stat = await fs12.stat(sourcePath);
     if (stat.isDirectory()) {
       files = await collectMarkdownFiles(sourcePath);
     } else if (stat.isFile()) {
@@ -9447,7 +10155,7 @@ async function runMigrateDocs(source, options) {
   }
   info(`${files.length}\uAC1C \uD30C\uC77C \uBC1C\uACAC`);
   newline();
-  const outputDir = options.output ? path18.resolve(options.output) : path18.join(projectRoot, ".sdd", "specs");
+  const outputDir = options.output ? path20.resolve(options.output) : path20.join(projectRoot, ".sdd", "specs");
   const summary = {
     total: files.length,
     succeeded: 0,
@@ -9459,10 +10167,10 @@ async function runMigrateDocs(source, options) {
     summary.results.push(result);
     if (result.success) {
       summary.succeeded++;
-      info(`\u2705 ${path18.basename(file)} \u2192 ${result.target}`);
+      info(`\u2705 ${path20.basename(file)} \u2192 ${result.target}`);
     } else {
       summary.failed++;
-      error(`\u274C ${path18.basename(file)}: ${result.error}`);
+      error(`\u274C ${path20.basename(file)}: ${result.error}`);
     }
   }
   newline();
@@ -9474,25 +10182,25 @@ async function runMigrateDocs(source, options) {
 }
 async function migrateDocument(filePath, outputDir, dryRun) {
   try {
-    const content = await fs11.readFile(filePath, "utf-8");
+    const content = await fs12.readFile(filePath, "utf-8");
     const analysis = analyzeDocument(content);
-    const featureId = generateFeatureId(analysis.title || path18.basename(filePath, ".md"));
+    const featureId = generateFeatureId(analysis.title || path20.basename(filePath, ".md"));
     const specContent = generateSpec({
       id: featureId,
-      title: analysis.title || path18.basename(filePath, ".md"),
+      title: analysis.title || path20.basename(filePath, ".md"),
       description: analysis.description || "",
       requirements: analysis.requirements,
       scenarios: analysis.scenarios
     });
-    const targetDir = path18.join(outputDir, featureId);
-    const targetPath = path18.join(targetDir, "spec.md");
+    const targetDir = path20.join(outputDir, featureId);
+    const targetPath = path20.join(targetDir, "spec.md");
     if (!dryRun) {
       await ensureDir(targetDir);
       await writeFile(targetPath, specContent);
     }
     return {
       source: filePath,
-      target: path18.relative(process.cwd(), targetPath),
+      target: path20.relative(process.cwd(), targetPath),
       success: true
     };
   } catch (error2) {
@@ -9537,14 +10245,14 @@ function analyzeDocument(content) {
   };
 }
 async function runAnalyze(file) {
-  const filePath = path18.resolve(file);
+  const filePath = path20.resolve(file);
   if (!await fileExists(filePath)) {
     error(`\uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${file}`);
     process.exit(ExitCode.FILE_SYSTEM_ERROR);
   }
-  const content = await fs11.readFile(filePath, "utf-8");
+  const content = await fs12.readFile(filePath, "utf-8");
   const analysis = analyzeDocument(content);
-  info(`\u{1F4CA} \uBB38\uC11C \uBD84\uC11D: ${path18.basename(file)}`);
+  info(`\u{1F4CA} \uBB38\uC11C \uBD84\uC11D: ${path20.basename(file)}`);
   newline();
   info(`\uC81C\uBAA9: ${analysis.title || "(\uC5C6\uC74C)"}`);
   info(`\uC124\uBA85: ${analysis.description || "(\uC5C6\uC74C)"}`);
@@ -9587,7 +10295,7 @@ async function runAnalyze(file) {
   }
 }
 async function runScan(dir, options) {
-  const dirPath = path18.resolve(dir);
+  const dirPath = path20.resolve(dir);
   if (!await directoryExists(dirPath)) {
     error(`\uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${dir}`);
     process.exit(ExitCode.FILE_SYSTEM_ERROR);
@@ -9603,7 +10311,7 @@ async function runScan(dir, options) {
   const results = [];
   for (const file of files) {
     try {
-      const content = await fs11.readFile(file, "utf-8");
+      const content = await fs12.readFile(file, "utf-8");
       const analysis = analyzeDocument(content);
       results.push({ file, analysis });
     } catch {
@@ -9618,7 +10326,7 @@ async function runScan(dir, options) {
   const partial = [];
   const notReady = [];
   for (const { file, analysis } of results) {
-    const relativePath = path18.relative(process.cwd(), file);
+    const relativePath = path20.relative(process.cwd(), file);
     if (analysis.hasRfc2119 && analysis.hasScenarios) {
       ready.push(relativePath);
     } else if (analysis.hasRfc2119 || analysis.hasScenarios || analysis.requirements.length > 0) {
@@ -9665,15 +10373,15 @@ async function collectMarkdownFiles(dirPath) {
 async function collectFilesWithExtensions(dirPath, extensions) {
   const files = [];
   async function scan(dir) {
-    const entries = await fs11.readdir(dir, { withFileTypes: true });
+    const entries = await fs12.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path18.join(dir, entry.name);
+      const fullPath = path20.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!["node_modules", ".git", ".sdd", "dist", "build"].includes(entry.name)) {
           await scan(fullPath);
         }
       } else if (entry.isFile()) {
-        const ext = path18.extname(entry.name).toLowerCase();
+        const ext = path20.extname(entry.name).toLowerCase();
         if (extensions.some((e) => e.toLowerCase() === ext)) {
           if (!["agents.md", "readme.md", "changelog.md", "license.md"].includes(entry.name.toLowerCase())) {
             files.push(fullPath);
@@ -9686,7 +10394,7 @@ async function collectFilesWithExtensions(dirPath, extensions) {
   return files;
 }
 async function runDetect(options) {
-  const projectRoot = options.path ? path18.resolve(options.path) : process.cwd();
+  const projectRoot = options.path ? path20.resolve(options.path) : process.cwd();
   info("\u{1F50D} \uC678\uBD80 SDD \uB3C4\uAD6C \uAC10\uC9C0 \uC911...");
   info(`   \uACBD\uB85C: ${projectRoot}`);
   newline();
@@ -9740,7 +10448,7 @@ async function runMigrateOpenSpec(source, options) {
   }
   let sourcePath;
   if (source) {
-    sourcePath = path18.resolve(source);
+    sourcePath = path20.resolve(source);
   } else {
     const detectResult = await detectExternalTools(projectRoot);
     if (!detectResult.success) {
@@ -9754,7 +10462,7 @@ async function runMigrateOpenSpec(source, options) {
     }
     sourcePath = openspec.path;
   }
-  const sddPath = path18.join(projectRoot, ".sdd");
+  const sddPath = path20.join(projectRoot, ".sdd");
   info("\u{1F504} OpenSpec\uC5D0\uC11C \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC911...");
   info(`   \uC18C\uC2A4: ${sourcePath}`);
   info(`   \uB300\uC0C1: ${sddPath}`);
@@ -9794,7 +10502,7 @@ async function runMigrateSpecKit(source, options) {
   }
   let sourcePath;
   if (source) {
-    sourcePath = path18.resolve(source);
+    sourcePath = path20.resolve(source);
   } else {
     const detectResult = await detectExternalTools(projectRoot);
     if (!detectResult.success) {
@@ -9808,7 +10516,7 @@ async function runMigrateSpecKit(source, options) {
     }
     sourcePath = speckit.path;
   }
-  const sddPath = path18.join(projectRoot, ".sdd");
+  const sddPath = path20.join(projectRoot, ".sdd");
   info("\u{1F504} Spec Kit\uC5D0\uC11C \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC911...");
   info(`   \uC18C\uC2A4: ${sourcePath}`);
   info(`   \uB300\uC0C1: ${sddPath}`);
@@ -9878,7 +10586,7 @@ function getConfidenceLabel(confidence) {
 }
 
 // src/cli/commands/cicd.ts
-import path19 from "path";
+import path21 from "path";
 init_errors();
 init_fs();
 function registerCicdCommand(program2) {
@@ -9930,16 +10638,20 @@ async function runSetup(platform, options) {
   listItem("PR/MR \uC0DD\uC131 \uC2DC \uC790\uB3D9\uC73C\uB85C \uC2A4\uD399 \uAC80\uC99D\uC774 \uC2E4\uD589\uB429\uB2C8\uB2E4");
 }
 async function setupGitHubActions(projectRoot, strict) {
-  const workflowDir = path19.join(projectRoot, ".github", "workflows");
+  const workflowDir = path21.join(projectRoot, ".github", "workflows");
   await ensureDir(workflowDir);
-  const workflowContent = generateGitHubWorkflow(strict);
-  const workflowPath = path19.join(workflowDir, "sdd-validate.yml");
-  await writeFile(workflowPath, workflowContent);
+  const validateContent = generateGitHubWorkflow(strict);
+  const validatePath = path21.join(workflowDir, "sdd-validate.yml");
+  await writeFile(validatePath, validateContent);
   info(`\u2705 GitHub Actions \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC0DD\uC131: .github/workflows/sdd-validate.yml`);
+  const labelerContent = generateGitHubLabeler();
+  const labelerPath = path21.join(workflowDir, "sdd-labeler.yml");
+  await writeFile(labelerPath, labelerContent);
+  info(`\u2705 GitHub Actions \uB77C\uBCA8\uB7EC \uC0DD\uC131: .github/workflows/sdd-labeler.yml`);
 }
 async function setupGitLabCI(projectRoot, strict) {
   const ciContent = generateGitLabCI(strict);
-  const ciPath = path19.join(projectRoot, ".gitlab-ci-sdd.yml");
+  const ciPath = path21.join(projectRoot, ".gitlab-ci-sdd.yml");
   await writeFile(ciPath, ciContent);
   info(`\u2705 GitLab CI \uAD6C\uC131 \uC0DD\uC131: .gitlab-ci-sdd.yml`);
   info("   (\uAE30\uC874 .gitlab-ci.yml\uC5D0 include\uD558\uAC70\uB098 \uBCD1\uD569\uD558\uC138\uC694)");
@@ -9998,6 +10710,69 @@ jobs:
           path: impact-report.json
 `;
 }
+function generateGitHubLabeler() {
+  return `# SDD PR \uB77C\uBCA8\uB7EC \uC6CC\uD06C\uD50C\uB85C\uC6B0
+# \uBCC0\uACBD\uB41C \uB3C4\uBA54\uC778\uC5D0 \uB530\uB77C \uC790\uB3D9\uC73C\uB85C \uB77C\uBCA8\uC744 \uCD94\uAC00\uD569\uB2C8\uB2E4
+
+name: SDD Labeler
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+    paths:
+      - '.sdd/**'
+
+jobs:
+  label:
+    name: Add Labels
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Detect Changes
+        id: changes
+        run: |
+          # \uBCC0\uACBD\uB41C \uB3C4\uBA54\uC778 \uAC10\uC9C0
+          DOMAINS=$(git diff --name-only origin/\${{ github.base_ref }} | \\
+            grep "^\\.sdd/specs/" | \\
+            cut -d'/' -f3 | \\
+            sort -u | \\
+            tr '\\n' ' ')
+          echo "domains=$DOMAINS" >> $GITHUB_OUTPUT
+
+          # Constitution \uBCC0\uACBD \uAC10\uC9C0
+          if git diff --name-only origin/\${{ github.base_ref }} | grep -q "constitution.md"; then
+            echo "constitution=true" >> $GITHUB_OUTPUT
+          else
+            echo "constitution=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Apply Labels
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const labels = [];
+            const domains = '\${{ steps.changes.outputs.domains }}'.trim().split(' ').filter(Boolean);
+            labels.push(...domains.map(d => \`spec:\${d}\`));
+
+            if ('\${{ steps.changes.outputs.constitution }}' === 'true') {
+              labels.push('constitution');
+            }
+
+            if (labels.length > 0) {
+              await github.rest.issues.addLabels({
+                issue_number: context.issue.number,
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                labels: labels,
+              });
+            }
+`;
+}
 function generateGitLabCI(strict) {
   const strictFlag = strict ? " --strict" : "";
   return `# SDD \uC2A4\uD399 \uAC80\uC99D \uD30C\uC774\uD504\uB77C\uC778
@@ -10035,7 +10810,7 @@ async function runHooksSetup(type, options) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const hooksDir = path19.join(projectRoot, ".husky");
+  const hooksDir = path21.join(projectRoot, ".husky");
   if (options.install) {
     info("husky \uC124\uCE58 \uBC29\uBC95:");
     newline();
@@ -10049,7 +10824,7 @@ async function runHooksSetup(type, options) {
   const hooks = type ? [type] : ["pre-commit", "pre-push"];
   for (const hook of hooks) {
     const hookContent = generateHookScript(hook);
-    const hookPath = path19.join(hooksDir, hook);
+    const hookPath = path21.join(hooksDir, hook);
     await writeFile(hookPath, hookContent);
     info(`\u2705 ${hook} \uD6C5 \uC0DD\uC131: .husky/${hook}`);
   }
@@ -10131,7 +10906,7 @@ async function runCiCheck(options) {
   let hasErrors = false;
   let hasWarnings = false;
   info("1. Constitution \uAC80\uC99D...");
-  const constitutionPath = path19.join(projectRoot, ".sdd", "constitution.md");
+  const constitutionPath = path21.join(projectRoot, ".sdd", "constitution.md");
   if (await fileExists(constitutionPath)) {
     info("   \u2705 constitution.md \uC874\uC7AC");
   } else {
@@ -10139,7 +10914,7 @@ async function runCiCheck(options) {
     hasWarnings = true;
   }
   info("2. \uC2A4\uD399 \uB514\uB809\uD1A0\uB9AC \uD655\uC778...");
-  const specsPath = path19.join(projectRoot, ".sdd", "specs");
+  const specsPath = path21.join(projectRoot, ".sdd", "specs");
   if (await directoryExists(specsPath)) {
     info("   \u2705 specs/ \uB514\uB809\uD1A0\uB9AC \uC874\uC7AC");
   } else {
@@ -10149,7 +10924,7 @@ async function runCiCheck(options) {
   info("3. \uAE30\uBCF8 \uAD6C\uC870 \uD655\uC778...");
   const requiredDirs = ["changes", "archive", "templates"];
   for (const dir of requiredDirs) {
-    const dirPath = path19.join(projectRoot, ".sdd", dir);
+    const dirPath = path21.join(projectRoot, ".sdd", dir);
     if (await directoryExists(dirPath)) {
       info(`   \u2705 ${dir}/ \uC874\uC7AC`);
     } else {
@@ -10177,15 +10952,15 @@ async function runCiCheck(options) {
 }
 
 // src/cli/commands/transition.ts
-import path20 from "path";
-import { promises as fs12 } from "fs";
+import path22 from "path";
+import { promises as fs13 } from "fs";
 init_errors();
 init_fs();
 init_types();
 async function getExistingChangeIds(sddPath) {
-  const changesPath = path20.join(sddPath, "changes");
+  const changesPath = path22.join(sddPath, "changes");
   try {
-    const dirs = await fs12.readdir(changesPath);
+    const dirs = await fs13.readdir(changesPath);
     return dirs.filter((d) => d.startsWith("CHG-"));
   } catch {
     return [];
@@ -10203,24 +10978,24 @@ async function extractProposalTitle(proposalPath) {
   return titleMatch ? titleMatch[1] : "";
 }
 async function transitionNewToChange(sddPath, specId, options) {
-  const specsPath = path20.join(sddPath, "specs");
-  const specPath = path20.join(specsPath, specId, "spec.md");
+  const specsPath = path22.join(sddPath, "specs");
+  const specPath = path22.join(specsPath, specId, "spec.md");
   if (!await fileExists(specPath)) {
     return failure(new Error(`\uC2A4\uD399\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${specId}`));
   }
   const existingIds = await getExistingChangeIds(sddPath);
   const changeId = generateChangeId(existingIds);
-  const changesPath = path20.join(sddPath, "changes");
-  const changePath = path20.join(changesPath, changeId);
+  const changesPath = path22.join(sddPath, "changes");
+  const changePath = path22.join(changesPath, changeId);
   await ensureDir(changePath);
   const title2 = options.title || `${specId} \uAE30\uB2A5 \uD655\uC7A5`;
   const reason = options.reason || "new \uC6CC\uD06C\uD50C\uB85C\uC6B0\uC5D0\uC11C \uC804\uD658\uB428";
   const proposalContent = generateTransitionProposal(specId, title2, reason, "new-to-change");
-  await writeFile(path20.join(changePath, "proposal.md"), proposalContent);
+  await writeFile(path22.join(changePath, "proposal.md"), proposalContent);
   const deltaContent = generateDeltaTemplate2(specId);
-  await writeFile(path20.join(changePath, "delta.md"), deltaContent);
+  await writeFile(path22.join(changePath, "delta.md"), deltaContent);
   const tasksContent = generateTasksTemplate2();
-  await writeFile(path20.join(changePath, "tasks.md"), tasksContent);
+  await writeFile(path22.join(changePath, "tasks.md"), tasksContent);
   return success({
     changeId,
     changePath,
@@ -10228,27 +11003,27 @@ async function transitionNewToChange(sddPath, specId, options) {
   });
 }
 async function transitionChangeToNew(sddPath, changeId, options) {
-  const changePath = path20.join(sddPath, "changes", changeId);
+  const changePath = path22.join(sddPath, "changes", changeId);
   if (!await directoryExists(changePath)) {
     return failure(new Error(`\uBCC0\uACBD \uC81C\uC548\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${changeId}`));
   }
-  const proposalPath = path20.join(changePath, "proposal.md");
+  const proposalPath = path22.join(changePath, "proposal.md");
   const extractedTitle = await extractProposalTitle(proposalPath);
   const featureName = options.name || extractedTitle.toLowerCase().replace(/\s+/g, "-") || `feature-from-${changeId}`;
-  const specsPath = path20.join(sddPath, "specs");
-  const newSpecPath = path20.join(specsPath, featureName);
+  const specsPath = path22.join(sddPath, "specs");
+  const newSpecPath = path22.join(specsPath, featureName);
   if (await directoryExists(newSpecPath)) {
     return failure(new Error(`\uC2A4\uD399\uC774 \uC774\uBBF8 \uC874\uC7AC\uD569\uB2C8\uB2E4: ${featureName}`));
   }
   await ensureDir(newSpecPath);
   const reason = options.reason || "change \uC6CC\uD06C\uD50C\uB85C\uC6B0\uC5D0\uC11C \uC804\uD658\uB428";
   const specContent = generateTransitionSpec(featureName, extractedTitle || featureName, reason, changeId);
-  await writeFile(path20.join(newSpecPath, "spec.md"), specContent);
+  await writeFile(path22.join(newSpecPath, "spec.md"), specContent);
   const planContent = generatePlanTemplate(featureName);
-  await writeFile(path20.join(newSpecPath, "plan.md"), planContent);
+  await writeFile(path22.join(newSpecPath, "plan.md"), planContent);
   const tasksContent = generateTasksTemplate2();
-  await writeFile(path20.join(newSpecPath, "tasks.md"), tasksContent);
-  const statusPath = path20.join(changePath, ".status");
+  await writeFile(path22.join(newSpecPath, "tasks.md"), tasksContent);
+  const statusPath = path22.join(changePath, ".status");
   await writeFile(statusPath, JSON.stringify({
     status: "transitioned",
     transitionedTo: featureName,
@@ -10329,7 +11104,7 @@ async function runNewToChange(specId, options) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path20.join(projectRoot, ".sdd");
+  const sddPath = path22.join(projectRoot, ".sdd");
   info("=== \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC804\uD658: new \u2192 change ===");
   newline();
   info(`\uB300\uC0C1 \uC2A4\uD399: ${specId}`);
@@ -10361,7 +11136,7 @@ async function runChangeToNew(changeId, options) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path20.join(projectRoot, ".sdd");
+  const sddPath = path22.join(projectRoot, ".sdd");
   info("=== \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC804\uD658: change \u2192 new ===");
   newline();
   info(`\uC6D0\uBCF8 \uBCC0\uACBD: ${changeId}`);
@@ -10568,11 +11343,11 @@ status: pending
 }
 
 // src/cli/commands/watch.ts
-import path22 from "path";
+import path24 from "path";
 
 // src/core/watch/watcher.ts
 import chokidar from "chokidar";
-import path21 from "path";
+import path23 from "path";
 import { EventEmitter } from "events";
 var SpecWatcher = class extends EventEmitter {
   watcher = null;
@@ -10643,7 +11418,7 @@ var SpecWatcher = class extends EventEmitter {
     const event = {
       type,
       path: filePath,
-      relativePath: path21.relative(this.specsPath, filePath),
+      relativePath: path23.relative(this.specsPath, filePath),
       timestamp: /* @__PURE__ */ new Date()
     };
     this.pendingEvents.push(event);
@@ -10690,8 +11465,8 @@ async function runWatch(options) {
     error("SDD \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. `sdd init`\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(ExitCode.GENERAL_ERROR);
   }
-  const sddPath = path22.join(projectRoot, ".sdd");
-  const specsPath = path22.join(sddPath, "specs");
+  const sddPath = path24.join(projectRoot, ".sdd");
+  const specsPath = path24.join(sddPath, "specs");
   const debounceMs = parseInt(options.debounce || "500", 10);
   info("\u{1F441}\uFE0F  Watch \uBAA8\uB4DC \uC2DC\uC791");
   info(`   \uACBD\uB85C: ${specsPath}`);
@@ -10781,14 +11556,14 @@ async function runWatch(options) {
 }
 
 // src/cli/commands/quality.ts
-import path24 from "path";
+import path26 from "path";
 
 // src/core/quality/analyzer.ts
 init_types();
 init_errors();
 init_fs();
-import path23 from "path";
-import { promises as fs13 } from "fs";
+import path25 from "path";
+import { promises as fs14 } from "fs";
 function getGrade(percentage) {
   if (percentage >= 90) return "A";
   if (percentage >= 80) return "B";
@@ -11056,7 +11831,7 @@ async function analyzeSpecQuality(specPath, sddPath) {
       return failure(new ChangeError(`\uC2A4\uD399 \uD30C\uC2F1 \uC2E4\uD328: ${parseResult.error.message}`));
     }
     const spec = parseResult.data;
-    const constitutionPath = path23.join(sddPath, "constitution.md");
+    const constitutionPath = path25.join(sddPath, "constitution.md");
     const hasConstitution = await fileExists(constitutionPath);
     const items = [
       scoreRfc2119(content),
@@ -11073,7 +11848,7 @@ async function analyzeSpecQuality(specPath, sddPath) {
     const percentage = Math.round(totalScore / maxScore * 100);
     const grade = getGrade(percentage);
     const topSuggestions = items.filter((item) => item.suggestions.length > 0).sort((a, b) => a.percentage - b.percentage).slice(0, 3).flatMap((item) => item.suggestions);
-    const specId = spec.metadata.id || path23.basename(path23.dirname(specPath));
+    const specId = spec.metadata.id || path25.basename(path25.dirname(specPath));
     const summary = `\uC2A4\uD399 '${specId}'\uC758 \uD488\uC9C8 \uC810\uC218: ${totalScore}/${maxScore} (${percentage}%, \uB4F1\uAE09: ${grade})`;
     return success({
       specId,
@@ -11096,7 +11871,7 @@ async function analyzeSpecQuality(specPath, sddPath) {
 }
 async function analyzeProjectQuality(sddPath) {
   try {
-    const specsPath = path23.join(sddPath, "specs");
+    const specsPath = path25.join(sddPath, "specs");
     if (!await directoryExists(specsPath)) {
       return failure(new ChangeError("\uC2A4\uD399 \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
     }
@@ -11139,9 +11914,9 @@ async function analyzeProjectQuality(sddPath) {
   }
 }
 async function findSpecFiles2(dir, files) {
-  const entries = await fs13.readdir(dir, { withFileTypes: true });
+  const entries = await fs14.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path23.join(dir, entry.name);
+    const fullPath = path25.join(dir, entry.name);
     if (entry.isDirectory()) {
       await findSpecFiles2(fullPath, files);
     } else if (entry.name === "spec.md") {
@@ -11205,7 +11980,7 @@ init_fs();
 init_errors();
 init_types();
 async function executeQuality(feature, options, projectRoot) {
-  const sddPath = path24.join(projectRoot, ".sdd");
+  const sddPath = path26.join(projectRoot, ".sdd");
   const minScore = parseInt(options.minScore || "0", 10);
   if (options.all || !feature) {
     const result2 = await analyzeProjectQuality(sddPath);
@@ -11220,7 +11995,7 @@ async function executeQuality(feature, options, projectRoot) {
       passed: result2.data.averagePercentage >= minScore
     });
   }
-  const specPath = path24.join(sddPath, "specs", feature, "spec.md");
+  const specPath = path26.join(sddPath, "specs", feature, "spec.md");
   const result = await analyzeSpecQuality(specPath, sddPath);
   if (!result.success) {
     return failure(result.error);
@@ -11264,13 +12039,13 @@ async function runQuality(feature, options) {
 }
 
 // src/cli/commands/report.ts
-import path26 from "path";
+import path28 from "path";
 
 // src/core/report/reporter.ts
 init_types();
 init_errors();
-import path25 from "path";
-import fs14 from "fs/promises";
+import path27 from "path";
+import fs15 from "fs/promises";
 init_fs();
 async function loadSpecList(specsPath) {
   try {
@@ -11283,12 +12058,12 @@ async function loadSpecList(specsPath) {
     }
     const specs = [];
     for (const entry of result.data) {
-      const featurePath = path25.join(specsPath, entry);
-      const stat = await fs14.stat(featurePath);
+      const featurePath = path27.join(specsPath, entry);
+      const stat = await fs15.stat(featurePath);
       if (stat.isDirectory()) {
-        const specFile = path25.join(featurePath, "spec.md");
+        const specFile = path27.join(featurePath, "spec.md");
         if (await fileExists(specFile)) {
-          const content = await fs14.readFile(specFile, "utf-8");
+          const content = await fs15.readFile(specFile, "utf-8");
           const metadata = parseSpecMetadata2(content);
           specs.push({
             id: entry,
@@ -11326,7 +12101,7 @@ function parseSpecMetadata2(content) {
 }
 async function generateReport(sddPath, options) {
   try {
-    const specsPath = path25.join(sddPath, "specs");
+    const specsPath = path27.join(sddPath, "specs");
     const specsResult = await loadSpecList(specsPath);
     if (!specsResult.success) {
       return failure(specsResult.error);
@@ -11379,8 +12154,8 @@ async function generateReport(sddPath, options) {
         return failure(new ChangeError(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD615\uC2DD\uC785\uB2C8\uB2E4: ${options.format}`));
     }
     if (options.outputPath) {
-      await fs14.mkdir(path25.dirname(options.outputPath), { recursive: true });
-      await fs14.writeFile(options.outputPath, content, "utf-8");
+      await fs15.mkdir(path27.dirname(options.outputPath), { recursive: true });
+      await fs15.writeFile(options.outputPath, content, "utf-8");
     }
     return success({
       format: options.format,
@@ -11655,12 +12430,12 @@ function resolveOutputPath(format, output, projectRoot) {
   if (!output) {
     const ext = format === "markdown" ? "md" : format;
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    return path26.join(projectRoot, `sdd-report-${timestamp}.${ext}`);
+    return path28.join(projectRoot, `sdd-report-${timestamp}.${ext}`);
   }
-  return path26.isAbsolute(output) ? output : path26.join(projectRoot, output);
+  return path28.isAbsolute(output) ? output : path28.join(projectRoot, output);
 }
 async function executeReport(options, projectRoot) {
-  const sddPath = path26.join(projectRoot, ".sdd");
+  const sddPath = path28.join(projectRoot, ".sdd");
   const format = options.format || "html";
   if (!isValidReportFormat(format)) {
     return failure(new Error(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD615\uC2DD\uC785\uB2C8\uB2E4: ${format}. \uC9C0\uC6D0 \uD615\uC2DD: html, markdown, json`));
@@ -11718,19 +12493,19 @@ async function runReport(options) {
 }
 
 // src/cli/commands/search.ts
-import path28 from "path";
+import path30 from "path";
 init_fs();
 
 // src/core/search/searcher.ts
 init_types();
 init_errors();
 init_fs();
-import path27 from "path";
-import { promises as fs15 } from "fs";
+import path29 from "path";
+import { promises as fs16 } from "fs";
 async function searchSpecs(sddPath, options = {}) {
   const startTime = Date.now();
   try {
-    const specsPath = path27.join(sddPath, "specs");
+    const specsPath = path29.join(sddPath, "specs");
     if (!await directoryExists(specsPath)) {
       return failure(new ChangeError("\uC2A4\uD399 \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
     }
@@ -11780,17 +12555,17 @@ async function buildSearchIndex(specsPath) {
   }
 }
 async function collectSpecs(basePath, currentPath, index) {
-  const entries = await fs15.readdir(currentPath, { withFileTypes: true });
+  const entries = await fs16.readdir(currentPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path27.join(currentPath, entry.name);
+    const fullPath = path29.join(currentPath, entry.name);
     if (entry.isDirectory()) {
       await collectSpecs(basePath, fullPath, index);
     } else if (entry.name === "spec.md") {
-      const content = await fs15.readFile(fullPath, "utf-8");
-      const relativePath = path27.relative(basePath, fullPath);
-      const specId = path27.dirname(relativePath);
+      const content = await fs16.readFile(fullPath, "utf-8");
+      const relativePath = path29.relative(basePath, fullPath);
+      const specId = path29.dirname(relativePath);
       const metadata = parseMetadata(content);
-      const stat = await fs15.stat(fullPath);
+      const stat = await fs16.stat(fullPath);
       index.push({
         id: specId === "." ? entry.name : specId,
         path: relativePath,
@@ -12088,7 +12863,7 @@ function registerSearchCommand(program2) {
   });
 }
 async function executeSearch(query, options) {
-  const sddPath = path28.join(process.cwd(), ".sdd");
+  const sddPath = path30.join(process.cwd(), ".sdd");
   if (!await fileExists(sddPath)) {
     logger_exports.error(".sdd \uB514\uB809\uD1A0\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. sdd init\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
     return;
@@ -12108,7 +12883,7 @@ async function executeSearch(query, options) {
 }
 
 // src/cli/commands/prepare.ts
-import path35 from "path";
+import path37 from "path";
 
 // src/core/prepare/schemas.ts
 import { z as z8 } from "zod";
@@ -12243,19 +13018,19 @@ var DEFAULT_KEYWORD_MAPPINGS = [
 ];
 
 // src/core/prepare/document-analyzer.ts
-import * as fs16 from "fs";
-import * as path29 from "path";
+import * as fs17 from "fs";
+import * as path31 from "path";
 var DocumentAnalyzer = class {
   sddDir;
   constructor(projectRoot) {
-    this.sddDir = path29.join(projectRoot, ".sdd");
+    this.sddDir = path31.join(projectRoot, ".sdd");
   }
   /**
    * 기능 디렉토리의 모든 문서 분석
    */
   async analyzeFeature(featureName) {
-    const featureDir = path29.join(this.sddDir, "specs", featureName);
-    if (!fs16.existsSync(featureDir)) {
+    const featureDir = path31.join(this.sddDir, "specs", featureName);
+    if (!fs17.existsSync(featureDir)) {
       throw new Error(`\uAE30\uB2A5 \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${featureDir}`);
     }
     const results = [];
@@ -12265,8 +13040,8 @@ var DocumentAnalyzer = class {
       { file: "spec.md", type: "spec" }
     ];
     for (const doc of documents) {
-      const filePath = path29.join(featureDir, doc.file);
-      if (fs16.existsSync(filePath)) {
+      const filePath = path31.join(featureDir, doc.file);
+      if (fs17.existsSync(filePath)) {
         const analysis = await this.analyzeDocument(filePath, doc.type);
         results.push(analysis);
       }
@@ -12277,7 +13052,7 @@ var DocumentAnalyzer = class {
    * 단일 문서 분석
    */
   async analyzeDocument(filePath, type) {
-    const content = fs16.readFileSync(filePath, "utf-8");
+    const content = fs17.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
     const analyzedLines = [];
     let taskCount = 0;
@@ -12343,7 +13118,7 @@ var DocumentAnalyzer = class {
       for (const line of analysis.lines) {
         for (const keyword of line.keywords) {
           sources.push({
-            file: path29.basename(analysis.file),
+            file: path31.basename(analysis.file),
             line: line.lineNumber,
             text: line.content,
             keyword
@@ -12460,19 +13235,19 @@ var ToolDetector = class {
 };
 
 // src/core/prepare/agent-scanner.ts
-import * as fs17 from "fs";
-import * as path30 from "path";
+import * as fs18 from "fs";
+import * as path32 from "path";
 import matter6 from "gray-matter";
 var AgentScanner = class {
   agentsDir;
   constructor(projectRoot) {
-    this.agentsDir = path30.join(projectRoot, ".claude", "agents");
+    this.agentsDir = path32.join(projectRoot, ".claude", "agents");
   }
   /**
    * 에이전트 디렉토리 존재 여부
    */
   exists() {
-    return fs17.existsSync(this.agentsDir);
+    return fs18.existsSync(this.agentsDir);
   }
   /**
    * 모든 에이전트 스캔
@@ -12482,10 +13257,10 @@ var AgentScanner = class {
       return [];
     }
     const agents = [];
-    const files = fs17.readdirSync(this.agentsDir);
+    const files = fs18.readdirSync(this.agentsDir);
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
-      const filePath = path30.join(this.agentsDir, file);
+      const filePath = path32.join(this.agentsDir, file);
       const agent = await this.scanAgent(filePath);
       if (agent) {
         agents.push(agent);
@@ -12498,7 +13273,7 @@ var AgentScanner = class {
    */
   async scanAgent(filePath) {
     try {
-      const content = fs17.readFileSync(filePath, "utf-8");
+      const content = fs18.readFileSync(filePath, "utf-8");
       const { data, content: body } = matter6(content);
       const metadata = this.parseMetadata(data, filePath);
       if (!metadata) {
@@ -12518,15 +13293,15 @@ var AgentScanner = class {
    * 특정 에이전트 존재 확인
    */
   hasAgent(name) {
-    const filePath = path30.join(this.agentsDir, `${name}.md`);
-    return fs17.existsSync(filePath);
+    const filePath = path32.join(this.agentsDir, `${name}.md`);
+    return fs18.existsSync(filePath);
   }
   /**
    * 특정 에이전트 가져오기
    */
   async getAgent(name) {
-    const filePath = path30.join(this.agentsDir, `${name}.md`);
-    if (!fs17.existsSync(filePath)) {
+    const filePath = path32.join(this.agentsDir, `${name}.md`);
+    if (!fs18.existsSync(filePath)) {
       return null;
     }
     return this.scanAgent(filePath);
@@ -12543,7 +13318,7 @@ var AgentScanner = class {
       if (result.success) {
         return result.data;
       }
-      const fileName = path30.basename(filePath, ".md");
+      const fileName = path32.basename(filePath, ".md");
       const withName = { ...data, name: data.name ?? fileName };
       const retryResult = AgentMetadataSchema.safeParse(withName);
       if (retryResult.success) {
@@ -12564,24 +13339,24 @@ var AgentScanner = class {
    * 에이전트 파일 경로 생성
    */
   getAgentFilePath(name) {
-    return path30.join(this.agentsDir, `${name}.md`);
+    return path32.join(this.agentsDir, `${name}.md`);
   }
 };
 
 // src/core/prepare/skill-scanner.ts
-import * as fs18 from "fs";
-import * as path31 from "path";
+import * as fs19 from "fs";
+import * as path33 from "path";
 import matter7 from "gray-matter";
 var SkillScanner = class {
   skillsDir;
   constructor(projectRoot) {
-    this.skillsDir = path31.join(projectRoot, ".claude", "skills");
+    this.skillsDir = path33.join(projectRoot, ".claude", "skills");
   }
   /**
    * 스킬 디렉토리 존재 여부
    */
   exists() {
-    return fs18.existsSync(this.skillsDir);
+    return fs19.existsSync(this.skillsDir);
   }
   /**
    * 모든 스킬 스캔
@@ -12591,10 +13366,10 @@ var SkillScanner = class {
       return [];
     }
     const skills = [];
-    const entries = fs18.readdirSync(this.skillsDir, { withFileTypes: true });
+    const entries = fs19.readdirSync(this.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillDir = path31.join(this.skillsDir, entry.name);
+      const skillDir = path33.join(this.skillsDir, entry.name);
       const skill = await this.scanSkill(skillDir);
       if (skill) {
         skills.push(skill);
@@ -12606,12 +13381,12 @@ var SkillScanner = class {
    * 단일 스킬 디렉토리 스캔
    */
   async scanSkill(skillDir) {
-    const skillFile = path31.join(skillDir, "SKILL.md");
-    if (!fs18.existsSync(skillFile)) {
+    const skillFile = path33.join(skillDir, "SKILL.md");
+    if (!fs19.existsSync(skillFile)) {
       return null;
     }
     try {
-      const content = fs18.readFileSync(skillFile, "utf-8");
+      const content = fs19.readFileSync(skillFile, "utf-8");
       const { data, content: body } = matter7(content);
       const metadata = this.parseMetadata(data, skillDir);
       if (!metadata) {
@@ -12632,16 +13407,16 @@ var SkillScanner = class {
    * 특정 스킬 존재 확인
    */
   hasSkill(name) {
-    const skillDir = path31.join(this.skillsDir, name);
-    const skillFile = path31.join(skillDir, "SKILL.md");
-    return fs18.existsSync(skillFile);
+    const skillDir = path33.join(this.skillsDir, name);
+    const skillFile = path33.join(skillDir, "SKILL.md");
+    return fs19.existsSync(skillFile);
   }
   /**
    * 특정 스킬 가져오기
    */
   async getSkill(name) {
-    const skillDir = path31.join(this.skillsDir, name);
-    if (!fs18.existsSync(skillDir)) {
+    const skillDir = path33.join(this.skillsDir, name);
+    if (!fs19.existsSync(skillDir)) {
       return null;
     }
     return this.scanSkill(skillDir);
@@ -12658,7 +13433,7 @@ var SkillScanner = class {
       if (result.success) {
         return result.data;
       }
-      const dirName = path31.basename(skillDir);
+      const dirName = path33.basename(skillDir);
       const withName = { ...data, name: data.name ?? dirName };
       const retryResult = SkillMetadataSchema.safeParse(withName);
       if (retryResult.success) {
@@ -12679,23 +13454,23 @@ var SkillScanner = class {
    * 스킬 디렉토리 경로 생성
    */
   getSkillDirPath(name) {
-    return path31.join(this.skillsDir, name);
+    return path33.join(this.skillsDir, name);
   }
   /**
    * 스킬 파일 경로 생성
    */
   getSkillFilePath(name) {
-    return path31.join(this.skillsDir, name, "SKILL.md");
+    return path33.join(this.skillsDir, name, "SKILL.md");
   }
 };
 
 // src/core/prepare/agent-generator.ts
-import * as fs19 from "fs";
-import * as path32 from "path";
+import * as fs20 from "fs";
+import * as path34 from "path";
 var AgentGenerator = class {
   agentsDir;
   constructor(projectRoot) {
-    this.agentsDir = path32.join(projectRoot, ".claude", "agents");
+    this.agentsDir = path34.join(projectRoot, ".claude", "agents");
   }
   /**
    * 감지된 도구에서 에이전트 초안 생성
@@ -12704,7 +13479,7 @@ var AgentGenerator = class {
     const model = options?.model ?? "sonnet";
     const tools = options?.tools ?? this.getDefaultTools(tool.name);
     const content = this.generateContent(tool, model, tools);
-    const filePath = path32.join(this.agentsDir, `${tool.name}.md`);
+    const filePath = path34.join(this.agentsDir, `${tool.name}.md`);
     return {
       name: tool.name,
       filePath,
@@ -12715,10 +13490,10 @@ var AgentGenerator = class {
    * 에이전트 파일 생성
    */
   async writeAgent(agent) {
-    if (!fs19.existsSync(this.agentsDir)) {
-      fs19.mkdirSync(this.agentsDir, { recursive: true });
+    if (!fs20.existsSync(this.agentsDir)) {
+      fs20.mkdirSync(this.agentsDir, { recursive: true });
     }
-    fs19.writeFileSync(agent.filePath, agent.content, "utf-8");
+    fs20.writeFileSync(agent.filePath, agent.content, "utf-8");
   }
   /**
    * 에이전트 콘텐츠 생성
@@ -12817,12 +13592,12 @@ var AgentGenerator = class {
 };
 
 // src/core/prepare/skill-generator.ts
-import * as fs20 from "fs";
-import * as path33 from "path";
+import * as fs21 from "fs";
+import * as path35 from "path";
 var SkillGenerator = class {
   skillsDir;
   constructor(projectRoot) {
-    this.skillsDir = path33.join(projectRoot, ".claude", "skills");
+    this.skillsDir = path35.join(projectRoot, ".claude", "skills");
   }
   /**
    * 감지된 도구에서 스킬 초안 생성
@@ -12830,8 +13605,8 @@ var SkillGenerator = class {
   generate(tool, options) {
     const allowedTools = options?.allowedTools ?? this.getDefaultTools(tool.name);
     const content = this.generateContent(tool, allowedTools);
-    const dirPath = path33.join(this.skillsDir, tool.name);
-    const filePath = path33.join(dirPath, "SKILL.md");
+    const dirPath = path35.join(this.skillsDir, tool.name);
+    const filePath = path35.join(dirPath, "SKILL.md");
     return {
       name: tool.name,
       dirPath,
@@ -12843,10 +13618,10 @@ var SkillGenerator = class {
    * 스킬 파일 생성
    */
   async writeSkill(skill) {
-    if (!fs20.existsSync(skill.dirPath)) {
-      fs20.mkdirSync(skill.dirPath, { recursive: true });
+    if (!fs21.existsSync(skill.dirPath)) {
+      fs21.mkdirSync(skill.dirPath, { recursive: true });
     }
-    fs20.writeFileSync(skill.filePath, skill.content, "utf-8");
+    fs21.writeFileSync(skill.filePath, skill.content, "utf-8");
   }
   /**
    * 스킬 콘텐츠 생성
@@ -13001,12 +13776,12 @@ var SkillGenerator = class {
 };
 
 // src/core/prepare/prepare-report.ts
-import * as fs21 from "fs";
-import * as path34 from "path";
+import * as fs22 from "fs";
+import * as path36 from "path";
 var PrepareReportGenerator = class {
   sddDir;
   constructor(projectRoot) {
-    this.sddDir = path34.join(projectRoot, ".sdd");
+    this.sddDir = path36.join(projectRoot, ".sdd");
   }
   /**
    * 보고서 생성
@@ -13121,13 +13896,13 @@ var PrepareReportGenerator = class {
    * 보고서 파일 저장
    */
   async writeReport(feature, report) {
-    const featureDir = path34.join(this.sddDir, "specs", feature);
-    if (!fs21.existsSync(featureDir)) {
-      fs21.mkdirSync(featureDir, { recursive: true });
+    const featureDir = path36.join(this.sddDir, "specs", feature);
+    if (!fs22.existsSync(featureDir)) {
+      fs22.mkdirSync(featureDir, { recursive: true });
     }
-    const filePath = path34.join(featureDir, "prepare.md");
+    const filePath = path36.join(featureDir, "prepare.md");
     const content = this.toMarkdown(report);
-    fs21.writeFileSync(filePath, content, "utf-8");
+    fs22.writeFileSync(filePath, content, "utf-8");
     return filePath;
   }
 };
@@ -13265,12 +14040,12 @@ async function runPrepare(feature, options) {
   if (created.agents.length > 0 || created.skills.length > 0) {
     success2("\uC0DD\uC131\uB41C \uD30C\uC77C:");
     for (const file of [...created.agents, ...created.skills]) {
-      console.log(`  - ${path35.relative(projectRoot, file)}`);
+      console.log(`  - ${path37.relative(projectRoot, file)}`);
     }
     newline();
   }
   if (reportPath) {
-    info(`\uBCF4\uACE0\uC11C: ${path35.relative(projectRoot, reportPath)}`);
+    info(`\uBCF4\uACE0\uC11C: ${path37.relative(projectRoot, reportPath)}`);
   }
   if (missingAgents.length > 0 || missingSkills.length > 0) {
     if (!options.autoApprove && !options.dryRun) {
@@ -13344,8 +14119,8 @@ var CodeReferenceSchema = z9.object({
 });
 
 // src/core/sync/spec-parser.ts
-import { promises as fs22, statSync } from "fs";
-import path36 from "path";
+import { promises as fs23, statSync } from "fs";
+import path38 from "path";
 import matter8 from "gray-matter";
 var REQ_ID_PATTERN = /\b(REQ-\d+)\b/gi;
 var RFC_KEYWORD_PATTERN = /\((SHALL|MUST|SHOULD|MAY|SHALL NOT|MUST NOT)\)/i;
@@ -13353,26 +14128,26 @@ var REQ_HEADER_PATTERN = /^#{2,4}\s*(REQ-\d+):\s*(.+)$/i;
 var SpecParser = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.specsDir = path36.join(projectRoot, ".sdd", "specs");
+    this.specsDir = path38.join(projectRoot, ".sdd", "specs");
   }
   specsDir;
   /**
    * 특정 스펙에서 요구사항 추출
    */
   async parseSpec(specId) {
-    const specPath = path36.join(this.specsDir, specId, "spec.md");
+    const specPath = path38.join(this.specsDir, specId, "spec.md");
     try {
-      const content = await fs22.readFile(specPath, "utf-8");
+      const content = await fs23.readFile(specPath, "utf-8");
       return this.extractRequirements(content, specId);
     } catch {
-      const specDir = path36.join(this.specsDir, specId);
+      const specDir = path38.join(this.specsDir, specId);
       try {
-        const files = await fs22.readdir(specDir);
+        const files = await fs23.readdir(specDir);
         const mdFiles = files.filter((f) => f.endsWith(".md"));
         const requirements = [];
         for (const file of mdFiles) {
-          const filePath = path36.join(specDir, file);
-          const content = await fs22.readFile(filePath, "utf-8");
+          const filePath = path38.join(specDir, file);
+          const content = await fs23.readFile(filePath, "utf-8");
           requirements.push(...this.extractRequirements(content, specId));
         }
         return requirements;
@@ -13398,7 +14173,7 @@ var SpecParser = class {
    */
   async listSpecs() {
     try {
-      const entries = await fs22.readdir(this.specsDir, { withFileTypes: true });
+      const entries = await fs23.readdir(this.specsDir, { withFileTypes: true });
       return entries.filter((e) => e.isDirectory()).map((e) => e.name);
     } catch {
       return [];
@@ -13475,8 +14250,8 @@ var SpecParser = class {
 };
 
 // src/core/sync/code-scanner.ts
-import { promises as fs23, statSync as statSync2 } from "fs";
-import path37 from "path";
+import { promises as fs24, statSync as statSync2 } from "fs";
+import path39 from "path";
 import { glob } from "glob";
 var SPEC_ANNOTATION_PATTERN = /@spec:?\s+(REQ-\d+(?:\s*,\s*REQ-\d+)*)/gi;
 var REQ_ID_PATTERN2 = /REQ-\d+/gi;
@@ -13495,7 +14270,7 @@ var DEFAULT_INCLUDE = ["**/*.ts", "**/*.js", "**/*.tsx", "**/*.jsx"];
 var CodeScanner = class {
   constructor(projectRoot, options = {}) {
     this.projectRoot = projectRoot;
-    this.srcDir = options.srcDir || path37.join(projectRoot, "src");
+    this.srcDir = options.srcDir || path39.join(projectRoot, "src");
     this.include = options.include || DEFAULT_INCLUDE;
     this.exclude = options.exclude || DEFAULT_EXCLUDE;
   }
@@ -13519,7 +14294,7 @@ var CodeScanner = class {
    */
   async scanFile(filePath) {
     try {
-      const content = await fs23.readFile(filePath, "utf-8");
+      const content = await fs24.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       const references = [];
       for (let i = 0; i < lines.length; i++) {
@@ -13531,7 +14306,7 @@ var CodeScanner = class {
           for (const reqMatch of reqIds) {
             references.push({
               reqId: reqMatch[0].toUpperCase(),
-              file: path37.relative(this.projectRoot, filePath),
+              file: path39.relative(this.projectRoot, filePath),
               line: lineNum,
               type: "code",
               context: line.trim()
@@ -13575,8 +14350,8 @@ var CodeScanner = class {
 };
 
 // src/core/sync/test-scanner.ts
-import { promises as fs24 } from "fs";
-import path38 from "path";
+import { promises as fs25 } from "fs";
+import path40 from "path";
 import { glob as glob2 } from "glob";
 var TEST_REQ_PATTERN = /(?:it|test|describe)\s*\(\s*['"`]([^'"`]*REQ-\d+[^'"`]*)/gi;
 var REQ_ID_PATTERN3 = /REQ-\d+/gi;
@@ -13616,7 +14391,7 @@ var TestScanner = class {
    */
   async scanFile(filePath) {
     try {
-      const content = await fs24.readFile(filePath, "utf-8");
+      const content = await fs25.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       const references = [];
       for (let i = 0; i < lines.length; i++) {
@@ -13629,7 +14404,7 @@ var TestScanner = class {
           for (const reqMatch of reqIds) {
             references.push({
               reqId: reqMatch[0].toUpperCase(),
-              file: path38.relative(this.projectRoot, filePath),
+              file: path40.relative(this.projectRoot, filePath),
               line: lineNum,
               type: "test",
               context: testDescription.trim()
@@ -13642,12 +14417,12 @@ var TestScanner = class {
           for (const reqMatch of reqIds) {
             const reqId = reqMatch[0].toUpperCase();
             const exists = references.some(
-              (r) => r.reqId === reqId && r.file === path38.relative(this.projectRoot, filePath) && r.line === lineNum
+              (r) => r.reqId === reqId && r.file === path40.relative(this.projectRoot, filePath) && r.line === lineNum
             );
             if (!exists) {
               references.push({
                 reqId,
-                file: path38.relative(this.projectRoot, filePath),
+                file: path40.relative(this.projectRoot, filePath),
                 line: lineNum,
                 type: "test",
                 context: line.trim()
@@ -14149,7 +14924,7 @@ var DiffOptionsSchema = z10.object({
 // src/core/diff/git-diff.ts
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import path39 from "path";
+import path41 from "path";
 var execAsync2 = promisify2(exec2);
 var GitDiff = class {
   constructor(projectRoot) {
@@ -14159,8 +14934,8 @@ var GitDiff = class {
    * Git diff 실행하여 변경된 스펙 파일 목록 조회
    */
   async getChangedSpecFiles(options = {}) {
-    const specsDir = path39.join(this.projectRoot, ".sdd", "specs");
-    const specPath = options.specPath ? path39.join(specsDir, options.specPath) : specsDir;
+    const specsDir = path41.join(this.projectRoot, ".sdd", "specs");
+    const specPath = options.specPath ? path41.join(specsDir, options.specPath) : specsDir;
     const normalizedPath = specPath.replace(/\\/g, "/");
     try {
       let diffCommand;
@@ -14244,9 +15019,9 @@ var GitDiff = class {
         }
       } else {
         try {
-          const fs27 = await import("fs/promises");
-          const absolutePath = path39.join(this.projectRoot, filePath);
-          after = await fs27.readFile(absolutePath, "utf-8");
+          const fs28 = await import("fs/promises");
+          const absolutePath = path41.join(this.projectRoot, filePath);
+          after = await fs28.readFile(absolutePath, "utf-8");
         } catch {
         }
       }
@@ -14897,8 +15672,8 @@ function registerDiffCommand(program2) {
 }
 
 // src/core/export/index.ts
-import { promises as fs26 } from "fs";
-import path41 from "path";
+import { promises as fs27 } from "fs";
+import path43 from "path";
 
 // src/core/export/schemas.ts
 import { z as z11 } from "zod";
@@ -14954,8 +15729,8 @@ var ExportResultSchema = z11.object({
 });
 
 // src/core/export/spec-parser.ts
-import { promises as fs25 } from "fs";
-import path40 from "path";
+import { promises as fs26 } from "fs";
+import path42 from "path";
 import { glob as glob3 } from "glob";
 function parseMetadata3(content) {
   const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
@@ -15120,7 +15895,7 @@ function parseDescription(content) {
   return match ? match[1].trim() : "";
 }
 async function parseSpecFile(filePath, specId) {
-  const content = await fs25.readFile(filePath, "utf-8");
+  const content = await fs26.readFile(filePath, "utf-8");
   const metadata = parseMetadata3(content);
   const body = content.replace(/^---\s*\n[\s\S]*?\n---\s*\n?/, "");
   return {
@@ -15139,7 +15914,7 @@ async function parseSpecFile(filePath, specId) {
   };
 }
 async function parseAllSpecs(projectRoot) {
-  const specsDir = path40.join(projectRoot, ".sdd", "specs");
+  const specsDir = path42.join(projectRoot, ".sdd", "specs");
   const normalizedDir = specsDir.replace(/\\/g, "/");
   const specFiles = await glob3(`${normalizedDir}/**/spec.md`, {
     absolute: true,
@@ -15147,8 +15922,8 @@ async function parseAllSpecs(projectRoot) {
   });
   const specs = [];
   for (const filePath of specFiles) {
-    const specDir = path40.dirname(filePath);
-    const specId = path40.basename(specDir);
+    const specDir = path42.dirname(filePath);
+    const specId = path42.basename(specDir);
     try {
       const spec = await parseSpecFile(filePath, specId);
       specs.push(spec);
@@ -15158,7 +15933,7 @@ async function parseAllSpecs(projectRoot) {
   return specs;
 }
 async function parseSpecById(projectRoot, specId) {
-  const specPath = path40.join(projectRoot, ".sdd", "specs", specId, "spec.md");
+  const specPath = path42.join(projectRoot, ".sdd", "specs", specId, "spec.md");
   try {
     return await parseSpecFile(specPath, specId);
   } catch {
@@ -15762,7 +16537,7 @@ function generateJson(specs, options = {}) {
 // src/core/export/index.ts
 function getDefaultOutputPath(projectRoot, format, specIds) {
   const baseName = specIds?.length === 1 ? specIds[0] : "specs";
-  return path41.join(projectRoot, `${baseName}.${format}`);
+  return path43.join(projectRoot, `${baseName}.${format}`);
 }
 async function executeExport(projectRoot, options = {}) {
   const {
@@ -15823,7 +16598,7 @@ async function executeExport(projectRoot, options = {}) {
           title: specs.length === 1 ? specs[0].title : "SDD \uC2A4\uD399 \uBB38\uC11C"
         });
         const htmlPath = outputPath.replace(/\.pdf$/, ".html");
-        await fs26.writeFile(htmlPath, content, "utf-8");
+        await fs27.writeFile(htmlPath, content, "utf-8");
         return {
           success: true,
           outputPath: htmlPath,
@@ -15841,9 +16616,9 @@ async function executeExport(projectRoot, options = {}) {
           error: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD615\uC2DD: ${format}`
         };
     }
-    const outputDir = path41.dirname(outputPath);
-    await fs26.mkdir(outputDir, { recursive: true });
-    await fs26.writeFile(outputPath, content, "utf-8");
+    const outputDir = path43.dirname(outputPath);
+    await fs27.mkdir(outputDir, { recursive: true });
+    await fs27.writeFile(outputPath, content, "utf-8");
     return {
       success: true,
       outputPath,
@@ -15934,6 +16709,7 @@ registerPrepareCommand(program);
 registerSyncCommand(program);
 registerDiffCommand(program);
 registerExportCommand(program);
+registerGitCommand(program);
 function run() {
   program.parse();
 }