qfai 0.8.1 → 0.9.2

package/dist/cli/index.mjs

@@ -1,16 +1,189 @@
 #!/usr/bin/env node
 
+// src/cli/commands/analyze.ts
+import { readFile } from "fs/promises";
+import path2 from "path";
+
+// src/core/fs.ts
+import { access, readdir } from "fs/promises";
+import path from "path";
+import fg from "fast-glob";
+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 fg(options.globs, {
+    cwd: root,
+    ignore: options.ignore ?? [],
+    onlyFiles: true,
+    absolute: true,
+    unique: true
+  });
+}
+async function walk(base, current, ignoreDirs, extensions, out) {
+  const items = await readdir(current, { withFileTypes: true });
+  for (const item of items) {
+    const fullPath = path.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 = path.extname(item.name).toLowerCase();
+        if (!extensions.includes(ext)) {
+          continue;
+        }
+      }
+      out.push(fullPath);
+    }
+  }
+}
+async function exists(target) {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/commands/analyze.ts
+async function runAnalyze(options) {
+  const root = path2.resolve(options.root);
+  const localDir = path2.join(root, ".qfai", "prompts.local", "analyze");
+  const standardDir = path2.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 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 = path2.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 = path2.join(dir, filename);
+    try {
+      await readFile(full, "utf-8");
+      return full;
+    } catch {
+    }
+  }
+  return null;
+}
+async function isDeprecatedPrompt(filePath) {
+  try {
+    const content = await 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
 import { mkdir, writeFile } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 
 // src/core/doctor.ts
 import { access as access4 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 
 // src/core/config.ts
-import { access, readFile } from "fs/promises";
-import path from "path";
+import { access as access2, readFile as readFile2 } from "fs/promises";
+import path3 from "path";
 import { parse as parseYaml } from "yaml";
 var defaultConfig = {
   paths: {
@@ -50,17 +223,17 @@ var defaultConfig = {
   }
 };
 function getConfigPath(root) {
-  return path.join(root, "qfai.config.yaml");
+  return path3.join(root, "qfai.config.yaml");
 }
 async function findConfigRoot(startDir) {
-  const resolvedStart = path.resolve(startDir);
+  const resolvedStart = path3.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 = path.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) {
       break;
     }
@@ -77,7 +250,7 @@ async function loadConfig(root) {
   const issues = [];
   let parsed;
   try {
-    const raw = await readFile(configPath, "utf-8");
+    const raw = await readFile2(configPath, "utf-8");
     parsed = parseYaml(raw);
   } catch (error2) {
     if (isMissingFile(error2)) {
@@ -90,7 +263,7 @@ async function loadConfig(root) {
   return { config: normalized, issues, configPath };
 }
 function resolvePath(root, config, key) {
-  return path.resolve(root, config.paths[key]);
+  return path3.resolve(root, config.paths[key]);
 }
 function normalizeConfig(raw, configPath, issues) {
   if (!isRecord(raw)) {
@@ -390,9 +563,9 @@ function isMissingFile(error2) {
   }
   return false;
 }
-async function exists(target) {
+async function exists2(target) {
   try {
-    await access(target);
+    await access2(target);
     return true;
   } catch {
     return false;
@@ -411,92 +584,24 @@ function isRecord(value) {
 // src/core/discovery.ts
 import { access as access3 } from "fs/promises";
 
-// src/core/fs.ts
-import { access as access2, readdir } from "fs/promises";
-import path2 from "path";
-import fg from "fast-glob";
-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 fg(options.globs, {
-    cwd: root,
-    ignore: options.ignore ?? [],
-    onlyFiles: true,
-    absolute: true,
-    unique: true
-  });
-}
-async function walk(base, current, ignoreDirs, extensions, out) {
-  const items = await readdir(current, { withFileTypes: true });
-  for (const item of items) {
-    const fullPath = path2.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 = path2.extname(item.name).toLowerCase();
-        if (!extensions.includes(ext)) {
-          continue;
-        }
-      }
-      out.push(fullPath);
-    }
-  }
-}
-async function exists2(target) {
-  try {
-    await access2(target);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/core/specLayout.ts
 import { readdir as readdir2 } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 var SPEC_DIR_RE = /^spec-\d{4}$/;
 async function collectSpecEntries(specsRoot) {
   const dirs = await listSpecDirs(specsRoot);
   const entries = dirs.map((dir) => ({
     dir,
-    specPath: path3.join(dir, "spec.md"),
-    deltaPath: path3.join(dir, "delta.md"),
-    scenarioPath: path3.join(dir, "scenario.md")
+    specPath: path4.join(dir, "spec.md"),
+    deltaPath: path4.join(dir, "delta.md"),
+    scenarioPath: path4.join(dir, "scenario.md")
   }));
   return entries.sort((a, b) => a.dir.localeCompare(b.dir));
 }
 async function listSpecDirs(specsRoot) {
   try {
     const items = await readdir2(specsRoot, { withFileTypes: true });
-    return items.filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => SPEC_DIR_RE.test(name.toLowerCase())).map((name) => path3.join(specsRoot, name));
+    return items.filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => SPEC_DIR_RE.test(name.toLowerCase())).map((name) => path4.join(specsRoot, name));
   } catch (error2) {
     if (isMissingFileError(error2)) {
       return [];
@@ -560,15 +665,15 @@ async function exists3(target) {
 }
 
 // src/core/paths.ts
-import path4 from "path";
+import path5 from "path";
 function toRelativePath(root, target) {
   if (!target) {
     return target;
   }
-  if (!path4.isAbsolute(target)) {
+  if (!path5.isAbsolute(target)) {
     return toPosixPath(target);
   }
-  const relative = path4.relative(root, target);
+  const relative = path5.relative(root, target);
   if (!relative) {
     return ".";
   }
@@ -579,8 +684,8 @@ function toPosixPath(value) {
 }
 
 // src/core/traceability.ts
-import { readFile as readFile2 } from "fs/promises";
-import path5 from "path";
+import { readFile as readFile3 } from "fs/promises";
+import path6 from "path";
 
 // src/core/gherkin/parse.ts
 import {
@@ -736,7 +841,7 @@ function extractAnnotatedScIds(text) {
 async function collectScIdsFromScenarioFiles(scenarioFiles) {
   const scIds = /* @__PURE__ */ new Set();
   for (const file of scenarioFiles) {
-    const text = await readFile2(file, "utf-8");
+    const text = await readFile3(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -754,7 +859,7 @@ async function collectScIdsFromScenarioFiles(scenarioFiles) {
 async function collectScIdSourcesFromScenarioFiles(scenarioFiles) {
   const sources = /* @__PURE__ */ new Map();
   for (const file of scenarioFiles) {
-    const text = await readFile2(file, "utf-8");
+    const text = await readFile3(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -807,10 +912,10 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
     };
   }
   const normalizedFiles = Array.from(
-    new Set(files.map((file) => path5.normalize(file)))
+    new Set(files.map((file) => path6.normalize(file)))
   );
   for (const file of normalizedFiles) {
-    const text = await readFile2(file, "utf-8");
+    const text = await readFile3(file, "utf-8");
     const scIds = extractAnnotatedScIds(text);
     if (scIds.length === 0) {
       continue;
@@ -867,20 +972,20 @@ function formatError3(error2) {
 }
 
 // src/core/promptsIntegrity.ts
-import { readFile as readFile3 } from "fs/promises";
-import path7 from "path";
+import { readFile as readFile4 } from "fs/promises";
+import path8 from "path";
 
 // src/shared/assets.ts
 import { existsSync } from "fs";
-import path6 from "path";
+import path7 from "path";
 import { fileURLToPath } from "url";
 function getInitAssetsDir() {
   const base = import.meta.url;
   const basePath = base.startsWith("file:") ? fileURLToPath(base) : base;
-  const baseDir = path6.dirname(basePath);
+  const baseDir = path7.dirname(basePath);
   const candidates = [
-    path6.resolve(baseDir, "../../../assets/init"),
-    path6.resolve(baseDir, "../../assets/init")
+    path7.resolve(baseDir, "../../../assets/init"),
+    path7.resolve(baseDir, "../../assets/init")
   ];
   for (const candidate of candidates) {
     if (existsSync(candidate)) {
@@ -898,10 +1003,10 @@ function getInitAssetsDir() {
 
 // src/core/promptsIntegrity.ts
 async function diffProjectPromptsAgainstInitAssets(root) {
-  const promptsDir = path7.resolve(root, ".qfai", "prompts");
+  const promptsDir = path8.resolve(root, ".qfai", "prompts");
   let templateDir;
   try {
-    templateDir = path7.join(getInitAssetsDir(), ".qfai", "prompts");
+    templateDir = path8.join(getInitAssetsDir(), ".qfai", "prompts");
   } catch {
     return {
       status: "skipped_missing_assets",
@@ -954,8 +1059,8 @@ async function diffProjectPromptsAgainstInitAssets(root) {
     }
     try {
       const [a, b] = await Promise.all([
-        readFile3(templateAbs, "utf-8"),
-        readFile3(projectAbs, "utf-8")
+        readFile4(templateAbs, "utf-8"),
+        readFile4(projectAbs, "utf-8")
       ]);
       if (normalizeNewlines(a) !== normalizeNewlines(b)) {
         changed.push(rel);
@@ -978,7 +1083,7 @@ function normalizeNewlines(text) {
   return text.replace(/\r\n/g, "\n");
 }
 function toRel(base, abs) {
-  const rel = path7.relative(base, abs);
+  const rel = path8.relative(base, abs);
   return rel.replace(/[\\/]+/g, "/");
 }
 function intersectKeys(a, b) {
@@ -992,16 +1097,16 @@ function intersectKeys(a, b) {
 }
 
 // src/core/version.ts
-import { readFile as readFile4 } from "fs/promises";
-import path8 from "path";
+import { readFile as readFile5 } from "fs/promises";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function resolveToolVersion() {
-  if ("0.8.1".length > 0) {
-    return "0.8.1";
+  if ("0.9.2".length > 0) {
+    return "0.9.2";
   }
   try {
     const packagePath = resolvePackageJsonPath();
-    const raw = await readFile4(packagePath, "utf-8");
+    const raw = await readFile5(packagePath, "utf-8");
     const parsed = JSON.parse(raw);
     const version = typeof parsed.version === "string" ? parsed.version : "";
     return version.length > 0 ? version : "unknown";
@@ -1012,7 +1117,7 @@ async function resolveToolVersion() {
 function resolvePackageJsonPath() {
   const base = import.meta.url;
   const basePath = base.startsWith("file:") ? fileURLToPath2(base) : base;
-  return path8.resolve(path8.dirname(basePath), "../../package.json");
+  return path9.resolve(path9.dirname(basePath), "../../package.json");
 }
 
 // src/core/doctor.ts
@@ -1038,7 +1143,7 @@ function normalizeGlobs2(values) {
   return values.map((glob) => glob.trim()).filter((glob) => glob.length > 0);
 }
 async function createDoctorData(options) {
-  const startDir = path9.resolve(options.startDir);
+  const startDir = path10.resolve(options.startDir);
   const checks = [];
   const configPath = getConfigPath(startDir);
   const search = options.rootExplicit ? {
@@ -1101,9 +1206,9 @@ async function createDoctorData(options) {
       details: { path: toRelativePath(root, resolved) }
     });
     if (key === "promptsDir") {
-      const promptsLocalDir = path9.join(
-        path9.dirname(resolved),
-        `${path9.basename(resolved)}.local`
+      const promptsLocalDir = path10.join(
+        path10.dirname(resolved),
+        `${path10.basename(resolved)}.local`
       );
       const found = await exists4(promptsLocalDir);
       addCheck(checks, {
@@ -1176,7 +1281,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 = path9.isAbsolute(config.output.validateJsonPath) ? config.output.validateJsonPath : path9.resolve(root, config.output.validateJsonPath);
+  const validateJsonAbs = path10.isAbsolute(config.output.validateJsonPath) ? config.output.validateJsonPath : path10.resolve(root, config.output.validateJsonPath);
   const validateJsonExists = await exists4(validateJsonAbs);
   addCheck(checks, {
     id: "output.validateJson",
@@ -1186,8 +1291,8 @@ async function createDoctorData(options) {
     details: { path: toRelativePath(root, validateJsonAbs) }
   });
   const outDirAbs = resolvePath(root, config, "outDir");
-  const rel = path9.relative(outDirAbs, validateJsonAbs);
-  const inside = rel !== "" && !rel.startsWith("..") && !path9.isAbsolute(rel);
+  const rel = path10.relative(outDirAbs, validateJsonAbs);
+  const inside = rel !== "" && !rel.startsWith("..") && !path10.isAbsolute(rel);
   addCheck(checks, {
     id: "output.pathAlignment",
     severity: inside ? "ok" : "warning",
@@ -1293,12 +1398,12 @@ async function detectOutDirCollisions(root) {
     ignore: DEFAULT_CONFIG_SEARCH_IGNORE_GLOBS
   });
   const configRoots = Array.from(
-    new Set(configPaths.map((configPath) => path9.dirname(configPath)))
+    new Set(configPaths.map((configPath) => path10.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 = path9.normalize(resolvePath(configRoot, config, "outDir"));
+    const outDir = path10.normalize(resolvePath(configRoot, config, "outDir"));
     const roots = outDirToRoots.get(outDir) ?? /* @__PURE__ */ new Set();
     roots.add(configRoot);
     outDirToRoots.set(outDir, roots);
@@ -1315,20 +1420,20 @@ async function detectOutDirCollisions(root) {
   return { monorepoRoot, configRoots, collisions };
 }
 async function findMonorepoRoot(startDir) {
-  let current = path9.resolve(startDir);
+  let current = path10.resolve(startDir);
   while (true) {
-    const gitPath = path9.join(current, ".git");
-    const workspacePath = path9.join(current, "pnpm-workspace.yaml");
+    const gitPath = path10.join(current, ".git");
+    const workspacePath = path10.join(current, "pnpm-workspace.yaml");
     if (await exists4(gitPath) || await exists4(workspacePath)) {
       return current;
     }
-    const parent = path9.dirname(current);
+    const parent = path10.dirname(current);
     if (parent === current) {
       break;
     }
     current = parent;
   }
-  return path9.resolve(startDir);
+  return path10.resolve(startDir);
 }
 
 // src/cli/lib/logger.ts
@@ -1370,8 +1475,8 @@ 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 = path10.isAbsolute(options.outPath) ? options.outPath : path10.resolve(process.cwd(), options.outPath);
-    await mkdir(path10.dirname(outAbs), { recursive: true });
+    const outAbs = path11.isAbsolute(options.outPath) ? options.outPath : path11.resolve(process.cwd(), options.outPath);
+    await mkdir(path11.dirname(outAbs), { recursive: true });
     await writeFile(outAbs, `${output}
 `, "utf-8");
     info(`doctor: wrote ${outAbs}`);
@@ -1391,11 +1496,11 @@ function shouldFailDoctor(summary, failOn) {
 }
 
 // src/cli/commands/init.ts
-import path12 from "path";
+import path13 from "path";
 
 // src/cli/lib/fs.ts
 import { access as access5, copyFile, mkdir as mkdir2, readdir as readdir3 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 async function copyTemplateTree(sourceRoot, destRoot, options) {
   const files = await collectTemplateFiles(sourceRoot);
   return copyFiles(files, sourceRoot, destRoot, options);
@@ -1403,7 +1508,7 @@ async function copyTemplateTree(sourceRoot, destRoot, options) {
 async function copyTemplatePaths(sourceRoot, destRoot, relativePaths, options) {
   const allFiles = [];
   for (const relPath of relativePaths) {
-    const fullPath = path11.join(sourceRoot, relPath);
+    const fullPath = path12.join(sourceRoot, relPath);
     const files = await collectTemplateFiles(fullPath);
     allFiles.push(...files);
   }
@@ -1413,13 +1518,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 + path11.sep);
-  const excludePrefixes = (options.exclude ?? []).map((p) => p.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "")).filter((p) => p.length > 0).map((p) => p + path11.sep);
+  const protectPrefixes = (options.protect ?? []).map((p) => p.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "")).filter((p) => p.length > 0).map((p) => p + path12.sep);
+  const excludePrefixes = (options.exclude ?? []).map((p) => p.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "")).filter((p) => p.length > 0).map((p) => p + path12.sep);
   const isProtectedRelative = (relative) => {
     if (protectPrefixes.length === 0) {
       return false;
     }
-    const normalized = relative.replace(/[\\/]+/g, path11.sep);
+    const normalized = relative.replace(/[\\/]+/g, path12.sep);
     return protectPrefixes.some(
       (prefix) => normalized === prefix.slice(0, -1) || normalized.startsWith(prefix)
     );
@@ -1428,7 +1533,7 @@ async function copyFiles(files, sourceRoot, destRoot, options) {
     if (excludePrefixes.length === 0) {
       return false;
     }
-    const normalized = relative.replace(/[\\/]+/g, path11.sep);
+    const normalized = relative.replace(/[\\/]+/g, path12.sep);
     return excludePrefixes.some(
       (prefix) => normalized === prefix.slice(0, -1) || normalized.startsWith(prefix)
     );
@@ -1436,14 +1541,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 = path11.relative(sourceRoot, file);
+      const relative = path12.relative(sourceRoot, file);
       if (isExcludedRelative(relative)) {
         continue;
       }
       if (isProtectedRelative(relative)) {
         continue;
       }
-      const dest = path11.join(destRoot, relative);
+      const dest = path12.join(destRoot, relative);
       if (!await shouldWrite(dest, options.force)) {
         conflicts.push(dest);
       }
@@ -1453,18 +1558,18 @@ async function copyFiles(files, sourceRoot, destRoot, options) {
     }
   }
   for (const file of files) {
-    const relative = path11.relative(sourceRoot, file);
+    const relative = path12.relative(sourceRoot, file);
     if (isExcludedRelative(relative)) {
       continue;
     }
-    const dest = path11.join(destRoot, relative);
+    const dest = path12.join(destRoot, relative);
     const forceForThisFile = isProtectedRelative(relative) ? false : options.force;
     if (!await shouldWrite(dest, forceForThisFile)) {
       skipped.push(dest);
       continue;
     }
     if (!options.dryRun) {
-      await mkdir2(path11.dirname(dest), { recursive: true });
+      await mkdir2(path12.dirname(dest), { recursive: true });
       await copyFile(file, dest);
     }
     copied.push(dest);
@@ -1488,7 +1593,7 @@ async function collectTemplateFiles(root) {
   }
   const items = await readdir3(root, { withFileTypes: true });
   for (const item of items) {
-    const fullPath = path11.join(root, item.name);
+    const fullPath = path12.join(root, item.name);
     if (item.isDirectory()) {
       const nested = await collectTemplateFiles(fullPath);
       entries.push(...nested);
@@ -1518,10 +1623,15 @@ async function exists5(target) {
 // src/cli/commands/init.ts
 async function runInit(options) {
   const assetsRoot = getInitAssetsDir();
-  const rootAssets = path12.join(assetsRoot, "root");
-  const qfaiAssets = path12.join(assetsRoot, ".qfai");
-  const destRoot = path12.resolve(options.dir);
-  const destQfai = path12.join(destRoot, ".qfai");
+  const rootAssets = path13.join(assetsRoot, "root");
+  const qfaiAssets = path13.join(assetsRoot, ".qfai");
+  const destRoot = path13.resolve(options.dir);
+  const destQfai = path13.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"
+    );
+  }
   const rootResult = await copyTemplateTree(rootAssets, destRoot, {
     force: false,
     dryRun: options.dryRun,
@@ -1563,8 +1673,8 @@ function report(copied, skipped, dryRun, label) {
 }
 
 // src/cli/commands/report.ts
-import { mkdir as mkdir3, readFile as readFile13, writeFile as writeFile2 } from "fs/promises";
-import path19 from "path";
+import { mkdir as mkdir3, readFile as readFile14, writeFile as writeFile2 } from "fs/promises";
+import path20 from "path";
 
 // src/core/normalize.ts
 function normalizeIssuePaths(root, issues) {
@@ -1604,12 +1714,12 @@ function normalizeValidationResult(root, result) {
 }
 
 // src/core/report.ts
-import { readFile as readFile12 } from "fs/promises";
-import path18 from "path";
+import { readFile as readFile13 } from "fs/promises";
+import path19 from "path";
 
 // src/core/contractIndex.ts
-import { readFile as readFile5 } from "fs/promises";
-import path13 from "path";
+import { readFile as readFile6 } from "fs/promises";
+import path14 from "path";
 
 // src/core/contractsDecl.ts
 var CONTRACT_DECLARATION_RE = /^\s*(?:#|\/\/|--|\/\*+|\*+)?\s*QFAI-CONTRACT-ID:\s*((?:API|UI|DB)-\d{4})\s*(?:\*\/)?\s*$/gm;
@@ -1631,9 +1741,9 @@ function stripContractDeclarationLines(text) {
 // src/core/contractIndex.ts
 async function buildContractIndex(root, config) {
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  const uiRoot = path13.join(contractsRoot, "ui");
-  const apiRoot = path13.join(contractsRoot, "api");
-  const dbRoot = path13.join(contractsRoot, "db");
+  const uiRoot = path14.join(contractsRoot, "ui");
+  const apiRoot = path14.join(contractsRoot, "api");
+  const dbRoot = path14.join(contractsRoot, "db");
   const [uiFiles, apiFiles, dbFiles] = await Promise.all([
     collectUiContractFiles(uiRoot),
     collectApiContractFiles(apiRoot),
@@ -1651,7 +1761,7 @@ async function buildContractIndex(root, config) {
 }
 async function indexContractFiles(files, index) {
   for (const file of files) {
-    const text = await readFile5(file, "utf-8");
+    const text = await readFile6(file, "utf-8");
     extractDeclaredContractIds(text).forEach((id) => record(index, id, file));
   }
 }
@@ -1886,14 +1996,14 @@ function parseSpec(md, file) {
 }
 
 // src/core/validators/contracts.ts
-import { readFile as readFile6 } from "fs/promises";
-import path15 from "path";
+import { readFile as readFile7 } from "fs/promises";
+import path16 from "path";
 
 // src/core/contracts.ts
-import path14 from "path";
+import path15 from "path";
 import { parse as parseYaml2 } from "yaml";
 function parseStructuredContract(file, text) {
-  const ext = path14.extname(file).toLowerCase();
+  const ext = path15.extname(file).toLowerCase();
   if (ext === ".json") {
     return JSON.parse(text);
   }
@@ -1913,9 +2023,9 @@ var SQL_DANGEROUS_PATTERNS = [
 async function validateContracts(root, config) {
   const issues = [];
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  issues.push(...await validateUiContracts(path15.join(contractsRoot, "ui")));
-  issues.push(...await validateApiContracts(path15.join(contractsRoot, "api")));
-  issues.push(...await validateDbContracts(path15.join(contractsRoot, "db")));
+  issues.push(...await validateUiContracts(path16.join(contractsRoot, "ui")));
+  issues.push(...await validateApiContracts(path16.join(contractsRoot, "api")));
+  issues.push(...await validateDbContracts(path16.join(contractsRoot, "db")));
   const contractIndex = await buildContractIndex(root, config);
   issues.push(...validateDuplicateContractIds(contractIndex));
   return issues;
@@ -1935,7 +2045,7 @@ async function validateUiContracts(uiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await readFile6(file, "utf-8");
+    const text = await readFile7(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -1990,7 +2100,7 @@ async function validateApiContracts(apiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await readFile6(file, "utf-8");
+    const text = await readFile7(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -2058,7 +2168,7 @@ async function validateDbContracts(dbRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await readFile6(file, "utf-8");
+    const text = await readFile7(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -2201,8 +2311,8 @@ function issue(code, message, severity, file, rule, refs, category = "compatibil
 }
 
 // src/core/validators/delta.ts
-import { readFile as readFile7 } from "fs/promises";
-import path16 from "path";
+import { readFile as readFile8 } from "fs/promises";
+import path17 from "path";
 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;
@@ -2216,10 +2326,10 @@ async function validateDeltas(root, config) {
   }
   const issues = [];
   for (const pack of packs) {
-    const deltaPath = path16.join(pack, "delta.md");
+    const deltaPath = path17.join(pack, "delta.md");
     let text;
     try {
-      text = await readFile7(deltaPath, "utf-8");
+      text = await readFile8(deltaPath, "utf-8");
     } catch (error2) {
       if (isMissingFileError2(error2)) {
         issues.push(
@@ -2295,8 +2405,8 @@ function issue2(code, message, severity, file, rule, refs, category = "change",
 }
 
 // src/core/validators/ids.ts
-import { readFile as readFile8 } from "fs/promises";
-import path17 from "path";
+import { readFile as readFile9 } from "fs/promises";
+import path18 from "path";
 var SC_TAG_RE3 = /^SC-\d{4}$/;
 async function validateDefinedIds(root, config) {
   const issues = [];
@@ -2331,7 +2441,7 @@ async function validateDefinedIds(root, config) {
 }
 async function collectSpecDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await readFile8(file, "utf-8");
+    const text = await readFile9(file, "utf-8");
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
       recordId(out, parsed.specId, file);
@@ -2341,7 +2451,7 @@ async function collectSpecDefinitionIds(files, out) {
 }
 async function collectScenarioDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await readFile8(file, "utf-8");
+    const text = await readFile9(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -2362,7 +2472,7 @@ function recordId(out, id, file) {
 }
 function formatFileList(files, root) {
   return files.map((file) => {
-    const relative = path17.relative(root, file);
+    const relative = path18.relative(root, file);
     return relative.length > 0 ? relative : file;
   }).join(", ");
 }
@@ -2420,7 +2530,7 @@ async function validatePromptsIntegrity(root) {
 }
 
 // src/core/validators/scenario.ts
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 var GIVEN_PATTERN = /\bGiven\b/;
 var WHEN_PATTERN = /\bWhen\b/;
 var THEN_PATTERN = /\bThen\b/;
@@ -2446,7 +2556,7 @@ async function validateScenarios(root, config) {
   for (const entry of entries) {
     let text;
     try {
-      text = await readFile9(entry.scenarioPath, "utf-8");
+      text = await readFile10(entry.scenarioPath, "utf-8");
     } catch (error2) {
       if (isMissingFileError3(error2)) {
         issues.push(
@@ -2620,7 +2730,7 @@ function isMissingFileError3(error2) {
 }
 
 // src/core/validators/spec.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 async function validateSpecs(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const entries = await collectSpecEntries(specsRoot);
@@ -2641,7 +2751,7 @@ async function validateSpecs(root, config) {
   for (const entry of entries) {
     let text;
     try {
-      text = await readFile10(entry.specPath, "utf-8");
+      text = await readFile11(entry.specPath, "utf-8");
     } catch (error2) {
       if (isMissingFileError4(error2)) {
         issues.push(
@@ -2794,7 +2904,7 @@ function isMissingFileError4(error2) {
 }
 
 // src/core/validators/traceability.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 var SPEC_TAG_RE3 = /^SPEC-\d{4}$/;
 var BR_TAG_RE2 = /^BR-\d{4}$/;
 async function validateTraceability(root, config) {
@@ -2814,7 +2924,7 @@ async function validateTraceability(root, config) {
   const contractIndex = await buildContractIndex(root, config);
   const contractIds = contractIndex.ids;
   for (const file of specFiles) {
-    const text = await readFile11(file, "utf-8");
+    const text = await readFile12(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
@@ -2887,7 +2997,7 @@ async function validateTraceability(root, config) {
     }
   }
   for (const file of scenarioFiles) {
-    const text = await readFile11(file, "utf-8");
+    const text = await readFile12(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const scenarioContractRefs = parseContractRefs(text, {
       allowCommentPrefix: true
@@ -3209,7 +3319,7 @@ async function validateCodeReferences(upstreamIds, srcRoot, testsRoot) {
   const pattern = buildIdPattern(Array.from(upstreamIds));
   let found = false;
   for (const file of targetFiles) {
-    const text = await readFile11(file, "utf-8");
+    const text = await readFile12(file, "utf-8");
     if (pattern.test(text)) {
       found = true;
       break;
@@ -3301,15 +3411,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 = path18.resolve(root);
+  const resolvedRoot = path19.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 = path18.join(contractsRoot, "api");
-  const uiRoot = path18.join(contractsRoot, "ui");
-  const dbRoot = path18.join(contractsRoot, "db");
+  const apiRoot = path19.join(contractsRoot, "api");
+  const uiRoot = path19.join(contractsRoot, "ui");
+  const dbRoot = path19.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specFiles = await collectSpecFiles(specsRoot);
@@ -3780,7 +3890,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await readFile12(file, "utf-8");
+    const text = await readFile13(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -3821,7 +3931,7 @@ async function collectIds(files) {
     DB: /* @__PURE__ */ new Set()
   };
   for (const file of files) {
-    const text = await readFile12(file, "utf-8");
+    const text = await readFile13(file, "utf-8");
     for (const prefix of ID_PREFIXES2) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -3839,7 +3949,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await readFile12(file, "utf-8");
+    const text = await readFile13(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -3860,7 +3970,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern2(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await readFile12(file, "utf-8");
+    const text = await readFile13(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -3952,7 +4062,7 @@ function buildHotspots(issues) {
 
 // src/cli/commands/report.ts
 async function runReport(options) {
-  const root = path19.resolve(options.root);
+  const root = path20.resolve(options.root);
   const configResult = await loadConfig(root);
   let validation;
   if (options.runValidate) {
@@ -3969,7 +4079,7 @@ async function runReport(options) {
     validation = normalized;
   } else {
     const input = options.inputPath ?? configResult.config.output.validateJsonPath;
-    const inputPath = path19.isAbsolute(input) ? input : path19.resolve(root, input);
+    const inputPath = path20.isAbsolute(input) ? input : path20.resolve(root, input);
     try {
       validation = await readValidationResult(inputPath);
     } catch (err) {
@@ -3995,10 +4105,10 @@ 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" ? path19.join(outRoot, "report.json") : path19.join(outRoot, "report.md");
+  const defaultOut = options.format === "json" ? path20.join(outRoot, "report.json") : path20.join(outRoot, "report.md");
   const out = options.outPath ?? defaultOut;
-  const outPath = path19.isAbsolute(out) ? out : path19.resolve(root, out);
-  await mkdir3(path19.dirname(outPath), { recursive: true });
+  const outPath = path20.isAbsolute(out) ? out : path20.resolve(root, out);
+  await mkdir3(path20.dirname(outPath), { recursive: true });
   await writeFile2(outPath, `${output}
 `, "utf-8");
   info(
@@ -4007,7 +4117,7 @@ async function runReport(options) {
   info(`wrote report: ${outPath}`);
 }
 async function readValidationResult(inputPath) {
-  const raw = await readFile13(inputPath, "utf-8");
+  const raw = await readFile14(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}`);
@@ -4063,15 +4173,15 @@ function isMissingFileError5(error2) {
   return record2.code === "ENOENT";
 }
 async function writeValidationResult(root, outputPath, result) {
-  const abs = path19.isAbsolute(outputPath) ? outputPath : path19.resolve(root, outputPath);
-  await mkdir3(path19.dirname(abs), { recursive: true });
+  const abs = path20.isAbsolute(outputPath) ? outputPath : path20.resolve(root, outputPath);
+  await mkdir3(path20.dirname(abs), { recursive: true });
   await writeFile2(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 
 // src/cli/commands/validate.ts
 import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 
 // src/cli/lib/failOn.ts
 function shouldFail(result, failOn) {
@@ -4086,7 +4196,7 @@ function shouldFail(result, failOn) {
 
 // src/cli/commands/validate.ts
 async function runValidate(options) {
-  const root = path20.resolve(options.root);
+  const root = path21.resolve(options.root);
   const configResult = await loadConfig(root);
   const result = await validateProject(root, configResult);
   const normalized = normalizeValidationResult(root, result);
@@ -4210,12 +4320,12 @@ function issueKey(issue7) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = resolveJsonPath(root, jsonPath);
-  await mkdir4(path20.dirname(abs), { recursive: true });
+  await mkdir4(path21.dirname(abs), { recursive: true });
   await writeFile3(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 function resolveJsonPath(root, jsonPath) {
-  return path20.isAbsolute(jsonPath) ? jsonPath : path20.resolve(root, jsonPath);
+  return path21.isAbsolute(jsonPath) ? jsonPath : path21.resolve(root, jsonPath);
 }
 var GITHUB_ANNOTATION_LIMIT = 100;
 
@@ -4228,6 +4338,7 @@ function parseArgs(argv, cwd) {
     force: false,
     yes: false,
     dryRun: false,
+    analyzeList: false,
     reportFormat: "md",
     reportRunValidate: false,
     doctorFormat: "text",
@@ -4237,6 +4348,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;
@@ -4245,13 +4357,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;
@@ -4262,8 +4390,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;
@@ -4272,35 +4417,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;
@@ -4312,7 +4466,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) {
@@ -4346,9 +4507,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) {
@@ -4360,6 +4524,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);
@@ -4406,6 +4581,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
@@ -4413,9 +4589,11 @@ Commands:
 Options:
   --root <path>   \u5BFE\u8C61\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA
   --dir <path>    init \u306E\u51FA\u529B\u5148
-  --force         \u65E2\u5B58\u30D5\u30A1\u30A4\u30EB\u3092\u4E0A\u66F8\u304D
+  --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