speclore 0.1.8 → 0.1.10

package/dist/mcp/server.js

@@ -148,7 +148,7 @@ var init_cost_tracker = __esm({
           totalTokens: promptTokens + completionTokens,
           estimatedCostUsd: cost
         });
-        logger.debug(`AI usage: ${model} \u2014 ${promptTokens}+${completionTokens} tokens, ~$${cost.toFixed(4)}`);
+        logger.debug(`AI usage: ${model} - ${promptTokens}+${completionTokens} tokens, ~$${cost.toFixed(4)}`);
         return cost;
       }
       /**
@@ -818,7 +818,7 @@ function acquireLock(specLoreDir) {
   try {
     writeFileSync(lockPath, JSON.stringify(lockInfo), { flag: "wx", encoding: "utf-8" });
   } catch {
-    logger.debug("Lock write failed \u2014 another process may have acquired it");
+    logger.debug("Lock write failed - another process may have acquired it");
     return false;
   }
   logger.debug(`Lock acquired by PID ${process.pid}`);
@@ -878,8 +878,8 @@ init_logger();
 
 // src/core/requirement-reader/index.ts
 init_logger();
-import { existsSync as existsSync6 } from "fs";
-import { extname as extname6 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { extname as extname7 } from "path";
 
 // src/plugins/registry.ts
 init_logger();
@@ -1026,8 +1026,8 @@ var PdfReader = class {
     } catch {
       throw new Error("pdfjs-dist package is required for PDF support. Install: npm i pdfjs-dist");
     }
-    const { readFileSync: readFileSync18 } = await import("fs");
-    const buffer = readFileSync18(source);
+    const { readFileSync: readFileSync19 } = await import("fs");
+    const buffer = readFileSync19(source);
     const uint8 = new Uint8Array(buffer);
     const doc = await pdfjsLib.getDocument({
       data: uint8,
@@ -1060,13 +1060,13 @@ var ImageReader = class {
     return /\.(png|jpe?g|webp)$/i.test(source);
   }
   async read(source) {
-    const { existsSync: existsSync22, readFileSync: readFileSync18 } = await import("fs");
-    if (!existsSync22(source)) {
+    const { existsSync: existsSync23, readFileSync: readFileSync19 } = await import("fs");
+    if (!existsSync23(source)) {
       throw new Error(`Image file not found: ${source}`);
     }
     const ext = source.split(".").pop()?.toLowerCase() ?? "png";
     const mimeType = ext === "jpg" ? "image/jpeg" : `image/${ext}`;
-    const buffer = readFileSync18(source);
+    const buffer = readFileSync19(source);
     let text;
     try {
       const { createProvider: createProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
@@ -1258,26 +1258,45 @@ var ClaudeWriter = class {
 };
 
 // src/plugins/builtin/qoder-writer.ts
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync5, rmSync as rmSync3 } from "fs";
-import { join as join4 } from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync6, rmSync as rmSync3 } from "fs";
+import { join as join5 } from "path";
+
+// src/infra/path-utils.ts
+import { posix, sep, relative, resolve, isAbsolute, join as join4 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { glob, globSync } from "glob";
+function toPosixPath(p) {
+  return p.split(/[/\\]/).join(posix.sep);
+}
+function resolveQoderDir(projectRoot2) {
+  if (existsSync5(join4(projectRoot2, ".qoder-cn"))) return ".qoder-cn";
+  return ".qoder";
+}
+function hasQoderDir(projectRoot2) {
+  return existsSync5(join4(projectRoot2, ".qoder")) || existsSync5(join4(projectRoot2, ".qoder-cn"));
+}
+
+// src/plugins/builtin/qoder-writer.ts
 var QoderWriter = class {
   toolName = "qoder";
   configFile = ".qoder/rules/speclore.md";
   projectRoot = "";
   detect(projectRoot2) {
-    return existsSync5(join4(projectRoot2, ".qoder"));
+    return existsSync6(join5(projectRoot2, ".qoder")) || existsSync6(join5(projectRoot2, ".qoder-cn"));
   }
   write(constraints) {
     this.projectRoot = constraints.projectRoot;
-    const rulesDir = join4(constraints.projectRoot, ".qoder", "rules");
+    const qoderDir = resolveQoderDir(constraints.projectRoot);
+    const rulesDir = join5(constraints.projectRoot, qoderDir, "rules");
     mkdirSync3(rulesDir, { recursive: true });
     const content = this.buildMarkdown(constraints);
-    writeFileSync4(join4(rulesDir, "speclore.md"), content, "utf-8");
+    writeFileSync4(join5(rulesDir, "speclore.md"), content, "utf-8");
     return Promise.resolve();
   }
   remove() {
-    const filePath = join4(this.projectRoot, ".qoder", "rules", "speclore.md");
-    if (existsSync5(filePath)) rmSync3(filePath);
+    const qoderDir = resolveQoderDir(this.projectRoot);
+    const filePath = join5(this.projectRoot, qoderDir, "rules", "speclore.md");
+    if (existsSync6(filePath)) rmSync3(filePath);
     return Promise.resolve();
   }
   buildMarkdown(c) {
@@ -1806,9 +1825,30 @@ async function readImageFile(filePath, providerOverride) {
   };
 }
 
+// src/core/requirement-reader/text-reader.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { basename as basename6, extname as extname6 } from "path";
+function readTextFile(filePath) {
+  const content = readFileSync6(filePath, "utf-8");
+  const id = deriveId2(filePath);
+  const lines = content.split("\n").filter((line) => line.trim().length > 0);
+  const title = lines[0]?.slice(0, 100) ?? basename6(filePath, extname6(filePath));
+  return Promise.resolve({
+    id,
+    title,
+    description: content,
+    rawContent: content,
+    confidence: 1
+  });
+}
+function deriveId2(filePath) {
+  const name = basename6(filePath, extname6(filePath));
+  return name.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-");
+}
+
 // src/core/requirement-reader/url-reader.ts
 init_logger();
-import { basename as basename6 } from "path";
+import { basename as basename7 } from "path";
 var FETCH_TIMEOUT_MS = 1e4;
 var MAX_CONTENT_LENGTH = 1e5;
 async function readUrl(url) {
@@ -1848,7 +1888,7 @@ async function readUrl(url) {
       content = content.slice(0, MAX_CONTENT_LENGTH) + "\n... (truncated)";
     }
     const urlPath = new URL(url).pathname;
-    const id = basename6(urlPath).toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-") || "url-content";
+    const id = basename7(urlPath).toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-") || "url-content";
     return {
       id,
       title,
@@ -1896,30 +1936,43 @@ var UrlAuthError = class extends Error {
 };
 
 // src/core/requirement-reader/index.ts
+function sanitizeSource(source) {
+  return source.replace(/[\u200B-\u200F\u202A-\u202E\u2060-\u2069\uFEFF\u00AD]/g, "");
+}
 async function readRequirement(source) {
-  const sourceType = classifySource(source);
-  logger.info(`Reading requirement from ${sourceType}: ${truncate(source, 80)}`);
+  const cleaned = sanitizeSource(source);
+  if (cleaned !== source) {
+    logger.debug("Stripped invisible Unicode characters from source input.");
+  }
+  const sourceType = classifySource(cleaned);
+  logger.info(`Reading requirement from ${sourceType}: ${truncate(cleaned, 120)}`);
   switch (sourceType) {
     case "file":
-      return readFromFile(source);
+      return readFromFile(cleaned);
     case "url":
-      return readFromUrl(source);
+      return readFromUrl(cleaned);
     case "text":
-      return readFromText(source);
+      return readFromText(cleaned);
   }
 }
 function classifySource(source) {
   if (/^https?:\/\//i.test(source)) {
     return "url";
   }
-  const ext = extname6(source).toLowerCase();
-  const supportedExts = [".md", ".docx", ".xlsx", ".xls", ".pdf", ".png", ".jpg", ".jpeg", ".webp"];
-  if (supportedExts.includes(ext) && existsSync6(source)) {
+  const ext = extname7(source).toLowerCase();
+  const supportedExts = [".md", ".txt", ".docx", ".xlsx", ".xls", ".pdf", ".png", ".jpg", ".jpeg", ".webp"];
+  if (supportedExts.includes(ext) && existsSync7(source)) {
     return "file";
   }
-  if (existsSync6(source) && (source.includes("/") || source.includes("\\"))) {
+  if (existsSync7(source) && (source.includes("/") || source.includes("\\"))) {
     return "file";
   }
+  if (supportedExts.includes(ext) && (source.includes("/") || source.includes("\\"))) {
+    throw new Error(
+      `File not found: ${source}
+The path looks like a file but does not exist. Check the path and try again. If copying from Windows, make sure no invisible characters are included.`
+    );
+  }
   return "text";
 }
 async function readFromFile(filePath) {
@@ -1933,10 +1986,12 @@ async function readFromFile(filePath) {
     }
     return results[0];
   }
-  const ext = extname6(filePath).toLowerCase();
+  const ext = extname7(filePath).toLowerCase();
   switch (ext) {
     case ".md":
       return readMarkdownFile(filePath);
+    case ".txt":
+      return readTextFile(filePath);
     case ".docx":
       return readDocxFile(filePath);
     case ".xlsx":
@@ -1972,7 +2027,7 @@ function truncate(str, maxLen) {
 
 // src/core/feature-generator/generator.ts
 init_provider();
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync7 } from "fs";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync8 } from "fs";
 import { join as join6, dirname } from "path";
 import { Parser as Parser2, GherkinClassicTokenMatcher as GherkinClassicTokenMatcher2, AstBuilder as AstBuilder2 } from "@cucumber/gherkin";
 import { IdGenerator as IdGenerator2 } from "@cucumber/messages";
@@ -2184,15 +2239,6 @@ function buildPrompt(requirement, context, config) {
 
 // src/core/feature-generator/generator.ts
 init_logger();
-
-// src/infra/path-utils.ts
-import { posix, sep, relative, resolve, isAbsolute, join as join5 } from "path";
-import { glob, globSync } from "glob";
-function toPosixPath(p) {
-  return p.split(/[/\\]/).join(posix.sep);
-}
-
-// src/core/feature-generator/generator.ts
 var MAX_VALIDATION_RETRIES = 2;
 async function generateFeature(requirement, context, config, projectRoot2, providerOverride) {
   logger.info(`Generating feature for: ${requirement.title}`);
@@ -2258,7 +2304,7 @@ Please fix these issues and regenerate the complete Feature file.`;
   const outputDir = join6(projectRoot2, config.spec.outputDir);
   const moduleDir = inferModule(requirement, context);
   const filePath = join6(outputDir, moduleDir, `${requirement.id}.feature`);
-  if (!existsSync7(dirname(filePath))) {
+  if (!existsSync8(dirname(filePath))) {
     mkdirSync4(dirname(filePath), { recursive: true });
   }
   writeFileSync5(filePath, featureContent, "utf-8");
@@ -2389,21 +2435,21 @@ function inferModule(requirement, context) {
 
 // src/core/constraint-coder/ai-tool-detector.ts
 init_logger();
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { join as join7 } from "path";
 function detectAITools(projectRoot2) {
   const tools = [];
-  if (existsSync8(join7(projectRoot2, ".cursor"))) {
+  if (existsSync9(join7(projectRoot2, ".cursor"))) {
     tools.push("cursor");
     logger.debug("Detected Cursor (.cursor/)");
   }
-  if (existsSync8(join7(projectRoot2, ".claude")) || existsSync8(join7(projectRoot2, "CLAUDE.md"))) {
+  if (existsSync9(join7(projectRoot2, ".claude")) || existsSync9(join7(projectRoot2, "CLAUDE.md"))) {
     tools.push("claude");
     logger.debug("Detected Claude Code (.claude/ or CLAUDE.md)");
   }
-  if (existsSync8(join7(projectRoot2, ".qoder"))) {
+  if (hasQoderDir(projectRoot2)) {
     tools.push("qoder");
-    logger.debug("Detected Qoder (.qoder/)");
+    logger.debug("Detected Qoder (.qoder/ or .qoder-cn/)");
   }
   logger.debug(`Detected AI tools: ${tools.length > 0 ? tools.join(", ") : "none"}`);
   return tools;
@@ -2411,7 +2457,7 @@ function detectAITools(projectRoot2) {
 
 // src/core/constraint-coder/constraint-writer.ts
 init_logger();
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync9 } from "fs";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync10 } from "fs";
 import { join as join8 } from "path";
 function writeConstraints(projectRoot2, tools, content) {
   const writtenFiles = [];
@@ -2485,7 +2531,7 @@ function buildConstraintText(content) {
 }
 function writeCursorRule(projectRoot2, text) {
   const dir = join8(projectRoot2, ".cursor", "rules");
-  if (!existsSync9(dir)) mkdirSync5(dir, { recursive: true });
+  if (!existsSync10(dir)) mkdirSync5(dir, { recursive: true });
   const filePath = join8(dir, "speclore.mdc");
   const frontmatter = [
     "---",
@@ -2500,14 +2546,15 @@ function writeCursorRule(projectRoot2, text) {
 }
 function writeClaudeRule(projectRoot2, text) {
   const dir = join8(projectRoot2, ".claude", "rules");
-  if (!existsSync9(dir)) mkdirSync5(dir, { recursive: true });
+  if (!existsSync10(dir)) mkdirSync5(dir, { recursive: true });
   const filePath = join8(dir, "speclore.md");
   writeFileSync6(filePath, text, "utf-8");
   return filePath;
 }
 function writeQoderRule(projectRoot2, text) {
-  const dir = join8(projectRoot2, ".qoder", "rules");
-  if (!existsSync9(dir)) mkdirSync5(dir, { recursive: true });
+  const qoderDir = resolveQoderDir(projectRoot2);
+  const dir = join8(projectRoot2, qoderDir, "rules");
+  if (!existsSync10(dir)) mkdirSync5(dir, { recursive: true });
   const filePath = join8(dir, "speclore.md");
   writeFileSync6(filePath, text, "utf-8");
   return filePath;
@@ -2518,7 +2565,7 @@ init_logger();
 function readModuleConfig(config) {
   const boundaries = [];
   for (const [name, mod] of Object.entries(config.project.modules)) {
-    logger.debug(`Reading module config: ${name} \u2192 ${mod.path}`);
+    logger.debug(`Reading module config: ${name} -> ${mod.path}`);
     boundaries.push({
       name,
       responsibility: mod.responsibility,
@@ -2579,7 +2626,7 @@ async function generateConstraints(projectRoot2, features, _context, config) {
       try {
         await writer.write(content);
         writtenFiles.push(writer.configFile);
-        logger.info(`Constraint written via plugin: ${writer.toolName} \u2192 ${writer.configFile}`);
+        logger.info(`Constraint written via plugin: ${writer.toolName} -> ${writer.configFile}`);
       } catch (err) {
         logger.warn(`Writer plugin '${tool}' failed: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -2596,7 +2643,7 @@ import { execFileSync } from "child_process";
 
 // src/core/verifier/mapping-resolver.ts
 init_logger();
-import { readFileSync as readFileSync6, existsSync as existsSync10, readdirSync } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync11, readdirSync } from "fs";
 import { join as join9 } from "path";
 function resolveMappings(projectRoot2, features, testOutput) {
   const results = [];
@@ -2621,17 +2668,17 @@ function resolveMapping(projectRoot2, feature, scenario, _testOutput) {
 }
 function resolveFromMappingFile(projectRoot2, _feature, scenario) {
   const mappingsDir = join9(projectRoot2, ".speclore", "mappings");
-  if (!existsSync10(mappingsDir)) return null;
+  if (!existsSync11(mappingsDir)) return null;
   try {
     const files = findMappingFiles(mappingsDir);
     for (const file of files) {
       try {
-        const content = readFileSync6(file, "utf-8");
+        const content = readFileSync7(file, "utf-8");
         const mapping = JSON.parse(content);
         if (mapping.scenarios && scenario.name in mapping.scenarios) {
           const entry = mapping.scenarios[scenario.name];
           if (entry) {
-            logger.debug(`Mapping file hit: ${scenario.name} \u2192 ${entry.testMethod}`);
+            logger.debug(`Mapping file hit: ${scenario.name} -> ${entry.testMethod}`);
             return {
               name: scenario.name,
               status: "passed",
@@ -2651,18 +2698,18 @@ function resolveFromMappingFile(projectRoot2, _feature, scenario) {
 }
 function resolveFromTag(projectRoot2, _feature, scenario) {
   const testsDir = join9(projectRoot2, "tests");
-  if (!existsSync10(testsDir)) return null;
+  if (!existsSync11(testsDir)) return null;
   try {
     const files = findTestFiles(testsDir);
     for (const file of files) {
       try {
-        const content = readFileSync6(file, "utf-8");
+        const content = readFileSync7(file, "utf-8");
         const tagRegex = /@speclore-scenario:\s*(.+)/g;
         let match;
         while ((match = tagRegex.exec(content)) !== null) {
           if (match[1].trim() === scenario.name) {
             const methodMatch = findTestMethodNearby(content, match.index);
-            logger.debug(`Tag hit: ${scenario.name} \u2192 ${methodMatch}`);
+            logger.debug(`Tag hit: ${scenario.name} -> ${methodMatch}`);
             return {
               name: scenario.name,
               status: "passed",
@@ -2819,20 +2866,20 @@ function executeTestCommand(projectRoot2, config) {
 
 // src/core/verifier/report-generator.ts
 init_logger();
-import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
 import { join as join10, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 
 // src/core/context-engine/context-writer.ts
 init_logger();
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, existsSync as existsSync13, statSync as statSync3, mkdirSync as mkdirSync7 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync14, statSync as statSync3, mkdirSync as mkdirSync7 } from "fs";
 import { join as join13 } from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 
 // src/core/context-engine/graph-builder.ts
 init_logger();
-import { existsSync as existsSync12, readdirSync as readdirSync2, statSync as statSync2, readFileSync as readFileSync8 } from "fs";
-import { join as join11, basename as basename7, extname as extname7, relative as relative2 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync2, statSync as statSync2, readFileSync as readFileSync9 } from "fs";
+import { join as join11, basename as basename8, extname as extname8, relative as relative2 } from "path";
 function detectProjectInfo(projectRoot2) {
   const info = {
     language: "unknown",
@@ -2841,11 +2888,11 @@ function detectProjectInfo(projectRoot2) {
     testFramework: "unknown",
     directoryStructure: ""
   };
-  if (existsSync12(join11(projectRoot2, "package.json"))) {
+  if (existsSync13(join11(projectRoot2, "package.json"))) {
     info.language = "typescript";
     info.buildTool = "npm";
     try {
-      const pkg = JSON.parse(readFileSync8(join11(projectRoot2, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync9(join11(projectRoot2, "package.json"), "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if ("next" in deps) info.framework = "next.js";
       else if ("@nestjs/core" in deps) info.framework = "nestjs";
@@ -2857,33 +2904,33 @@ function detectProjectInfo(projectRoot2) {
     } catch {
       logger.debug("Failed to parse package.json, using default project info");
     }
-  } else if (existsSync12(join11(projectRoot2, "pom.xml"))) {
+  } else if (existsSync13(join11(projectRoot2, "pom.xml"))) {
     info.language = "java";
     info.buildTool = "maven";
     info.testFramework = "junit";
     try {
-      const pom = readFileSync8(join11(projectRoot2, "pom.xml"), "utf-8");
+      const pom = readFileSync9(join11(projectRoot2, "pom.xml"), "utf-8");
       if (pom.includes("spring-boot")) info.framework = "spring-boot";
     } catch {
     }
-  } else if (existsSync12(join11(projectRoot2, "build.gradle")) || existsSync12(join11(projectRoot2, "build.gradle.kts"))) {
+  } else if (existsSync13(join11(projectRoot2, "build.gradle")) || existsSync13(join11(projectRoot2, "build.gradle.kts"))) {
     info.language = "java";
     info.buildTool = "gradle";
     info.testFramework = "junit";
-  } else if (existsSync12(join11(projectRoot2, "go.mod"))) {
+  } else if (existsSync13(join11(projectRoot2, "go.mod"))) {
     info.language = "go";
     info.buildTool = "go";
     info.testFramework = "go-test";
-  } else if (existsSync12(join11(projectRoot2, "Cargo.toml"))) {
+  } else if (existsSync13(join11(projectRoot2, "Cargo.toml"))) {
     info.language = "rust";
     info.buildTool = "cargo";
     info.testFramework = "cargo-test";
-  } else if (existsSync12(join11(projectRoot2, "requirements.txt")) || existsSync12(join11(projectRoot2, "pyproject.toml"))) {
+  } else if (existsSync13(join11(projectRoot2, "requirements.txt")) || existsSync13(join11(projectRoot2, "pyproject.toml"))) {
     info.language = "python";
     info.buildTool = "pip";
     info.testFramework = "pytest";
     try {
-      const reqs = existsSync12(join11(projectRoot2, "requirements.txt")) ? readFileSync8(join11(projectRoot2, "requirements.txt"), "utf-8") : readFileSync8(join11(projectRoot2, "pyproject.toml"), "utf-8");
+      const reqs = existsSync13(join11(projectRoot2, "requirements.txt")) ? readFileSync9(join11(projectRoot2, "requirements.txt"), "utf-8") : readFileSync9(join11(projectRoot2, "pyproject.toml"), "utf-8");
       if (reqs.includes("django")) info.framework = "django";
       else if (reqs.includes("flask")) info.framework = "flask";
       else if (reqs.includes("fastapi")) info.framework = "fastapi";
@@ -2931,7 +2978,7 @@ function buildDependencyGraph(projectRoot2, modules) {
   }
   for (const mod of modules) {
     const modPath = join11(projectRoot2, mod.path);
-    if (!existsSync12(modPath)) continue;
+    if (!existsSync13(modPath)) continue;
     try {
       const imports = scanImports(modPath);
       for (const otherMod of modules) {
@@ -2967,10 +3014,10 @@ function scanImports(dir) {
         walk(fullPath);
         continue;
       }
-      const ext = extname7(entry);
+      const ext = extname8(entry);
       if (![".ts", ".tsx", ".js", ".jsx", ".java", ".py"].includes(ext)) continue;
       try {
-        const content = readFileSync8(fullPath, "utf-8");
+        const content = readFileSync9(fullPath, "utf-8");
         const importRegex = /(?:import\s+.*?from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
         let match;
         while ((match = importRegex.exec(content)) !== null) {
@@ -3003,11 +3050,11 @@ function readDirRecursive(dir) {
 var ANALYZABLE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".java", ".py"]);
 function analyzeFileForEntities(filePath, modName, modPath, modRelativePath) {
   const entities = [];
-  const ext = extname7(filePath);
-  const name = basename7(filePath, ext);
+  const ext = extname8(filePath);
+  const name = basename8(filePath, ext);
   if (!ANALYZABLE_EXTENSIONS.has(ext)) return entities;
   try {
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const relFile = toPosixPath(join11(modRelativePath, relative2(modPath, filePath)));
     if (/(?:Entity|Model|Domain|Schema)$/i.test(name)) {
       entities.push({ name, module: modName, file: relFile });
@@ -3056,11 +3103,11 @@ function analyzeFileForEntities(filePath, modName, modPath, modRelativePath) {
 }
 function analyzeFileForApis(filePath, modName, modPath, modRelativePath) {
   const apis = [];
-  const ext = extname7(filePath);
-  const name = basename7(filePath, ext);
+  const ext = extname8(filePath);
+  const name = basename8(filePath, ext);
   if (!ANALYZABLE_EXTENSIONS.has(ext)) return apis;
   try {
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const relFile = toPosixPath(join11(modRelativePath, relative2(modPath, filePath)));
     if (/Controller|Resource|Handler|Route$/i.test(name)) {
       apis.push({
@@ -3134,7 +3181,7 @@ function extractEntities(projectRoot2, modules) {
   const seen = /* @__PURE__ */ new Set();
   for (const mod of modules) {
     const modPath = join11(projectRoot2, mod.path);
-    if (!existsSync12(modPath)) continue;
+    if (!existsSync13(modPath)) continue;
     try {
       const files = readDirRecursive(modPath);
       for (const file of files) {
@@ -3157,7 +3204,7 @@ function extractApis(projectRoot2, modules) {
   const seen = /* @__PURE__ */ new Set();
   for (const mod of modules) {
     const modPath = join11(projectRoot2, mod.path);
-    if (!existsSync12(modPath)) continue;
+    if (!existsSync13(modPath)) continue;
     try {
       const files = readDirRecursive(modPath);
       for (const file of files) {
@@ -3177,7 +3224,7 @@ function extractApis(projectRoot2, modules) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { join as join12, dirname as dirname3 } from "path";
 function readVersion() {
@@ -3185,7 +3232,7 @@ function readVersion() {
   for (let depth = 0; depth < 4; depth++) {
     try {
       const pkgPath = join12(currentDir, "package.json");
-      const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
       if (typeof pkg.version === "string") return pkg.version;
     } catch {
     }
@@ -3241,7 +3288,7 @@ function buildContext(projectRoot2, config) {
 }
 function loadContext(specLoreDir) {
   const contextPath = join13(specLoreDir, CONTEXT_FILENAME);
-  if (!existsSync13(contextPath)) {
+  if (!existsSync14(contextPath)) {
     logger.debug("No cached context.json found");
     return null;
   }
@@ -3256,7 +3303,7 @@ function loadContext(specLoreDir) {
     return null;
   }
   try {
-    const content = readFileSync10(contextPath, "utf-8");
+    const content = readFileSync11(contextPath, "utf-8");
     const context = JSON.parse(content);
     logger.debug("Loaded cached context.json");
     return context;
@@ -3274,8 +3321,8 @@ function hasGitHeadChanged(specLoreDir) {
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     const headFile = join13(specLoreDir, ".git-head");
-    if (!existsSync13(headFile)) return true;
-    const savedHead = readFileSync10(headFile, "utf-8").trim();
+    if (!existsSync14(headFile)) return true;
+    const savedHead = readFileSync11(headFile, "utf-8").trim();
     if (savedHead !== head) {
       writeFileSync8(headFile, head, "utf-8");
       return true;
@@ -3294,7 +3341,7 @@ function truncateTo(text, maxLines) {
 
 // src/core/analyzer/rdg-builder.ts
 init_logger();
-import { readFileSync as readFileSync11, existsSync as existsSync14, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync15, readdirSync as readdirSync3 } from "fs";
 import { join as join14 } from "path";
 
 // src/core/analyzer/cdg-builder.ts
@@ -3369,7 +3416,7 @@ function determineAffectedFeatures(affectedModules, projectRoot2, outputDir) {
 }
 
 // src/core/state-manager/index.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, existsSync as existsSync15, mkdirSync as mkdirSync8 } from "fs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, existsSync as existsSync16, mkdirSync as mkdirSync8 } from "fs";
 import { join as join15 } from "path";
 import yaml from "js-yaml";
 import { globSync as globSync3 } from "glob";
@@ -3397,11 +3444,11 @@ var StateManager = class {
   }
   /** Load state from disk, or return default if not exists */
   load() {
-    if (!existsSync15(this.statePath)) {
+    if (!existsSync16(this.statePath)) {
       return createDefaultState();
     }
     try {
-      const content = readFileSync12(this.statePath, "utf-8");
+      const content = readFileSync13(this.statePath, "utf-8");
       const parsed = yaml.load(content, { schema: yaml.JSON_SCHEMA });
       if (parsed && typeof parsed === "object") {
         return parsed;
@@ -3413,14 +3460,14 @@ var StateManager = class {
   /** Persist state to disk */
   save(state) {
     const dir = join15(this.projectRoot, ".speclore");
-    if (!existsSync15(dir)) {
+    if (!existsSync16(dir)) {
       mkdirSync8(dir, { recursive: true });
     }
     writeFileSync9(this.statePath, yaml.dump(state, { lineWidth: 120 }), "utf-8");
   }
   /** Ensure state file exists with default values */
   ensureInitialized() {
-    if (!existsSync15(this.statePath)) {
+    if (!existsSync16(this.statePath)) {
       const state2 = createDefaultState();
       this.save(state2);
       return state2;
@@ -3563,19 +3610,19 @@ var StateManager = class {
 };
 
 // src/core/test-scaffolder/index.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, existsSync as existsSync17, mkdirSync as mkdirSync9 } from "fs";
-import { join as join17, relative as relative3, dirname as dirname4, basename as basename8 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync10, existsSync as existsSync18, mkdirSync as mkdirSync9 } from "fs";
+import { join as join17, relative as relative3, dirname as dirname4, basename as basename9 } from "path";
 
 // src/core/test-scaffolder/framework-detector.ts
-import { readFileSync as readFileSync13, existsSync as existsSync16 } from "fs";
+import { readFileSync as readFileSync14, existsSync as existsSync17 } from "fs";
 import { join as join16 } from "path";
 function detectTestFramework(projectRoot2) {
   const pkgPath = join16(projectRoot2, "package.json");
-  if (!existsSync16(pkgPath)) {
+  if (!existsSync17(pkgPath)) {
     return "vitest";
   }
   try {
-    const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     if ("vitest" in deps) return "vitest";
     if ("jest" in deps || "@jest/core" in deps) return "jest";
@@ -3598,7 +3645,7 @@ function generateTestScaffolding(projectRoot2, features, config) {
     }
     const absTestPath = join17(projectRoot2, testFilePath);
     const scenarios = feature.scenarios;
-    if (existsSync17(absTestPath)) {
+    if (existsSync18(absTestPath)) {
       const appended = appendMissingScenarios(absTestPath, scenarios, framework);
       if (appended > 0) {
         results.push({ testFile: testFilePath, framework, scenarios: appended });
@@ -3607,7 +3654,7 @@ function generateTestScaffolding(projectRoot2, features, config) {
     } else {
       const content = generateTestFileContent(feature.featureName, scenarios, framework);
       const dir = dirname4(absTestPath);
-      if (!existsSync17(dir)) {
+      if (!existsSync18(dir)) {
         mkdirSync9(dir, { recursive: true });
       }
       writeFileSync10(absTestPath, content, "utf-8");
@@ -3626,7 +3673,7 @@ function resolveTestFilePath(projectRoot2, featurePath, config) {
       return resolveTestFromPattern(match, pattern);
     }
   }
-  const featureBase = basename8(featurePath, ".feature");
+  const featureBase = basename9(featurePath, ".feature");
   const featureDir = dirname4(relative3(projectRoot2, featurePath));
   return join17(featureDir, `${featureBase}.test.ts`).replace(/\\/g, "/");
 }
@@ -3681,7 +3728,7 @@ function generateTestFileContent(featureName, scenarios, framework) {
   return lines.join("\n");
 }
 function appendMissingScenarios(testFilePath, scenarios, _framework) {
-  const content = readFileSync14(testFilePath, "utf-8");
+  const content = readFileSync15(testFilePath, "utf-8");
   const missing = [];
   for (const scenario of scenarios) {
     if (!content.includes(`Scenario: ${scenario.name}`)) {
@@ -3715,7 +3762,7 @@ function appendMissingScenarios(testFilePath, scenarios, _framework) {
 }
 
 // src/infra/config.ts
-import { readFileSync as readFileSync15, existsSync as existsSync18 } from "fs";
+import { readFileSync as readFileSync16, existsSync as existsSync19 } from "fs";
 import { join as join18 } from "path";
 import { homedir } from "os";
 import yaml2 from "js-yaml";
@@ -3774,11 +3821,11 @@ function loadProjectConfig(projectRoot2) {
   return readYamlIfExists(projectPath);
 }
 function readYamlIfExists(filePath) {
-  if (!existsSync18(filePath)) {
+  if (!existsSync19(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync15(filePath, "utf-8");
+    const content = readFileSync16(filePath, "utf-8");
     const parsed = yaml2.load(content, { schema: yaml2.JSON_SCHEMA });
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -3902,7 +3949,7 @@ verify:
 // src/mcp/tools.ts
 init_logger();
 import { join as join19 } from "path";
-import { readFileSync as readFileSync16, existsSync as existsSync19, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
+import { readFileSync as readFileSync17, existsSync as existsSync20, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
 import { globSync as globSync4 } from "glob";
 import { toJSONSchema } from "zod";
 
@@ -3925,10 +3972,23 @@ var statusInputSchema = z.object({
 });
 
 // src/mcp/tools.ts
-var SPEC_TOOL_DESC = "Convert a requirement (text, file path, or URL) into structured BDD .feature files with scenario-level acceptance criteria.";
-var CODE_TOOL_DESC = "Generate AI coding constraint files for Cursor / Claude Code / Qoder based on .feature specs and project context. Requires .feature files to exist.";
-var VERIFY_TOOL_DESC = "Run tests and map results back to .feature scenarios, producing an acceptance report. Requires test scaffolding generated by speclore.code.";
-var STATUS_TOOL_DESC = "Get current project workflow status, feature states, and recommended next steps. Call this first to understand where the project stands.";
+var SPEC_TOOL_DESC = [
+  "Convert a requirement (text, file path, or URL) into structured BDD .feature files with scenario-level acceptance criteria.",
+  "IMPORTANT: After calling this tool, ALWAYS show the user: (1) the created file path, (2) the list of generated scenarios, (3) the recommended next step."
+].join(" ");
+var CODE_TOOL_DESC = [
+  "Generate AI coding constraint files for Cursor / Claude Code / Qoder based on .feature specs and project context. Requires .feature files to exist.",
+  "IMPORTANT: After calling this tool, ALWAYS show the user: (1) which constraint files were written, (2) test scaffold files generated, (3) the recommended next step."
+].join(" ");
+var VERIFY_TOOL_DESC = [
+  "Run tests and map results back to .feature scenarios, producing an acceptance report. Requires test scaffolding generated by speclore.code.",
+  "IMPORTANT: After calling this tool, ALWAYS show the user: (1) pass/fail summary, (2) any failed scenario details, (3) the recommended next step."
+].join(" ");
+var STATUS_TOOL_DESC = [
+  "Get current project workflow status, feature states, and recommended next steps.",
+  "BEST PRACTICE: Call this tool FIRST when starting a new conversation about the project to understand where it stands.",
+  "ALWAYS show the user the full status including: project state, feature list, and recommended actions."
+].join(" ");
 var specJsonSchema = toJSONSchema(specInputSchema, { target: "draft-07" });
 var codeJsonSchema = toJSONSchema(codeInputSchema, { target: "draft-07" });
 var verifyJsonSchema = toJSONSchema(verifyInputSchema, { target: "draft-07" });
@@ -3936,10 +3996,11 @@ async function executeSpecTool(args, projectRoot2) {
   if (!args.source || args.source.length > 5e4) {
     throw new Error("source must be between 1 and 50000 characters");
   }
+  const sanitizedSource = sanitizeSource(args.source);
   ensureProjectReady(projectRoot2);
   const config = loadConfig(projectRoot2);
-  logger.info(`Reading requirement from: ${args.source.slice(0, 80)}...`);
-  const req = await readRequirement(args.source);
+  logger.info(`Reading requirement from: ${sanitizedSource.slice(0, 120)}`);
+  const req = await readRequirement(sanitizedSource);
   const specLoreDir = join19(projectRoot2, ".speclore");
   const context = loadContext(specLoreDir) ?? buildContext(projectRoot2, config);
   const feature = await generateFeature(req, context, config, projectRoot2);
@@ -4090,10 +4151,10 @@ function ensureProjectReady(projectRoot2) {
   const specLoreDir = join19(projectRoot2, ".speclore");
   const configPath = join19(specLoreDir, "config.yaml");
   let configCreated = false;
-  if (!existsSync19(specLoreDir)) {
+  if (!existsSync20(specLoreDir)) {
     mkdirSync10(specLoreDir, { recursive: true });
   }
-  if (!existsSync19(configPath)) {
+  if (!existsSync20(configPath)) {
     const projectName = projectRoot2.split(/[/\\]/).pop() ?? "my-project";
     writeFileSync11(configPath, generateDefaultConfigYaml(projectName), "utf-8");
     configCreated = true;
@@ -4145,8 +4206,8 @@ function resolveFeatureFiles(patterns, projectRoot2, config) {
   for (const pattern of searchPatterns) {
     const matches = globSync4(pattern, { cwd: projectRoot2, absolute: true });
     for (const filePath of matches) {
-      if (existsSync19(filePath)) {
-        const content = readFileSync16(filePath, "utf-8");
+      if (existsSync20(filePath)) {
+        const content = readFileSync17(filePath, "utf-8");
         files.push(parseFeatureFile(filePath, content));
       }
     }
@@ -4230,29 +4291,30 @@ function buildCodingGuidance(_features, context, config) {
 }
 
 // src/setup/detector.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { join as join20 } from "path";
 function detectAITools2(projectRoot2) {
   const tools = [];
   const cursorFiles = [".cursor/mcp.json", ".cursor/rules"];
-  const cursorConfigs = cursorFiles.filter((f) => existsSync20(join20(projectRoot2, f)));
+  const cursorConfigs = cursorFiles.filter((f) => existsSync21(join20(projectRoot2, f)));
   tools.push({
     tool: "cursor",
-    detected: existsSync20(join20(projectRoot2, ".cursor")),
+    detected: existsSync21(join20(projectRoot2, ".cursor")),
     configFiles: cursorConfigs
   });
   const claudeFiles = [".claude/", "CLAUDE.md"];
-  const claudeConfigs = claudeFiles.filter((f) => existsSync20(join20(projectRoot2, f)));
+  const claudeConfigs = claudeFiles.filter((f) => existsSync21(join20(projectRoot2, f)));
   tools.push({
     tool: "claude",
     detected: claudeConfigs.length > 0,
     configFiles: claudeConfigs
   });
-  const qoderFiles = [".qoder/mcp.json", ".qoder/rules"];
-  const qoderConfigs = qoderFiles.filter((f) => existsSync20(join20(projectRoot2, f)));
+  const qoderDir = hasQoderDir(projectRoot2) ? existsSync21(join20(projectRoot2, ".qoder-cn")) ? ".qoder-cn" : ".qoder" : ".qoder";
+  const qoderFiles = [`${qoderDir}/mcp.json`, `${qoderDir}/rules`];
+  const qoderConfigs = qoderFiles.filter((f) => existsSync21(join20(projectRoot2, f)));
   tools.push({
     tool: "qoder",
-    detected: existsSync20(join20(projectRoot2, ".qoder")),
+    detected: hasQoderDir(projectRoot2),
     configFiles: qoderConfigs
   });
   return tools.filter((t) => t.detected);
@@ -4260,7 +4322,7 @@ function detectAITools2(projectRoot2) {
 
 // src/mcp/status.ts
 init_logger();
-import { readFileSync as readFileSync17, existsSync as existsSync21, mkdirSync as mkdirSync11, writeFileSync as writeFileSync12 } from "fs";
+import { readFileSync as readFileSync18, existsSync as existsSync22, mkdirSync as mkdirSync11, writeFileSync as writeFileSync12 } from "fs";
 import { join as join21 } from "path";
 import { globSync as globSync5 } from "glob";
 function executeStatusTool(args, projectRoot2) {
@@ -4277,9 +4339,9 @@ function executeStatusTool(args, projectRoot2) {
       continue;
     }
     let scenarioCount = 0;
-    if (existsSync21(path)) {
+    if (existsSync22(path)) {
       try {
-        const content = readFileSync17(path, "utf-8");
+        const content = readFileSync18(path, "utf-8");
         const matches = content.match(/Scenario(?: Outline)?:/g);
         scenarioCount = matches?.length ?? 0;
       } catch {
@@ -4302,7 +4364,7 @@ function executeStatusTool(args, projectRoot2) {
     if (args.feature && !filePath.includes(args.feature)) continue;
     let scenarioCount = 0;
     try {
-      const content = readFileSync17(filePath, "utf-8");
+      const content = readFileSync18(filePath, "utf-8");
       const matches = content.match(/Scenario(?: Outline)?:/g);
       scenarioCount = matches?.length ?? 0;
     } catch {
@@ -4362,10 +4424,10 @@ function ensureProjectReadyForStatus(projectRoot2) {
   const specLoreDir = join21(projectRoot2, ".speclore");
   const configPath = join21(specLoreDir, "config.yaml");
   let configCreated = false;
-  if (!existsSync21(specLoreDir)) {
+  if (!existsSync22(specLoreDir)) {
     mkdirSync11(specLoreDir, { recursive: true });
   }
-  if (!existsSync21(configPath)) {
+  if (!existsSync22(configPath)) {
     const projectName = projectRoot2.split(/[/\\]/).pop() ?? "my-project";
     writeFileSync12(configPath, generateDefaultConfigYaml(projectName), "utf-8");
     configCreated = true;
@@ -4402,7 +4464,11 @@ server.registerTool(
       { source: args.source, module: args.module },
       getProjectRoot()
     );
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    const summary = buildSpecSummary(result);
+    return { content: [{ type: "text", text: `${summary}
+
+---
+${JSON.stringify(result, null, 2)}` }] };
   }
 );
 server.registerTool(
@@ -4419,7 +4485,11 @@ server.registerTool(
       { features: args.features, tools: args.tools },
       getProjectRoot()
     );
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    const summary = buildCodeSummary(result);
+    return { content: [{ type: "text", text: `${summary}
+
+---
+${JSON.stringify(result, null, 2)}` }] };
   }
 );
 server.registerTool(
@@ -4433,7 +4503,11 @@ server.registerTool(
       { features: args.features, impact: args.impact },
       getProjectRoot()
     );
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    const summary = buildVerifySummary(result);
+    return { content: [{ type: "text", text: `${summary}
+
+---
+${JSON.stringify(result, null, 2)}` }] };
   }
 );
 server.registerTool(
@@ -4447,7 +4521,11 @@ server.registerTool(
       { feature: args.feature },
       getProjectRoot()
     );
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    const summary = buildStatusSummary(result);
+    return { content: [{ type: "text", text: `${summary}
+
+---
+${JSON.stringify(result, null, 2)}` }] };
   }
 );
 var projectRoot = process.env.SPECLORE_PROJECT_ROOT ?? process.cwd();
@@ -4461,10 +4539,10 @@ async function startMcpServer() {
     mkdirSync12(specLoreDir, { recursive: true });
     const locked = acquireLock(specLoreDir);
     if (!locked) {
-      logger.warn("Could not acquire lock \u2014 another SpecLore instance may be running.");
+      logger.warn("Could not acquire lock - another SpecLore instance may be running.");
     }
   } catch {
-    logger.warn("Could not acquire lock \u2014 .speclore/ directory may not exist.");
+    logger.warn("Could not acquire lock - .speclore/ directory may not exist.");
   }
   const transport = new StdioServerTransport();
   await server.connect(transport);
@@ -4484,6 +4562,58 @@ async function startMcpServer() {
     process.exit(0);
   });
 }
+function buildSpecSummary(result) {
+  const lines = [];
+  lines.push("[SpecLore] Feature file generated successfully.");
+  lines.push(`  File: ${result.createdFiles.join(", ")}`);
+  lines.push(`  Scenarios: ${result.scenarios.length}`);
+  for (const sc of result.scenarios) {
+    lines.push(`    - ${sc.name}`);
+  }
+  lines.push(`  Next step: ${result.nextSteps}`);
+  return lines.join("\n");
+}
+function buildCodeSummary(result) {
+  const lines = [];
+  lines.push("[SpecLore] Constraints and test scaffolding generated.");
+  lines.push(`  Constraint files: ${result.writtenFiles.length > 0 ? result.writtenFiles.join(", ") : "none"}`);
+  lines.push(`  Test scaffold files: ${result.scaffoldFiles.length > 0 ? result.scaffoldFiles.map((s) => s.testFile).join(", ") : "none"}`);
+  lines.push(`  Next step: ${result.workflow.nextStep}`);
+  return lines.join("\n");
+}
+function buildVerifySummary(result) {
+  const lines = [];
+  const icon = result.failed === 0 ? "[PASS]" : "[FAIL]";
+  lines.push(`[SpecLore] Verification ${icon} ${result.summary}`);
+  if (result.failed > 0) {
+    lines.push(`  Failed: ${result.failed} scenario(s)`);
+    for (const d of result.failedDetails) {
+      lines.push(`    - ${d.feature} > ${d.scenario}: ${d.error}`);
+    }
+  }
+  if (result.unmapped > 0) {
+    lines.push(`  Unmapped: ${result.unmapped} scenario(s) without test mapping`);
+  }
+  lines.push(`  Next step: ${result.workflow.nextStep}`);
+  return lines.join("\n");
+}
+function buildStatusSummary(result) {
+  const lines = [];
+  lines.push(`[SpecLore] Project status: ${result.project.initialized ? "initialized" : "not initialized"}`);
+  lines.push(`  AI tools detected: ${result.project.aiToolsDetected.length > 0 ? result.project.aiToolsDetected.join(", ") : "none"}`);
+  lines.push(`  Features: ${result.summary.total} total`);
+  if (result.summary.specified > 0) lines.push(`    - ${result.summary.specified} specified`);
+  if (result.summary.constrained > 0) lines.push(`    - ${result.summary.constrained} constrained`);
+  if (result.summary.coding > 0) lines.push(`    - ${result.summary.coding} coding`);
+  if (result.summary.verified > 0) lines.push(`    - ${result.summary.verified} verified`);
+  if (result.recommendedActions.length > 0) {
+    lines.push("  Recommended actions:");
+    for (const action of result.recommendedActions) {
+      lines.push(`    -> ${action}`);
+    }
+  }
+  return lines.join("\n");
+}
 
 // src/bin/mcp.ts
 startMcpServer().catch((err) => {