qfai 0.9.0 → 0.9.2

package/dist/cli/index.cjs

@@ -23,17 +23,190 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/cli/commands/analyze.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/core/fs.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".pnpm",
+  "tmp",
+  ".mcp-tools"
+]);
+async function collectFiles(root, options = {}) {
+  const entries = [];
+  if (!await exists(root)) {
+    return entries;
+  }
+  const ignoreDirs = /* @__PURE__ */ new Set([
+    ...DEFAULT_IGNORE_DIRS,
+    ...options.ignoreDirs ?? []
+  ]);
+  const extensions = options.extensions?.map((ext) => ext.toLowerCase()) ?? [];
+  await walk(root, root, ignoreDirs, extensions, entries);
+  return entries;
+}
+async function collectFilesByGlobs(root, options) {
+  if (options.globs.length === 0) {
+    return [];
+  }
+  return (0, import_fast_glob.default)(options.globs, {
+    cwd: root,
+    ignore: options.ignore ?? [],
+    onlyFiles: true,
+    absolute: true,
+    unique: true
+  });
+}
+async function walk(base, current, ignoreDirs, extensions, out) {
+  const items = await (0, import_promises.readdir)(current, { withFileTypes: true });
+  for (const item of items) {
+    const fullPath = import_node_path.default.join(current, item.name);
+    if (item.isDirectory()) {
+      if (ignoreDirs.has(item.name)) {
+        continue;
+      }
+      await walk(base, fullPath, ignoreDirs, extensions, out);
+      continue;
+    }
+    if (item.isFile()) {
+      if (extensions.length > 0) {
+        const ext = import_node_path.default.extname(item.name).toLowerCase();
+        if (!extensions.includes(ext)) {
+          continue;
+        }
+      }
+      out.push(fullPath);
+    }
+  }
+}
+async function exists(target) {
+  try {
+    await (0, import_promises.access)(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/commands/analyze.ts
+async function runAnalyze(options) {
+  const root = import_node_path2.default.resolve(options.root);
+  const localDir = import_node_path2.default.join(root, ".qfai", "prompts.local", "analyze");
+  const standardDir = import_node_path2.default.join(root, ".qfai", "prompts", "analyze");
+  const available = await listPromptNames([localDir, standardDir]);
+  const promptName = normalizePromptName(options.prompt);
+  if (!promptName || options.list) {
+    emitList(available);
+    return 0;
+  }
+  const resolved = await resolvePromptPath(promptName, [localDir, standardDir]);
+  if (!resolved) {
+    emitPromptNotFound(promptName, available);
+    return 1;
+  }
+  const content = await (0, import_promises2.readFile)(resolved, "utf-8");
+  process.stdout.write(content);
+  if (!content.endsWith("\n")) {
+    process.stdout.write("\n");
+  }
+  return 0;
+}
+function normalizePromptName(value) {
+  const trimmed = (value ?? "").trim();
+  if (!trimmed) {
+    return null;
+  }
+  return trimmed.endsWith(".md") ? trimmed.slice(0, -3) : trimmed;
+}
+async function listPromptNames(dirs) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs) {
+    const files = await collectFiles(dir, { extensions: [".md"] });
+    for (const abs of files) {
+      const base = import_node_path2.default.basename(abs);
+      if (base.toLowerCase() === "readme.md") {
+        continue;
+      }
+      const name = base.slice(0, -3);
+      if (byName.has(name)) {
+        continue;
+      }
+      if (await isDeprecatedPrompt(abs)) {
+        continue;
+      }
+      byName.set(name, abs);
+    }
+  }
+  return [...byName.keys()].sort((a, b) => a.localeCompare(b));
+}
+function emitList(names) {
+  process.stdout.write("# qfai analyze: prompts\n\n");
+  if (names.length === 0) {
+    process.stdout.write(
+      "\u5229\u7528\u53EF\u80FD\u306A\u30D7\u30ED\u30F3\u30D7\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002\u307E\u305A `qfai init` \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002\n"
+    );
+    return;
+  }
+  process.stdout.write("\u5229\u7528\u53EF\u80FD\u306A\u30D7\u30ED\u30F3\u30D7\u30C8\u4E00\u89A7:\n\n");
+  for (const name of names) {
+    process.stdout.write(`- ${name}
+`);
+  }
+}
+async function resolvePromptPath(promptName, dirs) {
+  const filename = `${promptName}.md`;
+  for (const dir of dirs) {
+    const full = import_node_path2.default.join(dir, filename);
+    try {
+      await (0, import_promises2.readFile)(full, "utf-8");
+      return full;
+    } catch {
+    }
+  }
+  return null;
+}
+async function isDeprecatedPrompt(filePath) {
+  try {
+    const content = await (0, import_promises2.readFile)(filePath, "utf-8");
+    const firstLine = firstLineOf(content);
+    return firstLine.trim() === "# Deprecated";
+  } catch {
+    return false;
+  }
+}
+function firstLineOf(content) {
+  return content.match(/^[^\r\n]*/)?.[0] ?? "";
+}
+function emitPromptNotFound(promptName, candidates) {
+  process.stderr.write(`qfai analyze: prompt not found: ${promptName}
+`);
+  if (candidates.length > 0) {
+    process.stderr.write("candidates:\n");
+    for (const c of candidates) {
+      process.stderr.write(`- ${c}
+`);
+    }
+  }
+}
+
 // src/cli/commands/doctor.ts
-var import_promises9 = require("fs/promises");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_promises10 = require("fs/promises");
+var import_node_path11 = __toESM(require("path"), 1);
 
 // src/core/doctor.ts
-var import_promises8 = require("fs/promises");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_promises9 = require("fs/promises");
+var import_node_path10 = __toESM(require("path"), 1);
 
 // src/core/config.ts
-var import_promises = require("fs/promises");
-var import_node_path = __toESM(require("path"), 1);
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
 var import_yaml = require("yaml");
 var defaultConfig = {
   paths: {
@@ -73,17 +246,17 @@ var defaultConfig = {
   }
 };
 function getConfigPath(root) {
-  return import_node_path.default.join(root, "qfai.config.yaml");
+  return import_node_path3.default.join(root, "qfai.config.yaml");
 }
 async function findConfigRoot(startDir) {
-  const resolvedStart = import_node_path.default.resolve(startDir);
+  const resolvedStart = import_node_path3.default.resolve(startDir);
   let current = resolvedStart;
   while (true) {
     const configPath = getConfigPath(current);
-    if (await exists(configPath)) {
+    if (await exists2(configPath)) {
       return { root: current, configPath, found: true };
     }
-    const parent = import_node_path.default.dirname(current);
+    const parent = import_node_path3.default.dirname(current);
     if (parent === current) {
       break;
     }
@@ -100,7 +273,7 @@ async function loadConfig(root) {
   const issues = [];
   let parsed;
   try {
-    const raw = await (0, import_promises.readFile)(configPath, "utf-8");
+    const raw = await (0, import_promises3.readFile)(configPath, "utf-8");
     parsed = (0, import_yaml.parse)(raw);
   } catch (error2) {
     if (isMissingFile(error2)) {
@@ -113,7 +286,7 @@ async function loadConfig(root) {
   return { config: normalized, issues, configPath };
 }
 function resolvePath(root, config, key) {
-  return import_node_path.default.resolve(root, config.paths[key]);
+  return import_node_path3.default.resolve(root, config.paths[key]);
 }
 function normalizeConfig(raw, configPath, issues) {
   if (!isRecord(raw)) {
@@ -413,9 +586,9 @@ function isMissingFile(error2) {
   }
   return false;
 }
-async function exists(target) {
+async function exists2(target) {
   try {
-    await (0, import_promises.access)(target);
+    await (0, import_promises3.access)(target);
     return true;
   } catch {
     return false;
@@ -432,94 +605,26 @@ function isRecord(value) {
 }
 
 // src/core/discovery.ts
-var import_promises4 = require("fs/promises");
-
-// src/core/fs.ts
-var import_promises2 = require("fs/promises");
-var import_node_path2 = __toESM(require("path"), 1);
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  ".pnpm",
-  "tmp",
-  ".mcp-tools"
-]);
-async function collectFiles(root, options = {}) {
-  const entries = [];
-  if (!await exists2(root)) {
-    return entries;
-  }
-  const ignoreDirs = /* @__PURE__ */ new Set([
-    ...DEFAULT_IGNORE_DIRS,
-    ...options.ignoreDirs ?? []
-  ]);
-  const extensions = options.extensions?.map((ext) => ext.toLowerCase()) ?? [];
-  await walk(root, root, ignoreDirs, extensions, entries);
-  return entries;
-}
-async function collectFilesByGlobs(root, options) {
-  if (options.globs.length === 0) {
-    return [];
-  }
-  return (0, import_fast_glob.default)(options.globs, {
-    cwd: root,
-    ignore: options.ignore ?? [],
-    onlyFiles: true,
-    absolute: true,
-    unique: true
-  });
-}
-async function walk(base, current, ignoreDirs, extensions, out) {
-  const items = await (0, import_promises2.readdir)(current, { withFileTypes: true });
-  for (const item of items) {
-    const fullPath = import_node_path2.default.join(current, item.name);
-    if (item.isDirectory()) {
-      if (ignoreDirs.has(item.name)) {
-        continue;
-      }
-      await walk(base, fullPath, ignoreDirs, extensions, out);
-      continue;
-    }
-    if (item.isFile()) {
-      if (extensions.length > 0) {
-        const ext = import_node_path2.default.extname(item.name).toLowerCase();
-        if (!extensions.includes(ext)) {
-          continue;
-        }
-      }
-      out.push(fullPath);
-    }
-  }
-}
-async function exists2(target) {
-  try {
-    await (0, import_promises2.access)(target);
-    return true;
-  } catch {
-    return false;
-  }
-}
+var import_promises5 = require("fs/promises");
 
 // src/core/specLayout.ts
-var import_promises3 = require("fs/promises");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_promises4 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"), 1);
 var SPEC_DIR_RE = /^spec-\d{4}$/;
 async function collectSpecEntries(specsRoot) {
   const dirs = await listSpecDirs(specsRoot);
   const entries = dirs.map((dir) => ({
     dir,
-    specPath: import_node_path3.default.join(dir, "spec.md"),
-    deltaPath: import_node_path3.default.join(dir, "delta.md"),
-    scenarioPath: import_node_path3.default.join(dir, "scenario.md")
+    specPath: import_node_path4.default.join(dir, "spec.md"),
+    deltaPath: import_node_path4.default.join(dir, "delta.md"),
+    scenarioPath: import_node_path4.default.join(dir, "scenario.md")
   }));
   return entries.sort((a, b) => a.dir.localeCompare(b.dir));
 }
 async function listSpecDirs(specsRoot) {
   try {
-    const items = await (0, import_promises3.readdir)(specsRoot, { withFileTypes: true });
-    return items.filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => SPEC_DIR_RE.test(name.toLowerCase())).map((name) => import_node_path3.default.join(specsRoot, name));
+    const items = await (0, import_promises4.readdir)(specsRoot, { withFileTypes: true });
+    return items.filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => SPEC_DIR_RE.test(name.toLowerCase())).map((name) => import_node_path4.default.join(specsRoot, name));
   } catch (error2) {
     if (isMissingFileError(error2)) {
       return [];
@@ -575,7 +680,7 @@ async function filterExisting(files) {
 }
 async function exists3(target) {
   try {
-    await (0, import_promises4.access)(target);
+    await (0, import_promises5.access)(target);
     return true;
   } catch {
     return false;
@@ -583,15 +688,15 @@ async function exists3(target) {
 }
 
 // src/core/paths.ts
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 function toRelativePath(root, target) {
   if (!target) {
     return target;
   }
-  if (!import_node_path4.default.isAbsolute(target)) {
+  if (!import_node_path5.default.isAbsolute(target)) {
     return toPosixPath(target);
   }
-  const relative = import_node_path4.default.relative(root, target);
+  const relative = import_node_path5.default.relative(root, target);
   if (!relative) {
     return ".";
   }
@@ -602,8 +707,8 @@ function toPosixPath(value) {
 }
 
 // src/core/traceability.ts
-var import_promises5 = require("fs/promises");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_promises6 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"), 1);
 
 // src/core/gherkin/parse.ts
 var import_gherkin = require("@cucumber/gherkin");
@@ -755,7 +860,7 @@ function extractAnnotatedScIds(text) {
 async function collectScIdsFromScenarioFiles(scenarioFiles) {
   const scIds = /* @__PURE__ */ new Set();
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises5.readFile)(file, "utf-8");
+    const text = await (0, import_promises6.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -773,7 +878,7 @@ async function collectScIdsFromScenarioFiles(scenarioFiles) {
 async function collectScIdSourcesFromScenarioFiles(scenarioFiles) {
   const sources = /* @__PURE__ */ new Map();
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises5.readFile)(file, "utf-8");
+    const text = await (0, import_promises6.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -826,10 +931,10 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
     };
   }
   const normalizedFiles = Array.from(
-    new Set(files.map((file) => import_node_path5.default.normalize(file)))
+    new Set(files.map((file) => import_node_path6.default.normalize(file)))
   );
   for (const file of normalizedFiles) {
-    const text = await (0, import_promises5.readFile)(file, "utf-8");
+    const text = await (0, import_promises6.readFile)(file, "utf-8");
     const scIds = extractAnnotatedScIds(text);
     if (scIds.length === 0) {
       continue;
@@ -886,20 +991,20 @@ function formatError3(error2) {
 }
 
 // src/core/promptsIntegrity.ts
-var import_promises6 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_promises7 = require("fs/promises");
+var import_node_path8 = __toESM(require("path"), 1);
 
 // src/shared/assets.ts
 var import_node_fs = require("fs");
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 function getInitAssetsDir() {
   const base = __filename;
   const basePath = base.startsWith("file:") ? (0, import_node_url.fileURLToPath)(base) : base;
-  const baseDir = import_node_path6.default.dirname(basePath);
+  const baseDir = import_node_path7.default.dirname(basePath);
   const candidates = [
-    import_node_path6.default.resolve(baseDir, "../../../assets/init"),
-    import_node_path6.default.resolve(baseDir, "../../assets/init")
+    import_node_path7.default.resolve(baseDir, "../../../assets/init"),
+    import_node_path7.default.resolve(baseDir, "../../assets/init")
   ];
   for (const candidate of candidates) {
     if ((0, import_node_fs.existsSync)(candidate)) {
@@ -917,10 +1022,10 @@ function getInitAssetsDir() {
 
 // src/core/promptsIntegrity.ts
 async function diffProjectPromptsAgainstInitAssets(root) {
-  const promptsDir = import_node_path7.default.resolve(root, ".qfai", "prompts");
+  const promptsDir = import_node_path8.default.resolve(root, ".qfai", "prompts");
   let templateDir;
   try {
-    templateDir = import_node_path7.default.join(getInitAssetsDir(), ".qfai", "prompts");
+    templateDir = import_node_path8.default.join(getInitAssetsDir(), ".qfai", "prompts");
   } catch {
     return {
       status: "skipped_missing_assets",
@@ -973,8 +1078,8 @@ async function diffProjectPromptsAgainstInitAssets(root) {
     }
     try {
       const [a, b] = await Promise.all([
-        (0, import_promises6.readFile)(templateAbs, "utf-8"),
-        (0, import_promises6.readFile)(projectAbs, "utf-8")
+        (0, import_promises7.readFile)(templateAbs, "utf-8"),
+        (0, import_promises7.readFile)(projectAbs, "utf-8")
       ]);
       if (normalizeNewlines(a) !== normalizeNewlines(b)) {
         changed.push(rel);
@@ -997,7 +1102,7 @@ function normalizeNewlines(text) {
   return text.replace(/\r\n/g, "\n");
 }
 function toRel(base, abs) {
-  const rel = import_node_path7.default.relative(base, abs);
+  const rel = import_node_path8.default.relative(base, abs);
   return rel.replace(/[\\/]+/g, "/");
 }
 function intersectKeys(a, b) {
@@ -1011,16 +1116,16 @@ function intersectKeys(a, b) {
 }
 
 // src/core/version.ts
-var import_promises7 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_promises8 = require("fs/promises");
+var import_node_path9 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 async function resolveToolVersion() {
-  if ("0.9.0".length > 0) {
-    return "0.9.0";
+  if ("0.9.2".length > 0) {
+    return "0.9.2";
   }
   try {
     const packagePath = resolvePackageJsonPath();
-    const raw = await (0, import_promises7.readFile)(packagePath, "utf-8");
+    const raw = await (0, import_promises8.readFile)(packagePath, "utf-8");
     const parsed = JSON.parse(raw);
     const version = typeof parsed.version === "string" ? parsed.version : "";
     return version.length > 0 ? version : "unknown";
@@ -1031,13 +1136,13 @@ async function resolveToolVersion() {
 function resolvePackageJsonPath() {
   const base = __filename;
   const basePath = base.startsWith("file:") ? (0, import_node_url2.fileURLToPath)(base) : base;
-  return import_node_path8.default.resolve(import_node_path8.default.dirname(basePath), "../../package.json");
+  return import_node_path9.default.resolve(import_node_path9.default.dirname(basePath), "../../package.json");
 }
 
 // src/core/doctor.ts
 async function exists4(target) {
   try {
-    await (0, import_promises8.access)(target);
+    await (0, import_promises9.access)(target);
     return true;
   } catch {
     return false;
@@ -1057,7 +1162,7 @@ function normalizeGlobs2(values) {
   return values.map((glob) => glob.trim()).filter((glob) => glob.length > 0);
 }
 async function createDoctorData(options) {
-  const startDir = import_node_path9.default.resolve(options.startDir);
+  const startDir = import_node_path10.default.resolve(options.startDir);
   const checks = [];
   const configPath = getConfigPath(startDir);
   const search = options.rootExplicit ? {
@@ -1120,9 +1225,9 @@ async function createDoctorData(options) {
       details: { path: toRelativePath(root, resolved) }
     });
     if (key === "promptsDir") {
-      const promptsLocalDir = import_node_path9.default.join(
-        import_node_path9.default.dirname(resolved),
-        `${import_node_path9.default.basename(resolved)}.local`
+      const promptsLocalDir = import_node_path10.default.join(
+        import_node_path10.default.dirname(resolved),
+        `${import_node_path10.default.basename(resolved)}.local`
       );
       const found = await exists4(promptsLocalDir);
       addCheck(checks, {
@@ -1195,7 +1300,7 @@ async function createDoctorData(options) {
     message: missingFiles === 0 ? `All spec packs have required files (count=${entries.length})` : `Missing required files in spec packs (missingFiles=${missingFiles})`,
     details: { specPacks: entries.length, missingFiles }
   });
-  const validateJsonAbs = import_node_path9.default.isAbsolute(config.output.validateJsonPath) ? config.output.validateJsonPath : import_node_path9.default.resolve(root, config.output.validateJsonPath);
+  const validateJsonAbs = import_node_path10.default.isAbsolute(config.output.validateJsonPath) ? config.output.validateJsonPath : import_node_path10.default.resolve(root, config.output.validateJsonPath);
   const validateJsonExists = await exists4(validateJsonAbs);
   addCheck(checks, {
     id: "output.validateJson",
@@ -1205,8 +1310,8 @@ async function createDoctorData(options) {
     details: { path: toRelativePath(root, validateJsonAbs) }
   });
   const outDirAbs = resolvePath(root, config, "outDir");
-  const rel = import_node_path9.default.relative(outDirAbs, validateJsonAbs);
-  const inside = rel !== "" && !rel.startsWith("..") && !import_node_path9.default.isAbsolute(rel);
+  const rel = import_node_path10.default.relative(outDirAbs, validateJsonAbs);
+  const inside = rel !== "" && !rel.startsWith("..") && !import_node_path10.default.isAbsolute(rel);
   addCheck(checks, {
     id: "output.pathAlignment",
     severity: inside ? "ok" : "warning",
@@ -1312,12 +1417,12 @@ async function detectOutDirCollisions(root) {
     ignore: DEFAULT_CONFIG_SEARCH_IGNORE_GLOBS
   });
   const configRoots = Array.from(
-    new Set(configPaths.map((configPath) => import_node_path9.default.dirname(configPath)))
+    new Set(configPaths.map((configPath) => import_node_path10.default.dirname(configPath)))
   ).sort((a, b) => a.localeCompare(b));
   const outDirToRoots = /* @__PURE__ */ new Map();
   for (const configRoot of configRoots) {
     const { config } = await loadConfig(configRoot);
-    const outDir = import_node_path9.default.normalize(resolvePath(configRoot, config, "outDir"));
+    const outDir = import_node_path10.default.normalize(resolvePath(configRoot, config, "outDir"));
     const roots = outDirToRoots.get(outDir) ?? /* @__PURE__ */ new Set();
     roots.add(configRoot);
     outDirToRoots.set(outDir, roots);
@@ -1334,20 +1439,20 @@ async function detectOutDirCollisions(root) {
   return { monorepoRoot, configRoots, collisions };
 }
 async function findMonorepoRoot(startDir) {
-  let current = import_node_path9.default.resolve(startDir);
+  let current = import_node_path10.default.resolve(startDir);
   while (true) {
-    const gitPath = import_node_path9.default.join(current, ".git");
-    const workspacePath = import_node_path9.default.join(current, "pnpm-workspace.yaml");
+    const gitPath = import_node_path10.default.join(current, ".git");
+    const workspacePath = import_node_path10.default.join(current, "pnpm-workspace.yaml");
     if (await exists4(gitPath) || await exists4(workspacePath)) {
       return current;
     }
-    const parent = import_node_path9.default.dirname(current);
+    const parent = import_node_path10.default.dirname(current);
     if (parent === current) {
       break;
     }
     current = parent;
   }
-  return import_node_path9.default.resolve(startDir);
+  return import_node_path10.default.resolve(startDir);
 }
 
 // src/cli/lib/logger.ts
@@ -1389,9 +1494,9 @@ async function runDoctor(options) {
   const output = options.format === "json" ? formatDoctorJson(data) : formatDoctorText(data);
   const exitCode = shouldFailDoctor(data.summary, options.failOn) ? 1 : 0;
   if (options.outPath) {
-    const outAbs = import_node_path10.default.isAbsolute(options.outPath) ? options.outPath : import_node_path10.default.resolve(process.cwd(), options.outPath);
-    await (0, import_promises9.mkdir)(import_node_path10.default.dirname(outAbs), { recursive: true });
-    await (0, import_promises9.writeFile)(outAbs, `${output}
+    const outAbs = import_node_path11.default.isAbsolute(options.outPath) ? options.outPath : import_node_path11.default.resolve(process.cwd(), options.outPath);
+    await (0, import_promises10.mkdir)(import_node_path11.default.dirname(outAbs), { recursive: true });
+    await (0, import_promises10.writeFile)(outAbs, `${output}
 `, "utf-8");
     info(`doctor: wrote ${outAbs}`);
     return exitCode;
@@ -1410,11 +1515,11 @@ function shouldFailDoctor(summary, failOn) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 
 // src/cli/lib/fs.ts
-var import_promises10 = require("fs/promises");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_promises11 = require("fs/promises");
+var import_node_path12 = __toESM(require("path"), 1);
 async function copyTemplateTree(sourceRoot, destRoot, options) {
   const files = await collectTemplateFiles(sourceRoot);
   return copyFiles(files, sourceRoot, destRoot, options);
@@ -1422,7 +1527,7 @@ async function copyTemplateTree(sourceRoot, destRoot, options) {
 async function copyTemplatePaths(sourceRoot, destRoot, relativePaths, options) {
   const allFiles = [];
   for (const relPath of relativePaths) {
-    const fullPath = import_node_path11.default.join(sourceRoot, relPath);
+    const fullPath = import_node_path12.default.join(sourceRoot, relPath);
     const files = await collectTemplateFiles(fullPath);
     allFiles.push(...files);
   }
@@ -1432,13 +1537,13 @@ async function copyFiles(files, sourceRoot, destRoot, options) {
   const copied = [];
   const skipped = [];
   const conflicts = [];
-  const protectPrefixes = (options.protect ?? []).map((p) => p.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "")).filter((p) => p.length > 0).map((p) => p + import_node_path11.default.sep);
-  const excludePrefixes = (options.exclude ?? []).map((p) => p.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "")).filter((p) => p.length > 0).map((p) => p + import_node_path11.default.sep);
+  const protectPrefixes = (options.protect ?? []).map((p) => p.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "")).filter((p) => p.length > 0).map((p) => p + import_node_path12.default.sep);
+  const excludePrefixes = (options.exclude ?? []).map((p) => p.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "")).filter((p) => p.length > 0).map((p) => p + import_node_path12.default.sep);
   const isProtectedRelative = (relative) => {
     if (protectPrefixes.length === 0) {
       return false;
     }
-    const normalized = relative.replace(/[\\/]+/g, import_node_path11.default.sep);
+    const normalized = relative.replace(/[\\/]+/g, import_node_path12.default.sep);
     return protectPrefixes.some(
       (prefix) => normalized === prefix.slice(0, -1) || normalized.startsWith(prefix)
     );
@@ -1447,7 +1552,7 @@ async function copyFiles(files, sourceRoot, destRoot, options) {
     if (excludePrefixes.length === 0) {
       return false;
     }
-    const normalized = relative.replace(/[\\/]+/g, import_node_path11.default.sep);
+    const normalized = relative.replace(/[\\/]+/g, import_node_path12.default.sep);
     return excludePrefixes.some(
       (prefix) => normalized === prefix.slice(0, -1) || normalized.startsWith(prefix)
     );
@@ -1455,14 +1560,14 @@ async function copyFiles(files, sourceRoot, destRoot, options) {
   const conflictPolicy = options.conflictPolicy ?? "error";
   if (!options.force && conflictPolicy === "error") {
     for (const file of files) {
-      const relative = import_node_path11.default.relative(sourceRoot, file);
+      const relative = import_node_path12.default.relative(sourceRoot, file);
       if (isExcludedRelative(relative)) {
         continue;
       }
       if (isProtectedRelative(relative)) {
         continue;
       }
-      const dest = import_node_path11.default.join(destRoot, relative);
+      const dest = import_node_path12.default.join(destRoot, relative);
       if (!await shouldWrite(dest, options.force)) {
         conflicts.push(dest);
       }
@@ -1472,19 +1577,19 @@ async function copyFiles(files, sourceRoot, destRoot, options) {
     }
   }
   for (const file of files) {
-    const relative = import_node_path11.default.relative(sourceRoot, file);
+    const relative = import_node_path12.default.relative(sourceRoot, file);
     if (isExcludedRelative(relative)) {
       continue;
     }
-    const dest = import_node_path11.default.join(destRoot, relative);
+    const dest = import_node_path12.default.join(destRoot, relative);
     const forceForThisFile = isProtectedRelative(relative) ? false : options.force;
     if (!await shouldWrite(dest, forceForThisFile)) {
       skipped.push(dest);
       continue;
     }
     if (!options.dryRun) {
-      await (0, import_promises10.mkdir)(import_node_path11.default.dirname(dest), { recursive: true });
-      await (0, import_promises10.copyFile)(file, dest);
+      await (0, import_promises11.mkdir)(import_node_path12.default.dirname(dest), { recursive: true });
+      await (0, import_promises11.copyFile)(file, dest);
     }
     copied.push(dest);
   }
@@ -1505,9 +1610,9 @@ async function collectTemplateFiles(root) {
   if (!await exists5(root)) {
     return entries;
   }
-  const items = await (0, import_promises10.readdir)(root, { withFileTypes: true });
+  const items = await (0, import_promises11.readdir)(root, { withFileTypes: true });
   for (const item of items) {
-    const fullPath = import_node_path11.default.join(root, item.name);
+    const fullPath = import_node_path12.default.join(root, item.name);
     if (item.isDirectory()) {
       const nested = await collectTemplateFiles(fullPath);
       entries.push(...nested);
@@ -1527,7 +1632,7 @@ async function shouldWrite(target, force) {
 }
 async function exists5(target) {
   try {
-    await (0, import_promises10.access)(target);
+    await (0, import_promises11.access)(target);
     return true;
   } catch {
     return false;
@@ -1537,10 +1642,10 @@ async function exists5(target) {
 // src/cli/commands/init.ts
 async function runInit(options) {
   const assetsRoot = getInitAssetsDir();
-  const rootAssets = import_node_path12.default.join(assetsRoot, "root");
-  const qfaiAssets = import_node_path12.default.join(assetsRoot, ".qfai");
-  const destRoot = import_node_path12.default.resolve(options.dir);
-  const destQfai = import_node_path12.default.join(destRoot, ".qfai");
+  const rootAssets = import_node_path13.default.join(assetsRoot, "root");
+  const qfaiAssets = import_node_path13.default.join(assetsRoot, ".qfai");
+  const destRoot = import_node_path13.default.resolve(options.dir);
+  const destQfai = import_node_path13.default.join(destRoot, ".qfai");
   if (options.force) {
     info(
       "NOTE: --force \u306F .qfai/prompts/** \u306E\u307F\u4E0A\u66F8\u304D\u3057\u307E\u3059\uFF08prompts.local \u306F\u4FDD\u8B77\u3055\u308C\u3001specs/contracts \u7B49\u306F\u4E0A\u66F8\u304D\u3057\u307E\u305B\u3093\uFF09\u3002"
@@ -1587,8 +1692,8 @@ function report(copied, skipped, dryRun, label) {
 }
 
 // src/cli/commands/report.ts
-var import_promises19 = require("fs/promises");
-var import_node_path19 = __toESM(require("path"), 1);
+var import_promises20 = require("fs/promises");
+var import_node_path20 = __toESM(require("path"), 1);
 
 // src/core/normalize.ts
 function normalizeIssuePaths(root, issues) {
@@ -1628,12 +1733,12 @@ function normalizeValidationResult(root, result) {
 }
 
 // src/core/report.ts
-var import_promises18 = require("fs/promises");
-var import_node_path18 = __toESM(require("path"), 1);
+var import_promises19 = require("fs/promises");
+var import_node_path19 = __toESM(require("path"), 1);
 
 // src/core/contractIndex.ts
-var import_promises11 = require("fs/promises");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_promises12 = require("fs/promises");
+var import_node_path14 = __toESM(require("path"), 1);
 
 // src/core/contractsDecl.ts
 var CONTRACT_DECLARATION_RE = /^\s*(?:#|\/\/|--|\/\*+|\*+)?\s*QFAI-CONTRACT-ID:\s*((?:API|UI|DB)-\d{4})\s*(?:\*\/)?\s*$/gm;
@@ -1655,9 +1760,9 @@ function stripContractDeclarationLines(text) {
 // src/core/contractIndex.ts
 async function buildContractIndex(root, config) {
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  const uiRoot = import_node_path13.default.join(contractsRoot, "ui");
-  const apiRoot = import_node_path13.default.join(contractsRoot, "api");
-  const dbRoot = import_node_path13.default.join(contractsRoot, "db");
+  const uiRoot = import_node_path14.default.join(contractsRoot, "ui");
+  const apiRoot = import_node_path14.default.join(contractsRoot, "api");
+  const dbRoot = import_node_path14.default.join(contractsRoot, "db");
   const [uiFiles, apiFiles, dbFiles] = await Promise.all([
     collectUiContractFiles(uiRoot),
     collectApiContractFiles(apiRoot),
@@ -1675,7 +1780,7 @@ async function buildContractIndex(root, config) {
 }
 async function indexContractFiles(files, index) {
   for (const file of files) {
-    const text = await (0, import_promises11.readFile)(file, "utf-8");
+    const text = await (0, import_promises12.readFile)(file, "utf-8");
     extractDeclaredContractIds(text).forEach((id) => record(index, id, file));
   }
 }
@@ -1910,14 +2015,14 @@ function parseSpec(md, file) {
 }
 
 // src/core/validators/contracts.ts
-var import_promises12 = require("fs/promises");
-var import_node_path15 = __toESM(require("path"), 1);
+var import_promises13 = require("fs/promises");
+var import_node_path16 = __toESM(require("path"), 1);
 
 // src/core/contracts.ts
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 var import_yaml2 = require("yaml");
 function parseStructuredContract(file, text) {
-  const ext = import_node_path14.default.extname(file).toLowerCase();
+  const ext = import_node_path15.default.extname(file).toLowerCase();
   if (ext === ".json") {
     return JSON.parse(text);
   }
@@ -1937,9 +2042,9 @@ var SQL_DANGEROUS_PATTERNS = [
 async function validateContracts(root, config) {
   const issues = [];
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  issues.push(...await validateUiContracts(import_node_path15.default.join(contractsRoot, "ui")));
-  issues.push(...await validateApiContracts(import_node_path15.default.join(contractsRoot, "api")));
-  issues.push(...await validateDbContracts(import_node_path15.default.join(contractsRoot, "db")));
+  issues.push(...await validateUiContracts(import_node_path16.default.join(contractsRoot, "ui")));
+  issues.push(...await validateApiContracts(import_node_path16.default.join(contractsRoot, "api")));
+  issues.push(...await validateDbContracts(import_node_path16.default.join(contractsRoot, "db")));
   const contractIndex = await buildContractIndex(root, config);
   issues.push(...validateDuplicateContractIds(contractIndex));
   return issues;
@@ -1959,7 +2064,7 @@ async function validateUiContracts(uiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises12.readFile)(file, "utf-8");
+    const text = await (0, import_promises13.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -2014,7 +2119,7 @@ async function validateApiContracts(apiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises12.readFile)(file, "utf-8");
+    const text = await (0, import_promises13.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -2082,7 +2187,7 @@ async function validateDbContracts(dbRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises12.readFile)(file, "utf-8");
+    const text = await (0, import_promises13.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -2225,8 +2330,8 @@ function issue(code, message, severity, file, rule, refs, category = "compatibil
 }
 
 // src/core/validators/delta.ts
-var import_promises13 = require("fs/promises");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_promises14 = require("fs/promises");
+var import_node_path17 = __toESM(require("path"), 1);
 var SECTION_RE = /^##\s+変更区分/m;
 var COMPAT_LINE_RE = /^\s*-\s*\[[ xX]\]\s*Compatibility\b/m;
 var CHANGE_LINE_RE = /^\s*-\s*\[[ xX]\]\s*Change\/Improvement\b/m;
@@ -2240,10 +2345,10 @@ async function validateDeltas(root, config) {
   }
   const issues = [];
   for (const pack of packs) {
-    const deltaPath = import_node_path16.default.join(pack, "delta.md");
+    const deltaPath = import_node_path17.default.join(pack, "delta.md");
     let text;
     try {
-      text = await (0, import_promises13.readFile)(deltaPath, "utf-8");
+      text = await (0, import_promises14.readFile)(deltaPath, "utf-8");
     } catch (error2) {
       if (isMissingFileError2(error2)) {
         issues.push(
@@ -2319,8 +2424,8 @@ function issue2(code, message, severity, file, rule, refs, category = "change",
 }
 
 // src/core/validators/ids.ts
-var import_promises14 = require("fs/promises");
-var import_node_path17 = __toESM(require("path"), 1);
+var import_promises15 = require("fs/promises");
+var import_node_path18 = __toESM(require("path"), 1);
 var SC_TAG_RE3 = /^SC-\d{4}$/;
 async function validateDefinedIds(root, config) {
   const issues = [];
@@ -2355,7 +2460,7 @@ async function validateDefinedIds(root, config) {
 }
 async function collectSpecDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await (0, import_promises14.readFile)(file, "utf-8");
+    const text = await (0, import_promises15.readFile)(file, "utf-8");
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
       recordId(out, parsed.specId, file);
@@ -2365,7 +2470,7 @@ async function collectSpecDefinitionIds(files, out) {
 }
 async function collectScenarioDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await (0, import_promises14.readFile)(file, "utf-8");
+    const text = await (0, import_promises15.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -2386,7 +2491,7 @@ function recordId(out, id, file) {
 }
 function formatFileList(files, root) {
   return files.map((file) => {
-    const relative = import_node_path17.default.relative(root, file);
+    const relative = import_node_path18.default.relative(root, file);
     return relative.length > 0 ? relative : file;
   }).join(", ");
 }
@@ -2444,7 +2549,7 @@ async function validatePromptsIntegrity(root) {
 }
 
 // src/core/validators/scenario.ts
-var import_promises15 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var GIVEN_PATTERN = /\bGiven\b/;
 var WHEN_PATTERN = /\bWhen\b/;
 var THEN_PATTERN = /\bThen\b/;
@@ -2470,7 +2575,7 @@ async function validateScenarios(root, config) {
   for (const entry of entries) {
     let text;
     try {
-      text = await (0, import_promises15.readFile)(entry.scenarioPath, "utf-8");
+      text = await (0, import_promises16.readFile)(entry.scenarioPath, "utf-8");
     } catch (error2) {
       if (isMissingFileError3(error2)) {
         issues.push(
@@ -2644,7 +2749,7 @@ function isMissingFileError3(error2) {
 }
 
 // src/core/validators/spec.ts
-var import_promises16 = require("fs/promises");
+var import_promises17 = require("fs/promises");
 async function validateSpecs(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const entries = await collectSpecEntries(specsRoot);
@@ -2665,7 +2770,7 @@ async function validateSpecs(root, config) {
   for (const entry of entries) {
     let text;
     try {
-      text = await (0, import_promises16.readFile)(entry.specPath, "utf-8");
+      text = await (0, import_promises17.readFile)(entry.specPath, "utf-8");
     } catch (error2) {
       if (isMissingFileError4(error2)) {
         issues.push(
@@ -2818,7 +2923,7 @@ function isMissingFileError4(error2) {
 }
 
 // src/core/validators/traceability.ts
-var import_promises17 = require("fs/promises");
+var import_promises18 = require("fs/promises");
 var SPEC_TAG_RE3 = /^SPEC-\d{4}$/;
 var BR_TAG_RE2 = /^BR-\d{4}$/;
 async function validateTraceability(root, config) {
@@ -2838,7 +2943,7 @@ async function validateTraceability(root, config) {
   const contractIndex = await buildContractIndex(root, config);
   const contractIds = contractIndex.ids;
   for (const file of specFiles) {
-    const text = await (0, import_promises17.readFile)(file, "utf-8");
+    const text = await (0, import_promises18.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
@@ -2911,7 +3016,7 @@ async function validateTraceability(root, config) {
     }
   }
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises17.readFile)(file, "utf-8");
+    const text = await (0, import_promises18.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const scenarioContractRefs = parseContractRefs(text, {
       allowCommentPrefix: true
@@ -3233,7 +3338,7 @@ async function validateCodeReferences(upstreamIds, srcRoot, testsRoot) {
   const pattern = buildIdPattern(Array.from(upstreamIds));
   let found = false;
   for (const file of targetFiles) {
-    const text = await (0, import_promises17.readFile)(file, "utf-8");
+    const text = await (0, import_promises18.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       found = true;
       break;
@@ -3325,15 +3430,15 @@ function countIssues(issues) {
 // src/core/report.ts
 var ID_PREFIXES2 = ["SPEC", "BR", "SC", "UI", "API", "DB"];
 async function createReportData(root, validation, configResult) {
-  const resolvedRoot = import_node_path18.default.resolve(root);
+  const resolvedRoot = import_node_path19.default.resolve(root);
   const resolved = configResult ?? await loadConfig(resolvedRoot);
   const config = resolved.config;
   const configPath = resolved.configPath;
   const specsRoot = resolvePath(resolvedRoot, config, "specsDir");
   const contractsRoot = resolvePath(resolvedRoot, config, "contractsDir");
-  const apiRoot = import_node_path18.default.join(contractsRoot, "api");
-  const uiRoot = import_node_path18.default.join(contractsRoot, "ui");
-  const dbRoot = import_node_path18.default.join(contractsRoot, "db");
+  const apiRoot = import_node_path19.default.join(contractsRoot, "api");
+  const uiRoot = import_node_path19.default.join(contractsRoot, "ui");
+  const dbRoot = import_node_path19.default.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specFiles = await collectSpecFiles(specsRoot);
@@ -3804,7 +3909,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await (0, import_promises18.readFile)(file, "utf-8");
+    const text = await (0, import_promises19.readFile)(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -3845,7 +3950,7 @@ async function collectIds(files) {
     DB: /* @__PURE__ */ new Set()
   };
   for (const file of files) {
-    const text = await (0, import_promises18.readFile)(file, "utf-8");
+    const text = await (0, import_promises19.readFile)(file, "utf-8");
     for (const prefix of ID_PREFIXES2) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -3863,7 +3968,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await (0, import_promises18.readFile)(file, "utf-8");
+    const text = await (0, import_promises19.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -3884,7 +3989,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern2(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await (0, import_promises18.readFile)(file, "utf-8");
+    const text = await (0, import_promises19.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -3976,7 +4081,7 @@ function buildHotspots(issues) {
 
 // src/cli/commands/report.ts
 async function runReport(options) {
-  const root = import_node_path19.default.resolve(options.root);
+  const root = import_node_path20.default.resolve(options.root);
   const configResult = await loadConfig(root);
   let validation;
   if (options.runValidate) {
@@ -3993,7 +4098,7 @@ async function runReport(options) {
     validation = normalized;
   } else {
     const input = options.inputPath ?? configResult.config.output.validateJsonPath;
-    const inputPath = import_node_path19.default.isAbsolute(input) ? input : import_node_path19.default.resolve(root, input);
+    const inputPath = import_node_path20.default.isAbsolute(input) ? input : import_node_path20.default.resolve(root, input);
     try {
       validation = await readValidationResult(inputPath);
     } catch (err) {
@@ -4019,11 +4124,11 @@ async function runReport(options) {
   const data = await createReportData(root, validation, configResult);
   const output = options.format === "json" ? formatReportJson(data) : formatReportMarkdown(data);
   const outRoot = resolvePath(root, configResult.config, "outDir");
-  const defaultOut = options.format === "json" ? import_node_path19.default.join(outRoot, "report.json") : import_node_path19.default.join(outRoot, "report.md");
+  const defaultOut = options.format === "json" ? import_node_path20.default.join(outRoot, "report.json") : import_node_path20.default.join(outRoot, "report.md");
   const out = options.outPath ?? defaultOut;
-  const outPath = import_node_path19.default.isAbsolute(out) ? out : import_node_path19.default.resolve(root, out);
-  await (0, import_promises19.mkdir)(import_node_path19.default.dirname(outPath), { recursive: true });
-  await (0, import_promises19.writeFile)(outPath, `${output}
+  const outPath = import_node_path20.default.isAbsolute(out) ? out : import_node_path20.default.resolve(root, out);
+  await (0, import_promises20.mkdir)(import_node_path20.default.dirname(outPath), { recursive: true });
+  await (0, import_promises20.writeFile)(outPath, `${output}
 `, "utf-8");
   info(
     `report: info=${validation.counts.info} warning=${validation.counts.warning} error=${validation.counts.error}`
@@ -4031,7 +4136,7 @@ async function runReport(options) {
   info(`wrote report: ${outPath}`);
 }
 async function readValidationResult(inputPath) {
-  const raw = await (0, import_promises19.readFile)(inputPath, "utf-8");
+  const raw = await (0, import_promises20.readFile)(inputPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!isValidationResult(parsed)) {
     throw new Error(`validate.json \u306E\u5F62\u5F0F\u304C\u4E0D\u6B63\u3067\u3059: ${inputPath}`);
@@ -4087,15 +4192,15 @@ function isMissingFileError5(error2) {
   return record2.code === "ENOENT";
 }
 async function writeValidationResult(root, outputPath, result) {
-  const abs = import_node_path19.default.isAbsolute(outputPath) ? outputPath : import_node_path19.default.resolve(root, outputPath);
-  await (0, import_promises19.mkdir)(import_node_path19.default.dirname(abs), { recursive: true });
-  await (0, import_promises19.writeFile)(abs, `${JSON.stringify(result, null, 2)}
+  const abs = import_node_path20.default.isAbsolute(outputPath) ? outputPath : import_node_path20.default.resolve(root, outputPath);
+  await (0, import_promises20.mkdir)(import_node_path20.default.dirname(abs), { recursive: true });
+  await (0, import_promises20.writeFile)(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 
 // src/cli/commands/validate.ts
-var import_promises20 = require("fs/promises");
-var import_node_path20 = __toESM(require("path"), 1);
+var import_promises21 = require("fs/promises");
+var import_node_path21 = __toESM(require("path"), 1);
 
 // src/cli/lib/failOn.ts
 function shouldFail(result, failOn) {
@@ -4110,7 +4215,7 @@ function shouldFail(result, failOn) {
 
 // src/cli/commands/validate.ts
 async function runValidate(options) {
-  const root = import_node_path20.default.resolve(options.root);
+  const root = import_node_path21.default.resolve(options.root);
   const configResult = await loadConfig(root);
   const result = await validateProject(root, configResult);
   const normalized = normalizeValidationResult(root, result);
@@ -4234,12 +4339,12 @@ function issueKey(issue7) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = resolveJsonPath(root, jsonPath);
-  await (0, import_promises20.mkdir)(import_node_path20.default.dirname(abs), { recursive: true });
-  await (0, import_promises20.writeFile)(abs, `${JSON.stringify(result, null, 2)}
+  await (0, import_promises21.mkdir)(import_node_path21.default.dirname(abs), { recursive: true });
+  await (0, import_promises21.writeFile)(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 function resolveJsonPath(root, jsonPath) {
-  return import_node_path20.default.isAbsolute(jsonPath) ? jsonPath : import_node_path20.default.resolve(root, jsonPath);
+  return import_node_path21.default.isAbsolute(jsonPath) ? jsonPath : import_node_path21.default.resolve(root, jsonPath);
 }
 var GITHUB_ANNOTATION_LIMIT = 100;
 
@@ -4252,6 +4357,7 @@ function parseArgs(argv, cwd) {
     force: false,
     yes: false,
     dryRun: false,
+    analyzeList: false,
     reportFormat: "md",
     reportRunValidate: false,
     doctorFormat: "text",
@@ -4261,6 +4367,7 @@ function parseArgs(argv, cwd) {
   };
   const args = [...argv];
   let command = args.shift() ?? null;
+  let invalid = false;
   if (command === "--help" || command === "-h") {
     options.help = true;
     command = null;
@@ -4269,13 +4376,29 @@ function parseArgs(argv, cwd) {
     const arg = args[i];
     switch (arg) {
       case "--root":
-        options.root = args[i + 1] ?? options.root;
-        options.rootExplicit = true;
-        i += 1;
+        {
+          const next = readOptionValue(args, i);
+          if (next === null) {
+            invalid = true;
+            options.help = true;
+            break;
+          }
+          options.root = next;
+          options.rootExplicit = true;
+          i += 1;
+        }
         break;
       case "--dir":
-        options.dir = args[i + 1] ?? options.dir;
-        i += 1;
+        {
+          const next = readOptionValue(args, i);
+          if (next === null) {
+            invalid = true;
+            options.help = true;
+            break;
+          }
+          options.dir = next;
+          i += 1;
+        }
         break;
       case "--force":
         options.force = true;
@@ -4286,8 +4409,25 @@ function parseArgs(argv, cwd) {
       case "--dry-run":
         options.dryRun = true;
         break;
+      case "--list":
+        options.analyzeList = true;
+        break;
+      case "--prompt":
+        {
+          const next = readOptionValue(args, i);
+          if (next) {
+            options.analyzePrompt = next;
+            i += 1;
+          }
+        }
+        break;
       case "--format": {
-        const next = args[i + 1];
+        const next = readOptionValue(args, i);
+        if (next === null) {
+          invalid = true;
+          options.help = true;
+          break;
+        }
         applyFormatOption(command, next, options);
         i += 1;
         break;
@@ -4296,35 +4436,44 @@ function parseArgs(argv, cwd) {
         options.strict = true;
         break;
       case "--fail-on": {
-        const next = args[i + 1];
+        const next = readOptionValue(args, i);
+        if (next === null) {
+          invalid = true;
+          options.help = true;
+          break;
+        }
         if (next === "never" || next === "warning" || next === "error") {
           options.failOn = next;
         }
         i += 1;
         break;
       }
-      case "--out":
-        {
-          const next = args[i + 1];
-          if (next) {
-            if (command === "doctor") {
-              options.doctorOut = next;
-            } else {
-              options.reportOut = next;
-            }
-          }
+      case "--out": {
+        const next = readOptionValue(args, i);
+        if (next === null) {
+          invalid = true;
+          options.help = true;
+          break;
+        }
+        if (command === "doctor") {
+          options.doctorOut = next;
+        } else {
+          options.reportOut = next;
         }
         i += 1;
         break;
-      case "--in":
-        {
-          const next = args[i + 1];
-          if (next) {
-            options.reportIn = next;
-          }
+      }
+      case "--in": {
+        const next = readOptionValue(args, i);
+        if (next === null) {
+          invalid = true;
+          options.help = true;
+          break;
         }
+        options.reportIn = next;
         i += 1;
         break;
+      }
       case "--run-validate":
         options.reportRunValidate = true;
         break;
@@ -4336,7 +4485,14 @@ function parseArgs(argv, cwd) {
         break;
     }
   }
-  return { command, options };
+  return { command, invalid, options };
+}
+function readOptionValue(args, index) {
+  const next = args[index + 1];
+  if (!next || next.startsWith("--")) {
+    return null;
+  }
+  return next;
 }
 function applyFormatOption(command, value, options) {
   if (!value) {
@@ -4370,9 +4526,12 @@ function applyFormatOption(command, value, options) {
 
 // src/cli/main.ts
 async function run(argv, cwd) {
-  const { command, options } = parseArgs(argv, cwd);
+  const { command, invalid, options } = parseArgs(argv, cwd);
   if (!command || options.help) {
     info(usage());
+    if (invalid) {
+      process.exitCode = 1;
+    }
     return;
   }
   switch (command) {
@@ -4384,6 +4543,17 @@ async function run(argv, cwd) {
         yes: options.yes
       });
       return;
+    case "analyze":
+      {
+        const resolvedRoot = await resolveRoot(options);
+        const exitCode = await runAnalyze({
+          root: resolvedRoot,
+          list: options.analyzeList,
+          ...options.analyzePrompt !== void 0 ? { prompt: options.analyzePrompt } : {}
+        });
+        process.exitCode = exitCode;
+      }
+      return;
     case "validate":
       {
         const resolvedRoot = await resolveRoot(options);
@@ -4430,6 +4600,7 @@ function usage() {
 
 Commands:
   init       \u30C6\u30F3\u30D7\u30EC\u3092\u751F\u6210
+  analyze    \u610F\u5473\u30EC\u30D9\u30EB\u306E\u30EC\u30D3\u30E5\u30FC\u88DC\u52A9\uFF08\u30D7\u30ED\u30F3\u30D7\u30C8\u51FA\u529B\uFF09
   validate   \u4ED5\u69D8/\u5951\u7D04/\u53C2\u7167\u306E\u691C\u67FB
   report     \u691C\u8A3C\u7D50\u679C\u3068\u96C6\u8A08\u3092\u51FA\u529B
   doctor     \u8A2D\u5B9A/\u30D1\u30B9/\u51FA\u529B\u524D\u63D0\u306E\u8A3A\u65AD
@@ -4440,6 +4611,8 @@ Options:
   --force         init: .qfai/prompts \u306E\u307F\u4E0A\u66F8\u304D\uFF08\u305D\u308C\u4EE5\u5916\u306F\u65E2\u5B58\u304C\u3042\u308C\u3070\u30B9\u30AD\u30C3\u30D7\uFF09
   --yes           init: \u4E88\u7D04\u30D5\u30E9\u30B0\uFF08\u73FE\u72B6\u306F\u975E\u5BFE\u8A71\u306E\u305F\u3081\u6319\u52D5\u5DEE\u306A\u3057\u3002\u5C06\u6765\u306E\u5BFE\u8A71\u5C0E\u5165\u6642\u306B\u81EA\u52D5Yes\uFF09
   --dry-run       \u5909\u66F4\u3092\u884C\u308F\u305A\u8868\u793A\u306E\u307F
+  --list                 analyze: \u5229\u7528\u53EF\u80FD\u306A\u30D7\u30ED\u30F3\u30D7\u30C8\u4E00\u89A7\u3092\u8868\u793A
+  --prompt <name>        analyze: \u6307\u5B9A\u30D7\u30ED\u30F3\u30D7\u30C8\uFF08.md\u7701\u7565\u53EF\uFF09\u3092\u51FA\u529B
   --format <text|github>       validate \u306E\u51FA\u529B\u5F62\u5F0F
   --format <md|json>           report \u306E\u51FA\u529B\u5F62\u5F0F
   --format <text|json>         doctor \u306E\u51FA\u529B\u5F62\u5F0F