sdd-tool 0.4.0 → 0.5.0

package/dist/cli/index.js

@@ -128,10 +128,10 @@ var init_base = __esm({
     };
     FileSystemError = class extends SddError {
       path;
-      constructor(code, path20) {
-        super(code, formatMessage(code, path20), ExitCode.FILE_SYSTEM_ERROR);
+      constructor(code, path27) {
+        super(code, formatMessage(code, path27), ExitCode.FILE_SYSTEM_ERROR);
         this.name = "FileSystemError";
-        this.path = path20;
+        this.path = path27;
       }
     };
     ValidationError = class extends SddError {
@@ -3631,9 +3631,9 @@ async function validateSpecs(targetPath, options = {}) {
 async function findSpecFiles(dirPath) {
   const files = [];
   async function scanDir(dir) {
-    const { promises: fs12 } = await import("fs");
+    const { promises: fs15 } = await import("fs");
     try {
-      const entries = await fs12.readdir(dir, { withFileTypes: true });
+      const entries = await fs15.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path3.join(dir, entry.name);
         if (entry.isDirectory()) {
@@ -5635,19 +5635,19 @@ function detectCircularDependencies(graph) {
   const cycles = [];
   const visited = /* @__PURE__ */ new Set();
   const recStack = /* @__PURE__ */ new Set();
-  function dfs(nodeId, path20) {
+  function dfs(nodeId, path27) {
     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, [...path20, nodeId])) {
+        if (dfs(depId, [...path27, nodeId])) {
           return true;
         }
       } else if (recStack.has(depId)) {
-        const cycleStart = path20.indexOf(depId);
-        const cycle = cycleStart >= 0 ? [...path20.slice(cycleStart), nodeId, depId] : [nodeId, depId];
+        const cycleStart = path27.indexOf(depId);
+        const cycle = cycleStart >= 0 ? [...path27.slice(cycleStart), nodeId, depId] : [nodeId, depId];
         cycles.push({
           cycle,
           description: `\uC21C\uD658 \uC758\uC874\uC131: ${cycle.join(" \u2192 ")}`
@@ -8139,12 +8139,354 @@ function displayConstitutionGuide() {
 }
 
 // src/cli/commands/migrate.ts
-import path17 from "path";
-import { promises as fs11 } from "fs";
+import path18 from "path";
+import { promises as fs12 } from "fs";
 init_errors();
 init_fs();
 init_new();
 init_schemas();
+
+// src/core/migrate/detector.ts
+init_types();
+init_errors();
+init_fs();
+import path17 from "path";
+import fs11 from "fs/promises";
+async function detectExternalTools(projectRoot) {
+  try {
+    const results = [];
+    const openspecResult = await detectOpenSpec(projectRoot);
+    if (openspecResult) {
+      results.push(openspecResult);
+    }
+    const speckitResult = await detectSpecKit(projectRoot);
+    if (speckitResult) {
+      results.push(speckitResult);
+    }
+    const sddResult = await detectSdd(projectRoot);
+    if (sddResult) {
+      results.push(sddResult);
+    }
+    return success(results);
+  } catch (error2) {
+    return failure(new ChangeError(error2 instanceof Error ? error2.message : String(error2)));
+  }
+}
+async function detectOpenSpec(projectRoot) {
+  const openspecPath = path17.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 hasAgents = await fileExists(agentsPath);
+  const hasSpecs = await directoryExists(specsPath);
+  const hasChanges = await directoryExists(changesPath);
+  if (!hasSpecs && !hasChanges && !hasAgents) {
+    return null;
+  }
+  const specs = [];
+  if (hasSpecs) {
+    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");
+        if (await fileExists(specFile)) {
+          const content = await fs11.readFile(specFile, "utf-8");
+          const title2 = extractTitle2(content);
+          const status = extractFrontmatterField(content, "status");
+          specs.push({
+            id: entry.name,
+            title: title2,
+            path: specPath,
+            status
+          });
+        }
+      }
+    }
+  }
+  return {
+    tool: "openspec",
+    path: openspecPath,
+    specCount: specs.length,
+    specs,
+    confidence: hasAgents ? "high" : hasSpecs && hasChanges ? "medium" : "low"
+  };
+}
+async function detectSpecKit(projectRoot) {
+  const specifyPath = path17.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 hasSpecs = await directoryExists(specsPath);
+  const hasConstitution = await fileExists(constitutionPath);
+  if (!hasSpecs) {
+    return null;
+  }
+  const specs = [];
+  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 hasSpec = await fileExists(specFile);
+      const hasPlan = await fileExists(planFile);
+      const hasTasks = await fileExists(tasksFile);
+      if (hasSpec || hasPlan) {
+        let title2;
+        let status;
+        if (hasSpec) {
+          const content = await fs11.readFile(specFile, "utf-8");
+          title2 = extractTitle2(content);
+          status = extractFrontmatterField(content, "status");
+        }
+        specs.push({
+          id: entry.name,
+          title: title2,
+          path: specPath,
+          status: hasTasks ? "in-progress" : status
+        });
+      }
+    }
+  }
+  return {
+    tool: "speckit",
+    path: specifyPath,
+    specCount: specs.length,
+    specs,
+    confidence: hasConstitution ? "high" : "medium"
+  };
+}
+async function detectSdd(projectRoot) {
+  const sddPath = path17.join(projectRoot, ".sdd");
+  if (!await directoryExists(sddPath)) {
+    return null;
+  }
+  const specsPath = path17.join(sddPath, "specs");
+  const configPath = path17.join(sddPath, "config.yaml");
+  if (!await directoryExists(specsPath)) {
+    return null;
+  }
+  const specs = [];
+  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");
+      if (await fileExists(specFile)) {
+        const content = await fs11.readFile(specFile, "utf-8");
+        const title2 = extractTitle2(content);
+        const status = extractFrontmatterField(content, "status");
+        specs.push({
+          id: entry.name,
+          title: title2,
+          path: specPath,
+          status
+        });
+      }
+    }
+  }
+  return {
+    tool: "sdd",
+    path: sddPath,
+    specCount: specs.length,
+    specs,
+    confidence: await fileExists(configPath) ? "high" : "medium"
+  };
+}
+async function migrateFromOpenSpec(sourcePath, targetPath, options = {}) {
+  try {
+    const specsPath = path17.join(sourcePath, "specs");
+    const targetSpecsPath = path17.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 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);
+      if (await directoryExists(targetSpecPath)) {
+        if (!options.overwrite) {
+          specsSkipped++;
+          continue;
+        }
+      }
+      try {
+        if (!options.dryRun) {
+          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 fs11.stat(sourceFile);
+            if (stat.isFile()) {
+              let content = await fs11.readFile(sourceFile, "utf-8");
+              if (file === "spec.md") {
+                content = convertOpenSpecToSdd(content, entry.name);
+              }
+              await fs11.writeFile(targetFile, content);
+            }
+          }
+        }
+        specsCreated++;
+      } catch (error2) {
+        errors.push(`${entry.name}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      }
+    }
+    return success({
+      source: "openspec",
+      targetPath,
+      specsCreated,
+      specsSkipped,
+      errors
+    });
+  } catch (error2) {
+    return failure(new ChangeError(error2 instanceof Error ? error2.message : String(error2)));
+  }
+}
+async function migrateFromSpecKit(sourcePath, targetPath, options = {}) {
+  try {
+    const specsPath = path17.join(sourcePath, "specs");
+    const targetSpecsPath = path17.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 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);
+      if (await directoryExists(targetSpecPath)) {
+        if (!options.overwrite) {
+          specsSkipped++;
+          continue;
+        }
+      }
+      try {
+        if (!options.dryRun) {
+          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 fs11.stat(sourceFile);
+            if (stat.isFile()) {
+              let content = await fs11.readFile(sourceFile, "utf-8");
+              if (file === "spec.md") {
+                content = convertSpecKitToSdd(content, entry.name);
+              }
+              await fs11.writeFile(targetFile, content);
+            }
+          }
+        }
+        specsCreated++;
+      } catch (error2) {
+        errors.push(`${entry.name}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      }
+    }
+    return success({
+      source: "speckit",
+      targetPath,
+      specsCreated,
+      specsSkipped,
+      errors
+    });
+  } catch (error2) {
+    return failure(new ChangeError(error2 instanceof Error ? error2.message : String(error2)));
+  }
+}
+function convertOpenSpecToSdd(content, specId) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    const title2 = extractTitle2(content) || specId;
+    return `---
+id: ${specId}
+title: ${title2}
+phase: migrated
+status: draft
+source: openspec
+migrated_at: ${(/* @__PURE__ */ new Date()).toISOString()}
+---
+
+${content}`;
+  }
+  let newFrontmatter = frontmatterMatch[1];
+  if (!newFrontmatter.includes("phase:")) {
+    newFrontmatter += "\nphase: migrated";
+  }
+  if (!newFrontmatter.includes("source:")) {
+    newFrontmatter += "\nsource: openspec";
+  }
+  if (!newFrontmatter.includes("migrated_at:")) {
+    newFrontmatter += `
+migrated_at: ${(/* @__PURE__ */ new Date()).toISOString()}`;
+  }
+  return content.replace(/^---\n[\s\S]*?\n---/, `---
+${newFrontmatter}
+---`);
+}
+function convertSpecKitToSdd(content, specId) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    const title2 = extractTitle2(content) || specId;
+    return `---
+id: ${specId}
+title: ${title2}
+phase: migrated
+status: draft
+source: speckit
+migrated_at: ${(/* @__PURE__ */ new Date()).toISOString()}
+---
+
+${content}`;
+  }
+  let newFrontmatter = frontmatterMatch[1];
+  if (!newFrontmatter.includes("phase:")) {
+    newFrontmatter += "\nphase: migrated";
+  }
+  if (!newFrontmatter.includes("source:")) {
+    newFrontmatter += "\nsource: speckit";
+  }
+  if (!newFrontmatter.includes("migrated_at:")) {
+    newFrontmatter += `
+migrated_at: ${(/* @__PURE__ */ new Date()).toISOString()}`;
+  }
+  return content.replace(/^---\n[\s\S]*?\n---/, `---
+${newFrontmatter}
+---`);
+}
+function extractTitle2(content) {
+  const fmMatch = content.match(/^---\n[\s\S]*?title:\s*['"]?([^'"\n]+)['"]?\n[\s\S]*?\n---/);
+  if (fmMatch) {
+    return fmMatch[1].trim();
+  }
+  const h1Match = content.match(/^#\s+(.+)$/m);
+  if (h1Match) {
+    return h1Match[1].trim();
+  }
+  return void 0;
+}
+function extractFrontmatterField(content, field) {
+  const regex = new RegExp(`^---\\n[\\s\\S]*?${field}:\\s*['"]?([^'"\\n]+)['"]?\\n[\\s\\S]*?\\n---`);
+  const match = content.match(regex);
+  return match ? match[1].trim() : void 0;
+}
+
+// src/cli/commands/migrate.ts
 function registerMigrateCommand(program2) {
   const migrate = program2.command("migrate").description("\uAE30\uC874 \uBB38\uC11C\uB97C SDD \uD615\uC2DD\uC73C\uB85C \uB9C8\uC774\uADF8\uB808\uC774\uC158\uD569\uB2C8\uB2E4");
   migrate.command("docs <source>").description("\uB9C8\uD06C\uB2E4\uC6B4 \uBB38\uC11C\uB97C spec.md \uD615\uC2DD\uC73C\uB85C \uBCC0\uD658\uD569\uB2C8\uB2E4").option("-o, --output <dir>", "\uCD9C\uB825 \uB514\uB809\uD1A0\uB9AC").option("--dry-run", "\uC2E4\uC81C \uD30C\uC77C \uC0DD\uC131 \uC5C6\uC774 \uBBF8\uB9AC\uBCF4\uAE30").action(async (source, options) => {
@@ -8171,6 +8513,30 @@ function registerMigrateCommand(program2) {
       process.exit(ExitCode.GENERAL_ERROR);
     }
   });
+  migrate.command("detect").description("\uD504\uB85C\uC81D\uD2B8\uC5D0\uC11C \uC678\uBD80 SDD \uB3C4\uAD6C\uB97C \uAC10\uC9C0\uD569\uB2C8\uB2E4").option("-p, --path <path>", "\uAC80\uC0C9 \uACBD\uB85C").action(async (options) => {
+    try {
+      await runDetect(options);
+    } catch (error2) {
+      error(error2 instanceof Error ? error2.message : String(error2));
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+  });
+  migrate.command("openspec [source]").description("OpenSpec \uD504\uB85C\uC81D\uD2B8\uC5D0\uC11C \uB9C8\uC774\uADF8\uB808\uC774\uC158\uD569\uB2C8\uB2E4").option("--dry-run", "\uC2E4\uC81C \uD30C\uC77C \uC0DD\uC131 \uC5C6\uC774 \uBBF8\uB9AC\uBCF4\uAE30").option("--overwrite", "\uAE30\uC874 \uC2A4\uD399 \uB36E\uC5B4\uC4F0\uAE30").action(async (source, options) => {
+    try {
+      await runMigrateOpenSpec(source, options);
+    } catch (error2) {
+      error(error2 instanceof Error ? error2.message : String(error2));
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+  });
+  migrate.command("speckit [source]").description("Spec Kit \uD504\uB85C\uC81D\uD2B8\uC5D0\uC11C \uB9C8\uC774\uADF8\uB808\uC774\uC158\uD569\uB2C8\uB2E4").option("--dry-run", "\uC2E4\uC81C \uD30C\uC77C \uC0DD\uC131 \uC5C6\uC774 \uBBF8\uB9AC\uBCF4\uAE30").option("--overwrite", "\uAE30\uC874 \uC2A4\uD399 \uB36E\uC5B4\uC4F0\uAE30").action(async (source, options) => {
+    try {
+      await runMigrateSpecKit(source, options);
+    } catch (error2) {
+      error(error2 instanceof Error ? error2.message : String(error2));
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+  });
 }
 async function runMigrateDocs(source, options) {
   const projectRoot = await findSddRoot();
@@ -8178,10 +8544,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 = path17.resolve(source);
+  const sourcePath = path18.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()) {
@@ -8197,7 +8563,7 @@ async function runMigrateDocs(source, options) {
   }
   info(`${files.length}\uAC1C \uD30C\uC77C \uBC1C\uACAC`);
   newline();
-  const outputDir = options.output ? path17.resolve(options.output) : path17.join(projectRoot, ".sdd", "specs");
+  const outputDir = options.output ? path18.resolve(options.output) : path18.join(projectRoot, ".sdd", "specs");
   const summary = {
     total: files.length,
     succeeded: 0,
@@ -8209,10 +8575,10 @@ async function runMigrateDocs(source, options) {
     summary.results.push(result);
     if (result.success) {
       summary.succeeded++;
-      info(`\u2705 ${path17.basename(file)} \u2192 ${result.target}`);
+      info(`\u2705 ${path18.basename(file)} \u2192 ${result.target}`);
     } else {
       summary.failed++;
-      error(`\u274C ${path17.basename(file)}: ${result.error}`);
+      error(`\u274C ${path18.basename(file)}: ${result.error}`);
     }
   }
   newline();
@@ -8224,25 +8590,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 || path17.basename(filePath, ".md"));
+    const featureId = generateFeatureId(analysis.title || path18.basename(filePath, ".md"));
     const specContent = generateSpec({
       id: featureId,
-      title: analysis.title || path17.basename(filePath, ".md"),
+      title: analysis.title || path18.basename(filePath, ".md"),
       description: analysis.description || "",
       requirements: analysis.requirements,
       scenarios: analysis.scenarios
     });
-    const targetDir = path17.join(outputDir, featureId);
-    const targetPath = path17.join(targetDir, "spec.md");
+    const targetDir = path18.join(outputDir, featureId);
+    const targetPath = path18.join(targetDir, "spec.md");
     if (!dryRun) {
       await ensureDir(targetDir);
       await writeFile(targetPath, specContent);
     }
     return {
       source: filePath,
-      target: path17.relative(process.cwd(), targetPath),
+      target: path18.relative(process.cwd(), targetPath),
       success: true
     };
   } catch (error2) {
@@ -8287,14 +8653,14 @@ function analyzeDocument(content) {
   };
 }
 async function runAnalyze(file) {
-  const filePath = path17.resolve(file);
+  const filePath = path18.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: ${path17.basename(file)}`);
+  info(`\u{1F4CA} \uBB38\uC11C \uBD84\uC11D: ${path18.basename(file)}`);
   newline();
   info(`\uC81C\uBAA9: ${analysis.title || "(\uC5C6\uC74C)"}`);
   info(`\uC124\uBA85: ${analysis.description || "(\uC5C6\uC74C)"}`);
@@ -8337,7 +8703,7 @@ async function runAnalyze(file) {
   }
 }
 async function runScan(dir, options) {
-  const dirPath = path17.resolve(dir);
+  const dirPath = path18.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);
@@ -8353,7 +8719,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 {
@@ -8368,7 +8734,7 @@ async function runScan(dir, options) {
   const partial = [];
   const notReady = [];
   for (const { file, analysis } of results) {
-    const relativePath = path17.relative(process.cwd(), file);
+    const relativePath = path18.relative(process.cwd(), file);
     if (analysis.hasRfc2119 && analysis.hasScenarios) {
       ready.push(relativePath);
     } else if (analysis.hasRfc2119 || analysis.hasScenarios || analysis.requirements.length > 0) {
@@ -8415,15 +8781,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 = path17.join(dir, entry.name);
+      const fullPath = path18.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 = path17.extname(entry.name).toLowerCase();
+        const ext = path18.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);
@@ -8435,9 +8801,200 @@ async function collectFilesWithExtensions(dirPath, extensions) {
   await scan(dirPath);
   return files;
 }
+async function runDetect(options) {
+  const projectRoot = options.path ? path18.resolve(options.path) : process.cwd();
+  info("\u{1F50D} \uC678\uBD80 SDD \uB3C4\uAD6C \uAC10\uC9C0 \uC911...");
+  info(`   \uACBD\uB85C: ${projectRoot}`);
+  newline();
+  const result = await detectExternalTools(projectRoot);
+  if (!result.success) {
+    error(result.error.message);
+    process.exit(ExitCode.GENERAL_ERROR);
+  }
+  const tools = result.data;
+  if (tools.length === 0) {
+    info("\uAC10\uC9C0\uB41C \uC678\uBD80 SDD \uB3C4\uAD6C\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    return;
+  }
+  for (const tool of tools) {
+    const icon = getToolIcon(tool.tool);
+    const confidence = getConfidenceLabel(tool.confidence);
+    info(`${icon} ${getToolName(tool.tool)}`);
+    info(`   \uACBD\uB85C: ${tool.path}`);
+    info(`   \uC2E0\uB8B0\uB3C4: ${confidence}`);
+    info(`   \uC2A4\uD399 \uC218: ${tool.specCount}\uAC1C`);
+    if (tool.specs.length > 0) {
+      newline();
+      info("   \uBC1C\uACAC\uB41C \uC2A4\uD399:");
+      for (const spec of tool.specs.slice(0, 5)) {
+        const status = spec.status ? ` [${spec.status}]` : "";
+        listItem(`${spec.id}: ${spec.title || "(\uC81C\uBAA9 \uC5C6\uC74C)"}${status}`, 2);
+      }
+      if (tool.specs.length > 5) {
+        info(`      ... \uC678 ${tool.specs.length - 5}\uAC1C`);
+      }
+    }
+    newline();
+  }
+  const openspec = tools.find((t) => t.tool === "openspec");
+  const speckit = tools.find((t) => t.tool === "speckit");
+  if (openspec || speckit) {
+    info("\u{1F4A1} \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uBA85\uB839\uC5B4:");
+    if (openspec) {
+      listItem(`sdd migrate openspec "${openspec.path}"`, 1);
+    }
+    if (speckit) {
+      listItem(`sdd migrate speckit "${speckit.path}"`, 1);
+    }
+  }
+}
+async function runMigrateOpenSpec(source, options) {
+  const projectRoot = await findSddRoot();
+  if (!projectRoot) {
+    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);
+  }
+  let sourcePath;
+  if (source) {
+    sourcePath = path18.resolve(source);
+  } else {
+    const detectResult = await detectExternalTools(projectRoot);
+    if (!detectResult.success) {
+      error(detectResult.error.message);
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+    const openspec = detectResult.data.find((t) => t.tool === "openspec");
+    if (!openspec) {
+      error("OpenSpec \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uACBD\uB85C\uB97C \uC9C1\uC811 \uC9C0\uC815\uD558\uC138\uC694.");
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+    sourcePath = openspec.path;
+  }
+  const sddPath = path18.join(projectRoot, ".sdd");
+  info("\u{1F504} OpenSpec\uC5D0\uC11C \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC911...");
+  info(`   \uC18C\uC2A4: ${sourcePath}`);
+  info(`   \uB300\uC0C1: ${sddPath}`);
+  if (options.dryRun) {
+    warn("   (dry-run \uBAA8\uB4DC)");
+  }
+  newline();
+  const result = await migrateFromOpenSpec(sourcePath, sddPath, {
+    dryRun: options.dryRun,
+    overwrite: options.overwrite
+  });
+  if (!result.success) {
+    error(result.error.message);
+    process.exit(ExitCode.GENERAL_ERROR);
+  }
+  const data = result.data;
+  success2("\u2705 \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC644\uB8CC");
+  info(`   \uC0DD\uC131: ${data.specsCreated}\uAC1C`);
+  info(`   \uC2A4\uD0B5: ${data.specsSkipped}\uAC1C`);
+  if (data.errors.length > 0) {
+    newline();
+    warn("\u26A0\uFE0F  \uC77C\uBD80 \uC624\uB958 \uBC1C\uC0DD:");
+    for (const error2 of data.errors) {
+      error(`   - ${error2}`);
+    }
+  }
+  if (options.dryRun) {
+    newline();
+    info("\uC2E4\uC81C \uB9C8\uC774\uADF8\uB808\uC774\uC158\uC744 \uC218\uD589\uD558\uB824\uBA74 --dry-run \uC635\uC158\uC744 \uC81C\uAC70\uD558\uC138\uC694.");
+  }
+}
+async function runMigrateSpecKit(source, options) {
+  const projectRoot = await findSddRoot();
+  if (!projectRoot) {
+    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);
+  }
+  let sourcePath;
+  if (source) {
+    sourcePath = path18.resolve(source);
+  } else {
+    const detectResult = await detectExternalTools(projectRoot);
+    if (!detectResult.success) {
+      error(detectResult.error.message);
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+    const speckit = detectResult.data.find((t) => t.tool === "speckit");
+    if (!speckit) {
+      error("Spec Kit \uD504\uB85C\uC81D\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uACBD\uB85C\uB97C \uC9C1\uC811 \uC9C0\uC815\uD558\uC138\uC694.");
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+    sourcePath = speckit.path;
+  }
+  const sddPath = path18.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}`);
+  if (options.dryRun) {
+    warn("   (dry-run \uBAA8\uB4DC)");
+  }
+  newline();
+  const result = await migrateFromSpecKit(sourcePath, sddPath, {
+    dryRun: options.dryRun,
+    overwrite: options.overwrite
+  });
+  if (!result.success) {
+    error(result.error.message);
+    process.exit(ExitCode.GENERAL_ERROR);
+  }
+  const data = result.data;
+  success2("\u2705 \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC644\uB8CC");
+  info(`   \uC0DD\uC131: ${data.specsCreated}\uAC1C`);
+  info(`   \uC2A4\uD0B5: ${data.specsSkipped}\uAC1C`);
+  if (data.errors.length > 0) {
+    newline();
+    warn("\u26A0\uFE0F  \uC77C\uBD80 \uC624\uB958 \uBC1C\uC0DD:");
+    for (const error2 of data.errors) {
+      error(`   - ${error2}`);
+    }
+  }
+  if (options.dryRun) {
+    newline();
+    info("\uC2E4\uC81C \uB9C8\uC774\uADF8\uB808\uC774\uC158\uC744 \uC218\uD589\uD558\uB824\uBA74 --dry-run \uC635\uC158\uC744 \uC81C\uAC70\uD558\uC138\uC694.");
+  }
+}
+function getToolIcon(tool) {
+  switch (tool) {
+    case "openspec":
+      return "\u{1F4E6}";
+    case "speckit":
+      return "\u{1F527}";
+    case "sdd":
+      return "\u{1F4CB}";
+    default:
+      return "\u2753";
+  }
+}
+function getToolName(tool) {
+  switch (tool) {
+    case "openspec":
+      return "OpenSpec";
+    case "speckit":
+      return "Spec Kit";
+    case "sdd":
+      return "SDD";
+    default:
+      return tool;
+  }
+}
+function getConfidenceLabel(confidence) {
+  switch (confidence) {
+    case "high":
+      return "\uB192\uC74C \u2713";
+    case "medium":
+      return "\uC911\uAC04";
+    case "low":
+      return "\uB0AE\uC74C";
+    default:
+      return confidence;
+  }
+}
 
 // src/cli/commands/cicd.ts
-import path18 from "path";
+import path19 from "path";
 init_errors();
 init_fs();
 function registerCicdCommand(program2) {
@@ -8489,16 +9046,16 @@ 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 = path18.join(projectRoot, ".github", "workflows");
+  const workflowDir = path19.join(projectRoot, ".github", "workflows");
   await ensureDir(workflowDir);
   const workflowContent = generateGitHubWorkflow(strict);
-  const workflowPath = path18.join(workflowDir, "sdd-validate.yml");
+  const workflowPath = path19.join(workflowDir, "sdd-validate.yml");
   await writeFile(workflowPath, workflowContent);
   info(`\u2705 GitHub Actions \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC0DD\uC131: .github/workflows/sdd-validate.yml`);
 }
 async function setupGitLabCI(projectRoot, strict) {
   const ciContent = generateGitLabCI(strict);
-  const ciPath = path18.join(projectRoot, ".gitlab-ci-sdd.yml");
+  const ciPath = path19.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)");
@@ -8594,7 +9151,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 = path18.join(projectRoot, ".husky");
+  const hooksDir = path19.join(projectRoot, ".husky");
   if (options.install) {
     info("husky \uC124\uCE58 \uBC29\uBC95:");
     newline();
@@ -8608,7 +9165,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 = path18.join(hooksDir, hook);
+    const hookPath = path19.join(hooksDir, hook);
     await writeFile(hookPath, hookContent);
     info(`\u2705 ${hook} \uD6C5 \uC0DD\uC131: .husky/${hook}`);
   }
@@ -8690,7 +9247,7 @@ async function runCiCheck(options) {
   let hasErrors = false;
   let hasWarnings = false;
   info("1. Constitution \uAC80\uC99D...");
-  const constitutionPath = path18.join(projectRoot, ".sdd", "constitution.md");
+  const constitutionPath = path19.join(projectRoot, ".sdd", "constitution.md");
   if (await fileExists(constitutionPath)) {
     info("   \u2705 constitution.md \uC874\uC7AC");
   } else {
@@ -8698,7 +9255,7 @@ async function runCiCheck(options) {
     hasWarnings = true;
   }
   info("2. \uC2A4\uD399 \uB514\uB809\uD1A0\uB9AC \uD655\uC778...");
-  const specsPath = path18.join(projectRoot, ".sdd", "specs");
+  const specsPath = path19.join(projectRoot, ".sdd", "specs");
   if (await directoryExists(specsPath)) {
     info("   \u2705 specs/ \uB514\uB809\uD1A0\uB9AC \uC874\uC7AC");
   } else {
@@ -8708,7 +9265,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 = path18.join(projectRoot, ".sdd", dir);
+    const dirPath = path19.join(projectRoot, ".sdd", dir);
     if (await directoryExists(dirPath)) {
       info(`   \u2705 ${dir}/ \uC874\uC7AC`);
     } else {
@@ -8736,7 +9293,7 @@ async function runCiCheck(options) {
 }
 
 // src/cli/commands/transition.ts
-import path19 from "path";
+import path20 from "path";
 init_errors();
 init_fs();
 function registerTransitionCommand(program2) {
@@ -8767,9 +9324,9 @@ 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 = path19.join(projectRoot, ".sdd");
-  const specsPath = path19.join(sddPath, "specs");
-  const specPath = path19.join(specsPath, specId, "spec.md");
+  const sddPath = path20.join(projectRoot, ".sdd");
+  const specsPath = path20.join(sddPath, "specs");
+  const specPath = path20.join(specsPath, specId, "spec.md");
   if (!await fileExists(specPath)) {
     error(`\uC2A4\uD399\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${specId}`);
     info("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uC2A4\uD399 \uBAA9\uB85D\uC740 `sdd list`\uB85C \uD655\uC778\uD558\uC138\uC694.");
@@ -8779,7 +9336,7 @@ async function runNewToChange(specId, options) {
   newline();
   info(`\uB300\uC0C1 \uC2A4\uD399: ${specId}`);
   const changeId = generateChangeId();
-  const changePath = path19.join(sddPath, "changes", changeId);
+  const changePath = path20.join(sddPath, "changes", changeId);
   await ensureDir(changePath);
   const specContent = await readFile(specPath);
   if (!specContent.success) {
@@ -8789,11 +9346,11 @@ async function runNewToChange(specId, options) {
   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(path19.join(changePath, "proposal.md"), proposalContent);
+  await writeFile(path20.join(changePath, "proposal.md"), proposalContent);
   const deltaContent = generateDeltaTemplate(specId);
-  await writeFile(path19.join(changePath, "delta.md"), deltaContent);
+  await writeFile(path20.join(changePath, "delta.md"), deltaContent);
   const tasksContent = generateTasksTemplate();
-  await writeFile(path19.join(changePath, "tasks.md"), tasksContent);
+  await writeFile(path20.join(changePath, "tasks.md"), tasksContent);
   newline();
   success2(`\uC804\uD658 \uC644\uB8CC! \uBCC0\uACBD \uC81C\uC548\uC774 \uC0DD\uC131\uB418\uC5C8\uC2B5\uB2C8\uB2E4.`);
   newline();
@@ -8815,8 +9372,8 @@ 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 = path19.join(projectRoot, ".sdd");
-  const changePath = path19.join(sddPath, "changes", changeId);
+  const sddPath = path20.join(projectRoot, ".sdd");
+  const changePath = path20.join(sddPath, "changes", changeId);
   if (!await directoryExists(changePath)) {
     error(`\uBCC0\uACBD \uC81C\uC548\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${changeId}`);
     info("\uC9C4\uD589 \uC911\uC778 \uBCC0\uACBD \uBAA9\uB85D\uC740 `sdd change -l`\uB85C \uD655\uC778\uD558\uC138\uC694.");
@@ -8825,7 +9382,7 @@ async function runChangeToNew(changeId, options) {
   info("=== \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC804\uD658: change \u2192 new ===");
   newline();
   info(`\uC6D0\uBCF8 \uBCC0\uACBD: ${changeId}`);
-  const proposalPath = path19.join(changePath, "proposal.md");
+  const proposalPath = path20.join(changePath, "proposal.md");
   let extractedTitle = "";
   if (await fileExists(proposalPath)) {
     const proposalContent = await readFile(proposalPath);
@@ -8837,8 +9394,8 @@ async function runChangeToNew(changeId, options) {
     }
   }
   const featureName = options.name || extractedTitle.toLowerCase().replace(/\s+/g, "-") || `feature-from-${changeId}`;
-  const specsPath = path19.join(sddPath, "specs");
-  const newSpecPath = path19.join(specsPath, featureName);
+  const specsPath = path20.join(sddPath, "specs");
+  const newSpecPath = path20.join(specsPath, featureName);
   if (await directoryExists(newSpecPath)) {
     error(`\uC2A4\uD399\uC774 \uC774\uBBF8 \uC874\uC7AC\uD569\uB2C8\uB2E4: ${featureName}`);
     info("\uB2E4\uB978 \uC774\uB984\uC744 \uC9C0\uC815\uD558\uC138\uC694: --name <name>");
@@ -8847,12 +9404,12 @@ async function runChangeToNew(changeId, options) {
   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(path19.join(newSpecPath, "spec.md"), specContent);
+  await writeFile(path20.join(newSpecPath, "spec.md"), specContent);
   const planContent = generatePlanTemplate(featureName);
-  await writeFile(path19.join(newSpecPath, "plan.md"), planContent);
+  await writeFile(path20.join(newSpecPath, "plan.md"), planContent);
   const tasksContent = generateTasksTemplate();
-  await writeFile(path19.join(newSpecPath, "tasks.md"), tasksContent);
-  const statusPath = path19.join(changePath, ".status");
+  await writeFile(path20.join(newSpecPath, "tasks.md"), tasksContent);
+  const statusPath = path20.join(changePath, ".status");
   await writeFile(statusPath, JSON.stringify({
     status: "transitioned",
     transitionedTo: featureName,
@@ -9086,6 +9643,1135 @@ status: pending
 `;
 }
 
+// src/cli/commands/watch.ts
+import path22 from "path";
+
+// src/core/watch/watcher.ts
+import chokidar from "chokidar";
+import path21 from "path";
+import { EventEmitter } from "events";
+var SpecWatcher = class extends EventEmitter {
+  watcher = null;
+  specsPath;
+  debounceMs;
+  debounceTimer = null;
+  pendingEvents = [];
+  isRunning = false;
+  constructor(options) {
+    super();
+    this.specsPath = options.specsPath;
+    this.debounceMs = options.debounceMs ?? 500;
+  }
+  /**
+   * 감시 시작
+   */
+  start() {
+    if (this.isRunning) {
+      return;
+    }
+    const ignored = [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/.*"
+    ];
+    this.watcher = chokidar.watch(this.specsPath, {
+      persistent: true,
+      ignoreInitial: true,
+      ignored,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 100
+      }
+    });
+    this.watcher.on("add", (filePath) => this.handleEvent("add", filePath)).on("change", (filePath) => this.handleEvent("change", filePath)).on("unlink", (filePath) => this.handleEvent("unlink", filePath)).on("error", (error2) => this.emit("error", error2)).on("ready", () => {
+      this.isRunning = true;
+      this.emit("ready");
+    });
+  }
+  /**
+   * 감시 중지
+   */
+  async stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    this.isRunning = false;
+    this.pendingEvents = [];
+  }
+  /**
+   * 실행 상태 확인
+   */
+  get running() {
+    return this.isRunning;
+  }
+  /**
+   * 파일 이벤트 처리
+   */
+  handleEvent(type, filePath) {
+    if (!filePath.endsWith(".md")) {
+      return;
+    }
+    const event = {
+      type,
+      path: filePath,
+      relativePath: path21.relative(this.specsPath, filePath),
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.pendingEvents.push(event);
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.flushEvents();
+    }, this.debounceMs);
+  }
+  /**
+   * 대기 중인 이벤트 처리
+   */
+  flushEvents() {
+    if (this.pendingEvents.length === 0) {
+      return;
+    }
+    const events = [...this.pendingEvents];
+    this.pendingEvents = [];
+    this.debounceTimer = null;
+    this.emit("change", events);
+  }
+};
+function createWatcher(options) {
+  return new SpecWatcher(options);
+}
+
+// src/cli/commands/watch.ts
+init_fs();
+init_errors();
+function registerWatchCommand(program2) {
+  program2.command("watch").description("\uC2A4\uD399 \uD30C\uC77C \uBCC0\uACBD\uC744 \uC2E4\uC2DC\uAC04 \uAC10\uC2DC\uD558\uACE0 \uC790\uB3D9 \uAC80\uC99D\uD569\uB2C8\uB2E4").option("--no-validate", "\uC790\uB3D9 \uAC80\uC99D \uBE44\uD65C\uC131\uD654").option("--impact", "\uC601\uD5A5\uB3C4 \uBD84\uC11D \uD3EC\uD568").option("-q, --quiet", "\uC131\uACF5 \uC2DC \uCD9C\uB825 \uC0DD\uB7B5").option("--debounce <ms>", "\uB514\uBC14\uC6B4\uC2A4 \uC2DC\uAC04 (\uAE30\uBCF8: 500ms)", "500").action(async (options) => {
+    try {
+      await runWatch(options);
+    } catch (error2) {
+      error(error2 instanceof Error ? error2.message : String(error2));
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+  });
+}
+async function runWatch(options) {
+  const projectRoot = await findSddRoot();
+  if (!projectRoot) {
+    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 debounceMs = parseInt(options.debounce || "500", 10);
+  info("\u{1F441}\uFE0F  Watch \uBAA8\uB4DC \uC2DC\uC791");
+  info(`   \uACBD\uB85C: ${specsPath}`);
+  info(`   \uB514\uBC14\uC6B4\uC2A4: ${debounceMs}ms`);
+  info(`   \uAC80\uC99D: ${options.validate !== false ? "\uD65C\uC131\uD654" : "\uBE44\uD65C\uC131\uD654"}`);
+  newline();
+  info("\uD30C\uC77C \uBCC0\uACBD\uC744 \uAC10\uC2DC \uC911... (Ctrl+C\uB85C \uC885\uB8CC)");
+  newline();
+  const watcher = createWatcher({
+    specsPath,
+    debounceMs
+  });
+  let validationCount = 0;
+  let errorCount = 0;
+  watcher.on("change", async (events) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    const addCount = events.filter((e) => e.type === "add").length;
+    const changeCount = events.filter((e) => e.type === "change").length;
+    const unlinkCount = events.filter((e) => e.type === "unlink").length;
+    const parts = [];
+    if (addCount > 0) parts.push(`\uCD94\uAC00 ${addCount}`);
+    if (changeCount > 0) parts.push(`\uC218\uC815 ${changeCount}`);
+    if (unlinkCount > 0) parts.push(`\uC0AD\uC81C ${unlinkCount}`);
+    info(`[${timestamp}] \uBCC0\uACBD \uAC10\uC9C0: ${parts.join(", ")}`);
+    for (const event of events) {
+      const icon = event.type === "add" ? "\u2795" : event.type === "change" ? "\u270F\uFE0F" : "\u274C";
+      info(`  ${icon} ${event.relativePath}`);
+    }
+    if (options.validate !== false) {
+      newline();
+      info("\u{1F50D} \uAC80\uC99D \uC2E4\uD589 \uC911...");
+      const result = await validateSpecs(sddPath, { strict: false });
+      validationCount++;
+      if (result.success) {
+        const data = result.data;
+        const hasErrors = data.results.some((r) => r.errors.length > 0);
+        const hasWarnings = data.results.some((r) => r.warnings.length > 0);
+        if (hasErrors) {
+          errorCount++;
+          error(`\u274C \uAC80\uC99D \uC2E4\uD328: ${data.errorCount}\uAC1C \uC5D0\uB7EC, ${data.warningCount}\uAC1C \uACBD\uACE0`);
+          for (const specResult of data.results) {
+            if (specResult.errors.length > 0) {
+              error(`   ${specResult.file}:`);
+              for (const err of specResult.errors) {
+                error(`     - ${err}`);
+              }
+            }
+          }
+        } else if (hasWarnings) {
+          if (!options.quiet) {
+            warn(`\u26A0\uFE0F  \uAC80\uC99D \uC644\uB8CC: ${data.warningCount}\uAC1C \uACBD\uACE0`);
+          }
+        } else {
+          if (!options.quiet) {
+            success2(`\u2705 \uAC80\uC99D \uD1B5\uACFC (${data.validCount}\uAC1C \uC2A4\uD399)`);
+          }
+        }
+      } else {
+        errorCount++;
+        error(`\u274C \uAC80\uC99D \uC624\uB958: ${result.error.message}`);
+      }
+      newline();
+    }
+  });
+  watcher.on("error", (error2) => {
+    error(`\uAC10\uC2DC \uC624\uB958: ${error2.message}`);
+  });
+  watcher.on("ready", () => {
+    success2("\u2705 \uAC10\uC2DC \uC900\uBE44 \uC644\uB8CC");
+    newline();
+  });
+  const cleanup = async () => {
+    newline();
+    info("Watch \uBAA8\uB4DC \uC885\uB8CC \uC911...");
+    await watcher.stop();
+    newline();
+    info("\u{1F4CA} \uC138\uC158 \uC694\uC57D:");
+    info(`   \uAC80\uC99D \uC2E4\uD589: ${validationCount}\uD68C`);
+    info(`   \uC5D0\uB7EC \uBC1C\uC0DD: ${errorCount}\uD68C`);
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  watcher.start();
+  await new Promise(() => {
+  });
+}
+
+// src/cli/commands/quality.ts
+import path24 from "path";
+
+// src/core/quality/analyzer.ts
+init_types();
+init_errors();
+init_fs();
+import path23 from "path";
+import { promises as fs13 } from "fs";
+function getGrade(percentage) {
+  if (percentage >= 90) return "A";
+  if (percentage >= 80) return "B";
+  if (percentage >= 70) return "C";
+  if (percentage >= 60) return "D";
+  return "F";
+}
+function scoreRfc2119(content) {
+  const maxScore = 10;
+  const details = [];
+  const suggestions = [];
+  const keywords = ["SHALL", "MUST", "SHOULD", "MAY", "SHALL NOT", "MUST NOT", "SHOULD NOT"];
+  const found = [];
+  for (const kw of keywords) {
+    const regex = new RegExp(`\\b${kw}\\b`, "gi");
+    const matches = content.match(regex);
+    if (matches && matches.length > 0) {
+      found.push(`${kw}: ${matches.length}\uAC1C`);
+    }
+  }
+  let score = 0;
+  if (found.length > 0) {
+    score = Math.min(maxScore, found.length * 2);
+    details.push(`\uBC1C\uACAC\uB41C \uD0A4\uC6CC\uB4DC: ${found.join(", ")}`);
+  } else {
+    details.push("RFC 2119 \uD0A4\uC6CC\uB4DC\uAC00 \uBC1C\uACAC\uB418\uC9C0 \uC54A\uC74C");
+    suggestions.push("\uC694\uAD6C\uC0AC\uD56D\uC5D0 SHALL, MUST, SHOULD, MAY \uD0A4\uC6CC\uB4DC\uB97C \uC0AC\uC6A9\uD558\uC138\uC694");
+  }
+  return {
+    name: "RFC 2119 \uD0A4\uC6CC\uB4DC",
+    score,
+    maxScore,
+    percentage: score / maxScore * 100,
+    details,
+    suggestions
+  };
+}
+function scoreScenarios(content) {
+  const maxScore = 20;
+  const details = [];
+  const suggestions = [];
+  const givenCount = (content.match(/\*\*GIVEN\*\*|\bGIVEN\b/gi) || []).length;
+  const whenCount = (content.match(/\*\*WHEN\*\*|\bWHEN\b/gi) || []).length;
+  const thenCount = (content.match(/\*\*THEN\*\*|\bTHEN\b/gi) || []).length;
+  const scenarioCount = Math.min(givenCount, whenCount, thenCount);
+  let score = 0;
+  if (scenarioCount > 0) {
+    score = Math.min(maxScore, scenarioCount * 5);
+    details.push(`\uC644\uC804\uD55C \uC2DC\uB098\uB9AC\uC624: ${scenarioCount}\uAC1C`);
+    details.push(`GIVEN: ${givenCount}, WHEN: ${whenCount}, THEN: ${thenCount}`);
+  } else {
+    details.push("GIVEN-WHEN-THEN \uC2DC\uB098\uB9AC\uC624\uAC00 \uC5C6\uC74C");
+    suggestions.push("\uCD5C\uC18C 2\uAC1C \uC774\uC0C1\uC758 GIVEN-WHEN-THEN \uC2DC\uB098\uB9AC\uC624\uB97C \uC791\uC131\uD558\uC138\uC694");
+  }
+  if (scenarioCount < 2 && scenarioCount > 0) {
+    suggestions.push("\uCD94\uAC00 \uC2DC\uB098\uB9AC\uC624 \uC791\uC131\uC744 \uAD8C\uC7A5\uD569\uB2C8\uB2E4 (\uCD5C\uC18C 2\uAC1C)");
+  }
+  return {
+    name: "GIVEN-WHEN-THEN \uC2DC\uB098\uB9AC\uC624",
+    score,
+    maxScore,
+    percentage: score / maxScore * 100,
+    details,
+    suggestions
+  };
+}
+function scoreRequirements(content) {
+  const maxScore = 15;
+  const details = [];
+  const suggestions = [];
+  const reqIdPattern = /REQ-\d+|REQ-[A-Z]+-\d+/gi;
+  const reqIds = content.match(reqIdPattern) || [];
+  const hasRequirementsSection = /^##\s*(요구사항|Requirements)/im.test(content);
+  let score = 0;
+  if (hasRequirementsSection) {
+    score += 5;
+    details.push("\uC694\uAD6C\uC0AC\uD56D \uC139\uC158\uC774 \uC874\uC7AC\uD568");
+  } else {
+    suggestions.push("## \uC694\uAD6C\uC0AC\uD56D \uC139\uC158\uC744 \uCD94\uAC00\uD558\uC138\uC694");
+  }
+  if (reqIds.length > 0) {
+    score += Math.min(10, reqIds.length * 2);
+    details.push(`\uC694\uAD6C\uC0AC\uD56D ID: ${reqIds.length}\uAC1C (${[...new Set(reqIds)].slice(0, 3).join(", ")}...)`);
+  } else {
+    suggestions.push("\uC694\uAD6C\uC0AC\uD56D\uC5D0 REQ-01 \uD615\uC2DD\uC758 ID\uB97C \uBD80\uC5EC\uD558\uC138\uC694");
+  }
+  return {
+    name: "\uC694\uAD6C\uC0AC\uD56D \uBA85\uD655\uC131",
+    score,
+    maxScore,
+    percentage: score / maxScore * 100,
+    details,
+    suggestions
+  };
+}
+function scoreDependencies(spec) {
+  const maxScore = 10;
+  const details = [];
+  const suggestions = [];
+  let score = 0;
+  if (spec.frontmatter.depends) {
+    const deps = Array.isArray(spec.frontmatter.depends) ? spec.frontmatter.depends : [spec.frontmatter.depends];
+    if (deps.length > 0 && deps[0] !== null) {
+      score = maxScore;
+      details.push(`\uC758\uC874\uC131: ${deps.join(", ")}`);
+    } else {
+      score = 5;
+      details.push("\uC758\uC874\uC131 \uC5C6\uC74C (\uBA85\uC2DC\uC801 \uC120\uC5B8)");
+    }
+  } else {
+    details.push("\uC758\uC874\uC131 \uD544\uB4DC\uAC00 \uC5C6\uC74C");
+    suggestions.push("frontmatter\uC5D0 depends \uD544\uB4DC\uB97C \uCD94\uAC00\uD558\uC138\uC694");
+  }
+  return {
+    name: "\uC758\uC874\uC131 \uBA85\uC2DC",
+    score,
+    maxScore,
+    percentage: score / maxScore * 100,
+    details,
+    suggestions
+  };
+}
+function scoreStructure(content) {
+  const maxScore = 15;
+  const details = [];
+  const suggestions = [];
+  const requiredSections = [
+    { pattern: /^#\s+.+/m, name: "\uC81C\uBAA9 (H1)" },
+    { pattern: /^##\s*(요구사항|Requirements)/im, name: "\uC694\uAD6C\uC0AC\uD56D \uC139\uC158" },
+    { pattern: /^##\s*(시나리오|Scenario)/im, name: "\uC2DC\uB098\uB9AC\uC624 \uC139\uC158" }
+  ];
+  const optionalSections = [
+    { pattern: /^##\s*(개요|Overview|설명|Description)/im, name: "\uAC1C\uC694/\uC124\uBA85 \uC139\uC158" },
+    { pattern: /^##\s*(제약|Constraints|제한)/im, name: "\uC81C\uC57D\uC0AC\uD56D \uC139\uC158" },
+    { pattern: /^##\s*(비고|Notes|참고)/im, name: "\uBE44\uACE0 \uC139\uC158" }
+  ];
+  let score = 0;
+  const foundRequired = [];
+  const missingRequired = [];
+  for (const section of requiredSections) {
+    if (section.pattern.test(content)) {
+      foundRequired.push(section.name);
+      score += 4;
+    } else {
+      missingRequired.push(section.name);
+    }
+  }
+  for (const section of optionalSections) {
+    if (section.pattern.test(content)) {
+      score += 1;
+    }
+  }
+  score = Math.min(maxScore, score);
+  if (foundRequired.length > 0) {
+    details.push(`\uD544\uC218 \uC139\uC158: ${foundRequired.join(", ")}`);
+  }
+  if (missingRequired.length > 0) {
+    suggestions.push(`\uB204\uB77D\uB41C \uC139\uC158: ${missingRequired.join(", ")}`);
+  }
+  return {
+    name: "\uBB38\uC11C \uAD6C\uC870",
+    score,
+    maxScore,
+    percentage: score / maxScore * 100,
+    details,
+    suggestions
+  };
+}
+function scoreConstitution(spec, hasConstitution) {
+  const maxScore = 10;
+  const details = [];
+  const suggestions = [];
+  let score = 0;
+  if (!hasConstitution) {
+    score = maxScore;
+    details.push("Constitution \uBBF8\uC124\uC815 (\uAC80\uC0AC \uC0DD\uB7B5)");
+  } else if (spec.frontmatter.constitution_version) {
+    score = maxScore;
+    details.push(`Constitution \uBC84\uC804: ${spec.frontmatter.constitution_version}`);
+  } else {
+    details.push("constitution_version \uD544\uB4DC \uC5C6\uC74C");
+    suggestions.push("frontmatter\uC5D0 constitution_version\uC744 \uCD94\uAC00\uD558\uC138\uC694");
+  }
+  return {
+    name: "Constitution \uC900\uC218",
+    score,
+    maxScore,
+    percentage: score / maxScore * 100,
+    details,
+    suggestions
+  };
+}
+function scoreLinks(content) {
+  const maxScore = 10;
+  const details = [];
+  const suggestions = [];
+  const linkPattern = /\[([^\]]+)\]\(([^)]+)\)/g;
+  const links = [...content.matchAll(linkPattern)];
+  let score = 5;
+  if (links.length > 0) {
+    score = Math.min(maxScore, 5 + links.length);
+    details.push(`\uB9C1\uD06C: ${links.length}\uAC1C`);
+  } else {
+    details.push("\uB9C1\uD06C \uC5C6\uC74C");
+    suggestions.push("\uAD00\uB828 \uBB38\uC11C\uB098 \uC678\uBD80 \uCC38\uC870 \uB9C1\uD06C\uB97C \uCD94\uAC00\uD558\uBA74 \uC88B\uC2B5\uB2C8\uB2E4");
+  }
+  return {
+    name: "\uCC38\uC870 \uB9C1\uD06C",
+    score,
+    maxScore,
+    percentage: score / maxScore * 100,
+    details,
+    suggestions
+  };
+}
+function scoreMetadata(spec) {
+  const maxScore = 10;
+  const details = [];
+  const suggestions = [];
+  const requiredFields = ["id", "title", "status"];
+  const optionalFields = ["created", "updated", "author", "version"];
+  let score = 0;
+  const missingRequired = [];
+  for (const field of requiredFields) {
+    if (spec.frontmatter[field]) {
+      score += 2;
+    } else {
+      missingRequired.push(field);
+    }
+  }
+  for (const field of optionalFields) {
+    if (spec.frontmatter[field]) {
+      score += 1;
+    }
+  }
+  score = Math.min(maxScore, score);
+  const presentFields = Object.keys(spec.frontmatter).filter(
+    (k) => spec.frontmatter[k] !== null && spec.frontmatter[k] !== void 0
+  );
+  details.push(`\uBA54\uD0C0\uB370\uC774\uD130 \uD544\uB4DC: ${presentFields.length}\uAC1C`);
+  if (missingRequired.length > 0) {
+    suggestions.push(`\uD544\uC218 \uD544\uB4DC \uB204\uB77D: ${missingRequired.join(", ")}`);
+  }
+  return {
+    name: "\uBA54\uD0C0\uB370\uC774\uD130 \uC644\uC131\uB3C4",
+    score,
+    maxScore,
+    percentage: score / maxScore * 100,
+    details,
+    suggestions
+  };
+}
+async function analyzeSpecQuality(specPath, sddPath) {
+  try {
+    if (!await fileExists(specPath)) {
+      return failure(new ChangeError(`\uC2A4\uD399 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${specPath}`));
+    }
+    const contentResult = await readFile(specPath);
+    if (!contentResult.success) {
+      return failure(new ChangeError("\uC2A4\uD399 \uD30C\uC77C\uC744 \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    }
+    const content = contentResult.data;
+    const parseResult = parseSpec(content);
+    if (!parseResult.success) {
+      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 hasConstitution = await fileExists(constitutionPath);
+    const items = [
+      scoreRfc2119(content),
+      scoreScenarios(content),
+      scoreRequirements(content),
+      scoreDependencies(spec),
+      scoreStructure(content),
+      scoreConstitution(spec, hasConstitution),
+      scoreLinks(content),
+      scoreMetadata(spec)
+    ];
+    const totalScore = items.reduce((sum, item) => sum + item.score, 0);
+    const maxScore = items.reduce((sum, item) => sum + item.maxScore, 0);
+    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.frontmatter.id || path23.basename(path23.dirname(specPath));
+    const summary = `\uC2A4\uD399 '${specId}'\uC758 \uD488\uC9C8 \uC810\uC218: ${totalScore}/${maxScore} (${percentage}%, \uB4F1\uAE09: ${grade})`;
+    return success({
+      specId,
+      specPath,
+      totalScore,
+      maxScore,
+      percentage,
+      grade,
+      items,
+      summary,
+      topSuggestions
+    });
+  } catch (error2) {
+    return failure(
+      new ChangeError(
+        `\uD488\uC9C8 \uBD84\uC11D \uC2E4\uD328: ${error2 instanceof Error ? error2.message : String(error2)}`
+      )
+    );
+  }
+}
+async function analyzeProjectQuality(sddPath) {
+  try {
+    const specsPath = path23.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."));
+    }
+    const specFiles = [];
+    await findSpecFiles2(specsPath, specFiles);
+    if (specFiles.length === 0) {
+      return failure(new ChangeError("\uC2A4\uD399 \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    }
+    const specResults = [];
+    for (const specFile of specFiles) {
+      const result = await analyzeSpecQuality(specFile, sddPath);
+      if (result.success) {
+        specResults.push(result.data);
+      }
+    }
+    if (specResults.length === 0) {
+      return failure(new ChangeError("\uBD84\uC11D \uAC00\uB2A5\uD55C \uC2A4\uD399\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    }
+    const totalPercentage = specResults.reduce((sum, r) => sum + r.percentage, 0);
+    const averagePercentage = Math.round(totalPercentage / specResults.length);
+    const averageScore = Math.round(
+      specResults.reduce((sum, r) => sum + r.totalScore, 0) / specResults.length
+    );
+    const grade = getGrade(averagePercentage);
+    const summary = `\uD504\uB85C\uC81D\uD2B8 \uD488\uC9C8: \uD3C9\uADE0 ${averagePercentage}% (\uB4F1\uAE09: ${grade}), ${specResults.length}\uAC1C \uC2A4\uD399 \uBD84\uC11D`;
+    return success({
+      averageScore,
+      averagePercentage,
+      grade,
+      totalSpecs: specResults.length,
+      specResults,
+      summary
+    });
+  } catch (error2) {
+    return failure(
+      new ChangeError(
+        `\uD504\uB85C\uC81D\uD2B8 \uD488\uC9C8 \uBD84\uC11D \uC2E4\uD328: ${error2 instanceof Error ? error2.message : String(error2)}`
+      )
+    );
+  }
+}
+async function findSpecFiles2(dir, files) {
+  const entries = await fs13.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path23.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await findSpecFiles2(fullPath, files);
+    } else if (entry.name === "spec.md") {
+      files.push(fullPath);
+    }
+  }
+}
+function formatQualityResult(result) {
+  const lines = [];
+  const gradeIcon = result.grade === "A" ? "\u{1F3C6}" : result.grade === "B" ? "\u2705" : result.grade === "C" ? "\u{1F7E1}" : result.grade === "D" ? "\u{1F7E0}" : "\u{1F534}";
+  lines.push(`\u{1F4CA} \uD488\uC9C8 \uBD84\uC11D: ${result.specId}`);
+  lines.push(`   ${gradeIcon} \uB4F1\uAE09: ${result.grade} (${result.percentage}%)`);
+  lines.push(`   \u{1F4C8} \uC810\uC218: ${result.totalScore}/${result.maxScore}`);
+  lines.push("");
+  lines.push("\u{1F4CB} \uD56D\uBAA9\uBCC4 \uC810\uC218:");
+  for (const item of result.items) {
+    const icon = item.percentage >= 80 ? "\u2705" : item.percentage >= 60 ? "\u{1F7E1}" : "\u{1F534}";
+    lines.push(`   ${icon} ${item.name}: ${item.score}/${item.maxScore} (${Math.round(item.percentage)}%)`);
+    for (const detail of item.details) {
+      lines.push(`      \u2514\u2500 ${detail}`);
+    }
+  }
+  lines.push("");
+  if (result.topSuggestions.length > 0) {
+    lines.push("\u{1F4A1} \uAC1C\uC120 \uC81C\uC548:");
+    for (const suggestion of result.topSuggestions) {
+      lines.push(`   - ${suggestion}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatProjectQualityResult(result) {
+  const lines = [];
+  const gradeIcon = result.grade === "A" ? "\u{1F3C6}" : result.grade === "B" ? "\u2705" : result.grade === "C" ? "\u{1F7E1}" : result.grade === "D" ? "\u{1F7E0}" : "\u{1F534}";
+  lines.push("\u{1F4CA} \uD504\uB85C\uC81D\uD2B8 \uD488\uC9C8 \uBD84\uC11D");
+  lines.push(`   ${gradeIcon} \uD3C9\uADE0 \uB4F1\uAE09: ${result.grade} (${result.averagePercentage}%)`);
+  lines.push(`   \u{1F4C8} \uBD84\uC11D\uB41C \uC2A4\uD399: ${result.totalSpecs}\uAC1C`);
+  lines.push("");
+  const gradeCount = { A: 0, B: 0, C: 0, D: 0, F: 0 };
+  for (const spec of result.specResults) {
+    gradeCount[spec.grade]++;
+  }
+  lines.push("\u{1F4C8} \uB4F1\uAE09 \uBD84\uD3EC:");
+  if (gradeCount.A > 0) lines.push(`   \u{1F3C6} A: ${gradeCount.A}\uAC1C`);
+  if (gradeCount.B > 0) lines.push(`   \u2705 B: ${gradeCount.B}\uAC1C`);
+  if (gradeCount.C > 0) lines.push(`   \u{1F7E1} C: ${gradeCount.C}\uAC1C`);
+  if (gradeCount.D > 0) lines.push(`   \u{1F7E0} D: ${gradeCount.D}\uAC1C`);
+  if (gradeCount.F > 0) lines.push(`   \u{1F534} F: ${gradeCount.F}\uAC1C`);
+  lines.push("");
+  lines.push("\u{1F4CB} \uC2A4\uD399\uBCC4 \uC810\uC218:");
+  const sortedSpecs = [...result.specResults].sort((a, b) => b.percentage - a.percentage);
+  for (const spec of sortedSpecs) {
+    const icon = spec.grade === "A" ? "\u{1F3C6}" : spec.grade === "B" ? "\u2705" : spec.grade === "C" ? "\u{1F7E1}" : spec.grade === "D" ? "\u{1F7E0}" : "\u{1F534}";
+    lines.push(`   ${icon} ${spec.specId}: ${spec.percentage}% (${spec.grade})`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/quality.ts
+init_fs();
+init_errors();
+function registerQualityCommand(program2) {
+  program2.command("quality [feature]").description("\uC2A4\uD399 \uD488\uC9C8\uC744 \uBD84\uC11D\uD558\uACE0 \uC810\uC218\uB97C \uC0B0\uCD9C\uD569\uB2C8\uB2E4").option("-a, --all", "\uC804\uCCB4 \uD504\uB85C\uC81D\uD2B8 \uBD84\uC11D").option("--json", "JSON \uD615\uC2DD \uCD9C\uB825").option("--min-score <score>", "\uCD5C\uC18C \uC810\uC218 \uAE30\uC900 (\uC774\uD558 \uC2DC \uC5D0\uB7EC)", "0").action(async (feature, options) => {
+    try {
+      await runQuality(feature, options);
+    } catch (error2) {
+      error(error2 instanceof Error ? error2.message : String(error2));
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+  });
+}
+async function runQuality(feature, options) {
+  const projectRoot = await findSddRoot();
+  if (!projectRoot) {
+    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 = path24.join(projectRoot, ".sdd");
+  const minScore = parseInt(options.minScore || "0", 10);
+  if (options.all || !feature) {
+    const result2 = await analyzeProjectQuality(sddPath);
+    if (!result2.success) {
+      error(result2.error.message);
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result2.data, null, 2));
+    } else {
+      console.log(formatProjectQualityResult(result2.data));
+    }
+    if (result2.data.averagePercentage < minScore) {
+      newline();
+      error(`\uD488\uC9C8 \uC810\uC218\uAC00 \uCD5C\uC18C \uAE30\uC900(${minScore}%) \uBBF8\uB2EC\uC785\uB2C8\uB2E4.`);
+      process.exit(ExitCode.VALIDATION_ERROR);
+    }
+    return;
+  }
+  const specPath = path24.join(sddPath, "specs", feature, "spec.md");
+  const result = await analyzeSpecQuality(specPath, sddPath);
+  if (!result.success) {
+    error(result.error.message);
+    process.exit(ExitCode.GENERAL_ERROR);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(result.data, null, 2));
+  } else {
+    console.log(formatQualityResult(result.data));
+  }
+  if (result.data.percentage < minScore) {
+    newline();
+    error(`\uD488\uC9C8 \uC810\uC218\uAC00 \uCD5C\uC18C \uAE30\uC900(${minScore}%) \uBBF8\uB2EC\uC785\uB2C8\uB2E4.`);
+    process.exit(ExitCode.VALIDATION_ERROR);
+  }
+}
+
+// src/cli/commands/report.ts
+import path26 from "path";
+
+// src/core/report/reporter.ts
+init_types();
+init_errors();
+import path25 from "path";
+import fs14 from "fs/promises";
+init_fs();
+async function loadSpecList(specsPath) {
+  try {
+    if (!await fileExists(specsPath)) {
+      return failure(new ChangeError("\uC2A4\uD399 \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    }
+    const result = await readDir(specsPath);
+    if (!result.success) {
+      return failure(new ChangeError("\uC2A4\uD399 \uB514\uB809\uD1A0\uB9AC\uB97C \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    }
+    const specs = [];
+    for (const entry of result.data) {
+      const featurePath = path25.join(specsPath, entry);
+      const stat = await fs14.stat(featurePath);
+      if (stat.isDirectory()) {
+        const specFile = path25.join(featurePath, "spec.md");
+        if (await fileExists(specFile)) {
+          const content = await fs14.readFile(specFile, "utf-8");
+          const metadata = parseSpecMetadata2(content);
+          specs.push({
+            id: entry,
+            title: metadata?.title,
+            phase: metadata?.phase,
+            status: metadata?.status,
+            description: metadata?.description
+          });
+        }
+      }
+    }
+    return success(specs);
+  } catch (error2) {
+    return failure(new ChangeError(error2 instanceof Error ? error2.message : String(error2)));
+  }
+}
+function parseSpecMetadata2(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) return null;
+  const frontmatter = frontmatterMatch[1];
+  const result = {};
+  const lines = frontmatter.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^(\w+):\s*['"]?([^'"]+)['"]?$/);
+    if (match) {
+      result[match[1]] = match[2].trim();
+    }
+  }
+  return {
+    title: result.title,
+    phase: result.phase,
+    status: result.status,
+    description: result.description
+  };
+}
+async function generateReport(sddPath, options) {
+  try {
+    const specsPath = path25.join(sddPath, "specs");
+    const specsResult = await loadSpecList(specsPath);
+    if (!specsResult.success) {
+      return failure(specsResult.error);
+    }
+    const specs = specsResult.data;
+    const reportData = {
+      title: options.title || "SDD \uD504\uB85C\uC81D\uD2B8 \uB9AC\uD3EC\uD2B8",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectPath: sddPath,
+      specs,
+      summary: {
+        totalSpecs: specs.length,
+        byPhase: {},
+        byStatus: {}
+      }
+    };
+    for (const spec of specs) {
+      const phase = spec.phase || "unknown";
+      reportData.summary.byPhase[phase] = (reportData.summary.byPhase[phase] || 0) + 1;
+      const status = spec.status || "unknown";
+      reportData.summary.byStatus[status] = (reportData.summary.byStatus[status] || 0) + 1;
+    }
+    if (options.includeQuality !== false) {
+      const qualityResult = await analyzeProjectQuality(sddPath);
+      if (qualityResult.success) {
+        reportData.quality = qualityResult.data;
+        reportData.summary.averageQuality = qualityResult.data.averagePercentage;
+      }
+    }
+    if (options.includeValidation !== false) {
+      const validationResult = await validateSpecs(sddPath, { strict: false });
+      if (validationResult.success) {
+        reportData.validation = validationResult.data;
+        reportData.summary.validationErrors = validationResult.data.errorCount;
+        reportData.summary.validationWarnings = validationResult.data.warningCount;
+      }
+    }
+    let content;
+    switch (options.format) {
+      case "html":
+        content = renderHtmlReport(reportData);
+        break;
+      case "markdown":
+        content = renderMarkdownReport(reportData);
+        break;
+      case "json":
+        content = JSON.stringify(reportData, null, 2);
+        break;
+      default:
+        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");
+    }
+    return success({
+      format: options.format,
+      content,
+      outputPath: options.outputPath
+    });
+  } catch (error2) {
+    return failure(new ChangeError(error2 instanceof Error ? error2.message : String(error2)));
+  }
+}
+function renderHtmlReport(data) {
+  const gradeColor = (grade) => {
+    switch (grade) {
+      case "A":
+        return "#22c55e";
+      case "B":
+        return "#84cc16";
+      case "C":
+        return "#eab308";
+      case "D":
+        return "#f97316";
+      case "F":
+        return "#ef4444";
+      default:
+        return "#6b7280";
+    }
+  };
+  const statusBadge = (status) => {
+    const colors = {
+      draft: "#6b7280",
+      review: "#3b82f6",
+      approved: "#22c55e",
+      implemented: "#8b5cf6",
+      deprecated: "#ef4444"
+    };
+    const color = colors[status] || "#6b7280";
+    return `<span style="background:${color};color:white;padding:2px 8px;border-radius:4px;font-size:12px;">${status}</span>`;
+  };
+  const specRows = data.specs.map((spec) => `
+    <tr>
+      <td><strong>${spec.id}</strong></td>
+      <td>${spec.title || "-"}</td>
+      <td>${spec.phase || "-"}</td>
+      <td>${statusBadge(spec.status || "unknown")}</td>
+      <td>${spec.description || "-"}</td>
+    </tr>
+  `).join("");
+  const qualityRows = data.quality?.results.map((q) => `
+    <tr>
+      <td>${q.specId}</td>
+      <td>${q.percentage}%</td>
+      <td style="color:${gradeColor(q.grade)};font-weight:bold;">${q.grade}</td>
+      <td>${q.totalScore}/${q.maxScore}</td>
+    </tr>
+  `).join("") || "";
+  const validationRows = data.validation?.results.map((v) => `
+    <tr>
+      <td>${v.file}</td>
+      <td style="color:${v.errors.length > 0 ? "#ef4444" : "#22c55e"};">${v.errors.length > 0 ? "\u274C \uC2E4\uD328" : "\u2705 \uD1B5\uACFC"}</td>
+      <td>${v.errors.length}</td>
+      <td>${v.warnings.length}</td>
+    </tr>
+  `).join("") || "";
+  return `<!DOCTYPE html>
+<html lang="ko">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${data.title}</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #1f2937; background: #f9fafb; padding: 2rem; }
+    .container { max-width: 1200px; margin: 0 auto; }
+    h1 { font-size: 2rem; margin-bottom: 0.5rem; color: #111827; }
+    h2 { font-size: 1.5rem; margin: 2rem 0 1rem; color: #374151; border-bottom: 2px solid #e5e7eb; padding-bottom: 0.5rem; }
+    .meta { color: #6b7280; margin-bottom: 2rem; }
+    .summary { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
+    .card { background: white; border-radius: 8px; padding: 1.5rem; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
+    .card-title { font-size: 0.875rem; color: #6b7280; margin-bottom: 0.5rem; }
+    .card-value { font-size: 2rem; font-weight: bold; color: #111827; }
+    .card-value.success { color: #22c55e; }
+    .card-value.warning { color: #eab308; }
+    .card-value.error { color: #ef4444; }
+    table { width: 100%; border-collapse: collapse; background: white; border-radius: 8px; overflow: hidden; box-shadow: 0 1px 3px rgba(0,0,0,0.1); margin-bottom: 2rem; }
+    th, td { padding: 0.75rem 1rem; text-align: left; border-bottom: 1px solid #e5e7eb; }
+    th { background: #f3f4f6; font-weight: 600; color: #374151; }
+    tr:hover { background: #f9fafb; }
+    .phase-chart { display: flex; gap: 0.5rem; flex-wrap: wrap; }
+    .phase-item { background: #e0e7ff; color: #3730a3; padding: 0.25rem 0.75rem; border-radius: 9999px; font-size: 0.875rem; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>${data.title}</h1>
+    <p class="meta">\uC0DD\uC131: ${new Date(data.generatedAt).toLocaleString("ko-KR")} | \uACBD\uB85C: ${data.projectPath}</p>
+
+    <div class="summary">
+      <div class="card">
+        <div class="card-title">\uCD1D \uC2A4\uD399 \uC218</div>
+        <div class="card-value">${data.summary.totalSpecs}</div>
+      </div>
+      ${data.summary.averageQuality !== void 0 ? `
+      <div class="card">
+        <div class="card-title">\uD3C9\uADE0 \uD488\uC9C8</div>
+        <div class="card-value ${data.summary.averageQuality >= 80 ? "success" : data.summary.averageQuality >= 60 ? "warning" : "error"}">${data.summary.averageQuality.toFixed(1)}%</div>
+      </div>` : ""}
+      ${data.summary.validationErrors !== void 0 ? `
+      <div class="card">
+        <div class="card-title">\uAC80\uC99D \uC5D0\uB7EC</div>
+        <div class="card-value ${data.summary.validationErrors === 0 ? "success" : "error"}">${data.summary.validationErrors}</div>
+      </div>` : ""}
+      ${data.summary.validationWarnings !== void 0 ? `
+      <div class="card">
+        <div class="card-title">\uAC80\uC99D \uACBD\uACE0</div>
+        <div class="card-value ${data.summary.validationWarnings === 0 ? "success" : "warning"}">${data.summary.validationWarnings}</div>
+      </div>` : ""}
+    </div>
+
+    <h2>Phase\uBCC4 \uBD84\uD3EC</h2>
+    <div class="phase-chart">
+      ${Object.entries(data.summary.byPhase).map(([phase, count]) => `
+        <span class="phase-item">${phase}: ${count}</span>
+      `).join("")}
+    </div>
+
+    <h2>\uC2A4\uD399 \uBAA9\uB85D</h2>
+    <table>
+      <thead>
+        <tr>
+          <th>ID</th>
+          <th>\uC81C\uBAA9</th>
+          <th>Phase</th>
+          <th>\uC0C1\uD0DC</th>
+          <th>\uC124\uBA85</th>
+        </tr>
+      </thead>
+      <tbody>
+        ${specRows}
+      </tbody>
+    </table>
+
+    ${data.quality ? `
+    <h2>\uD488\uC9C8 \uBD84\uC11D</h2>
+    <table>
+      <thead>
+        <tr>
+          <th>\uC2A4\uD399 ID</th>
+          <th>\uC810\uC218</th>
+          <th>\uB4F1\uAE09</th>
+          <th>\uC0C1\uC138</th>
+        </tr>
+      </thead>
+      <tbody>
+        ${qualityRows}
+      </tbody>
+    </table>` : ""}
+
+    ${data.validation ? `
+    <h2>\uAC80\uC99D \uACB0\uACFC</h2>
+    <table>
+      <thead>
+        <tr>
+          <th>\uD30C\uC77C</th>
+          <th>\uC0C1\uD0DC</th>
+          <th>\uC5D0\uB7EC</th>
+          <th>\uACBD\uACE0</th>
+        </tr>
+      </thead>
+      <tbody>
+        ${validationRows}
+      </tbody>
+    </table>` : ""}
+
+    <footer style="margin-top:3rem;padding-top:1rem;border-top:1px solid #e5e7eb;color:#6b7280;font-size:0.875rem;">
+      Generated by SDD CLI v0.5.0
+    </footer>
+  </div>
+</body>
+</html>`;
+}
+function renderMarkdownReport(data) {
+  const lines = [];
+  lines.push(`# ${data.title}`);
+  lines.push("");
+  lines.push(`> \uC0DD\uC131: ${new Date(data.generatedAt).toLocaleString("ko-KR")}`);
+  lines.push(`> \uACBD\uB85C: ${data.projectPath}`);
+  lines.push("");
+  lines.push("## \uC694\uC57D");
+  lines.push("");
+  lines.push(`| \uD56D\uBAA9 | \uAC12 |`);
+  lines.push(`|------|-----|`);
+  lines.push(`| \uCD1D \uC2A4\uD399 \uC218 | ${data.summary.totalSpecs} |`);
+  if (data.summary.averageQuality !== void 0) {
+    lines.push(`| \uD3C9\uADE0 \uD488\uC9C8 | ${data.summary.averageQuality.toFixed(1)}% |`);
+  }
+  if (data.summary.validationErrors !== void 0) {
+    lines.push(`| \uAC80\uC99D \uC5D0\uB7EC | ${data.summary.validationErrors} |`);
+  }
+  if (data.summary.validationWarnings !== void 0) {
+    lines.push(`| \uAC80\uC99D \uACBD\uACE0 | ${data.summary.validationWarnings} |`);
+  }
+  lines.push("");
+  lines.push("## Phase\uBCC4 \uBD84\uD3EC");
+  lines.push("");
+  for (const [phase, count] of Object.entries(data.summary.byPhase)) {
+    lines.push(`- **${phase}**: ${count}\uAC1C`);
+  }
+  lines.push("");
+  lines.push("## \uC0C1\uD0DC\uBCC4 \uBD84\uD3EC");
+  lines.push("");
+  for (const [status, count] of Object.entries(data.summary.byStatus)) {
+    lines.push(`- **${status}**: ${count}\uAC1C`);
+  }
+  lines.push("");
+  lines.push("## \uC2A4\uD399 \uBAA9\uB85D");
+  lines.push("");
+  lines.push("| ID | \uC81C\uBAA9 | Phase | \uC0C1\uD0DC |");
+  lines.push("|----|------|-------|------|");
+  for (const spec of data.specs) {
+    lines.push(`| ${spec.id} | ${spec.title || "-"} | ${spec.phase || "-"} | ${spec.status || "-"} |`);
+  }
+  lines.push("");
+  if (data.quality) {
+    lines.push("## \uD488\uC9C8 \uBD84\uC11D");
+    lines.push("");
+    lines.push(`\uD3C9\uADE0 \uC810\uC218: **${data.quality.averagePercentage.toFixed(1)}%** (${data.quality.averageGrade})`);
+    lines.push("");
+    lines.push("| \uC2A4\uD399 ID | \uC810\uC218 | \uB4F1\uAE09 |");
+    lines.push("|---------|------|------|");
+    for (const q of data.quality.results) {
+      lines.push(`| ${q.specId} | ${q.percentage}% | ${q.grade} |`);
+    }
+    lines.push("");
+  }
+  if (data.validation) {
+    lines.push("## \uAC80\uC99D \uACB0\uACFC");
+    lines.push("");
+    lines.push(`- \uAC80\uC99D\uB41C \uC2A4\uD399: ${data.validation.validCount}\uAC1C`);
+    lines.push(`- \uC5D0\uB7EC: ${data.validation.errorCount}\uAC1C`);
+    lines.push(`- \uACBD\uACE0: ${data.validation.warningCount}\uAC1C`);
+    lines.push("");
+    if (data.validation.errorCount > 0 || data.validation.warningCount > 0) {
+      lines.push("### \uC0C1\uC138 \uACB0\uACFC");
+      lines.push("");
+      for (const v of data.validation.results) {
+        if (v.errors.length > 0 || v.warnings.length > 0) {
+          lines.push(`#### ${v.file}`);
+          for (const e of v.errors) {
+            lines.push(`- ${e}`);
+          }
+          for (const w of v.warnings) {
+            lines.push(`- ${w}`);
+          }
+          lines.push("");
+        }
+      }
+    }
+  }
+  lines.push("---");
+  lines.push("*Generated by SDD CLI v0.5.0*");
+  return lines.join("\n");
+}
+
+// src/cli/commands/report.ts
+init_fs();
+init_errors();
+function registerReportCommand(program2) {
+  program2.command("report").description("\uC2A4\uD399 \uB9AC\uD3EC\uD2B8\uB97C \uC0DD\uC131\uD569\uB2C8\uB2E4").option("-f, --format <format>", "\uCD9C\uB825 \uD615\uC2DD (html, markdown, json)", "html").option("-o, --output <path>", "\uCD9C\uB825 \uD30C\uC77C \uACBD\uB85C").option("--title <title>", "\uB9AC\uD3EC\uD2B8 \uC81C\uBAA9").option("--no-quality", "\uD488\uC9C8 \uBD84\uC11D \uC81C\uC678").option("--no-validation", "\uAC80\uC99D \uACB0\uACFC \uC81C\uC678").action(async (options) => {
+    try {
+      await runReport(options);
+    } catch (error2) {
+      error(error2 instanceof Error ? error2.message : String(error2));
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+  });
+}
+async function runReport(options) {
+  const projectRoot = await findSddRoot();
+  if (!projectRoot) {
+    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 = path26.join(projectRoot, ".sdd");
+  const format = options.format || "html";
+  if (!["html", "markdown", "json"].includes(format)) {
+    error(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD615\uC2DD\uC785\uB2C8\uB2E4: ${format}`);
+    info("\uC9C0\uC6D0 \uD615\uC2DD: html, markdown, json");
+    process.exit(ExitCode.VALIDATION_ERROR);
+  }
+  let outputPath = options.output;
+  if (!outputPath) {
+    const ext = format === "markdown" ? "md" : format;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    outputPath = path26.join(projectRoot, `sdd-report-${timestamp}.${ext}`);
+  } else if (!path26.isAbsolute(outputPath)) {
+    outputPath = path26.join(projectRoot, outputPath);
+  }
+  info("\u{1F4CA} \uB9AC\uD3EC\uD2B8 \uC0DD\uC131 \uC911...");
+  info(`   \uD615\uC2DD: ${format}`);
+  info(`   \uD488\uC9C8 \uBD84\uC11D: ${options.quality !== false ? "\uD3EC\uD568" : "\uC81C\uC678"}`);
+  info(`   \uAC80\uC99D \uACB0\uACFC: ${options.validation !== false ? "\uD3EC\uD568" : "\uC81C\uC678"}`);
+  newline();
+  const result = await generateReport(sddPath, {
+    format,
+    outputPath,
+    title: options.title,
+    includeQuality: options.quality !== false,
+    includeValidation: options.validation !== false
+  });
+  if (!result.success) {
+    error(result.error.message);
+    process.exit(ExitCode.GENERAL_ERROR);
+  }
+  success2(`\u2705 \uB9AC\uD3EC\uD2B8\uAC00 \uC0DD\uC131\uB418\uC5C8\uC2B5\uB2C8\uB2E4.`);
+  info(`   \uACBD\uB85C: ${result.data.outputPath}`);
+  if (!options.output && format === "json") {
+    newline();
+    console.log(result.data.content);
+  }
+}
+
 // src/cli/index.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../../package.json");
@@ -9104,6 +10790,9 @@ registerStartCommand(program);
 registerMigrateCommand(program);
 registerCicdCommand(program);
 registerTransitionCommand(program);
+registerWatchCommand(program);
+registerQualityCommand(program);
+registerReportCommand(program);
 function run() {
   program.parse();
 }