speclore 0.1.8 → 0.1.10

package/dist/index.js

@@ -306,30 +306,51 @@ var init_config2 = __esm({
   }
 });
 
-// src/setup/detector.ts
+// src/infra/path-utils.ts
+import { posix, sep, relative, resolve, isAbsolute, join as join2 } from "path";
 import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { glob, globSync } from "glob";
+function toPosixPath(p) {
+  return p.split(/[/\\]/).join(posix.sep);
+}
+function resolveQoderDir(projectRoot2) {
+  if (existsSync2(join2(projectRoot2, ".qoder-cn"))) return ".qoder-cn";
+  return ".qoder";
+}
+function hasQoderDir(projectRoot2) {
+  return existsSync2(join2(projectRoot2, ".qoder")) || existsSync2(join2(projectRoot2, ".qoder-cn"));
+}
+var init_path_utils = __esm({
+  "src/infra/path-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/setup/detector.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
 function detectAITools(projectRoot2) {
   const tools = [];
   const cursorFiles = [".cursor/mcp.json", ".cursor/rules"];
-  const cursorConfigs = cursorFiles.filter((f) => existsSync2(join2(projectRoot2, f)));
+  const cursorConfigs = cursorFiles.filter((f) => existsSync3(join3(projectRoot2, f)));
   tools.push({
     tool: "cursor",
-    detected: existsSync2(join2(projectRoot2, ".cursor")),
+    detected: existsSync3(join3(projectRoot2, ".cursor")),
     configFiles: cursorConfigs
   });
   const claudeFiles = [".claude/", "CLAUDE.md"];
-  const claudeConfigs = claudeFiles.filter((f) => existsSync2(join2(projectRoot2, f)));
+  const claudeConfigs = claudeFiles.filter((f) => existsSync3(join3(projectRoot2, f)));
   tools.push({
     tool: "claude",
     detected: claudeConfigs.length > 0,
     configFiles: claudeConfigs
   });
-  const qoderFiles = [".qoder/mcp.json", ".qoder/rules"];
-  const qoderConfigs = qoderFiles.filter((f) => existsSync2(join2(projectRoot2, f)));
+  const qoderDir = hasQoderDir(projectRoot2) ? existsSync3(join3(projectRoot2, ".qoder-cn")) ? ".qoder-cn" : ".qoder" : ".qoder";
+  const qoderFiles = [`${qoderDir}/mcp.json`, `${qoderDir}/rules`];
+  const qoderConfigs = qoderFiles.filter((f) => existsSync3(join3(projectRoot2, f)));
   tools.push({
     tool: "qoder",
-    detected: existsSync2(join2(projectRoot2, ".qoder")),
+    detected: hasQoderDir(projectRoot2),
     configFiles: qoderConfigs
   });
   return tools.filter((t) => t.detected);
@@ -337,23 +358,24 @@ function detectAITools(projectRoot2) {
 var init_detector = __esm({
   "src/setup/detector.ts"() {
     "use strict";
+    init_path_utils();
   }
 });
 
 // src/version.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath } from "url";
-import { join as join3, dirname } from "path";
+import { join as join4, dirname } from "path";
 function readVersion() {
   let currentDir = dirname(fileURLToPath(import.meta.url));
   for (let depth = 0; depth < 4; depth++) {
     try {
-      const pkgPath = join3(currentDir, "package.json");
+      const pkgPath = join4(currentDir, "package.json");
       const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
       if (typeof pkg.version === "string") return pkg.version;
     } catch {
     }
-    currentDir = join3(currentDir, "..");
+    currentDir = join4(currentDir, "..");
   }
   return "0.0.0";
 }
@@ -369,7 +391,7 @@ var init_version = __esm({
 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,
@@ -387,20 +409,8 @@ var init_config_reader = __esm({
   }
 });
 
-// src/infra/path-utils.ts
-import { posix, sep, relative, resolve, isAbsolute, join as join8 } from "path";
-import { glob, globSync } from "glob";
-function toPosixPath(p) {
-  return p.split(/[/\\]/).join(posix.sep);
-}
-var init_path_utils = __esm({
-  "src/infra/path-utils.ts"() {
-    "use strict";
-  }
-});
-
 // src/core/context-engine/graph-builder.ts
-import { existsSync as existsSync6, readdirSync, statSync, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync7, readdirSync, statSync, readFileSync as readFileSync5 } from "fs";
 import { join as join9, basename, extname, relative as relative2 } from "path";
 function detectProjectInfo(projectRoot2) {
   const info = {
@@ -410,7 +420,7 @@ function detectProjectInfo(projectRoot2) {
     testFramework: "unknown",
     directoryStructure: ""
   };
-  if (existsSync6(join9(projectRoot2, "package.json"))) {
+  if (existsSync7(join9(projectRoot2, "package.json"))) {
     info.language = "typescript";
     info.buildTool = "npm";
     try {
@@ -426,7 +436,7 @@ function detectProjectInfo(projectRoot2) {
     } catch {
       logger.debug("Failed to parse package.json, using default project info");
     }
-  } else if (existsSync6(join9(projectRoot2, "pom.xml"))) {
+  } else if (existsSync7(join9(projectRoot2, "pom.xml"))) {
     info.language = "java";
     info.buildTool = "maven";
     info.testFramework = "junit";
@@ -435,24 +445,24 @@ function detectProjectInfo(projectRoot2) {
       if (pom.includes("spring-boot")) info.framework = "spring-boot";
     } catch {
     }
-  } else if (existsSync6(join9(projectRoot2, "build.gradle")) || existsSync6(join9(projectRoot2, "build.gradle.kts"))) {
+  } else if (existsSync7(join9(projectRoot2, "build.gradle")) || existsSync7(join9(projectRoot2, "build.gradle.kts"))) {
     info.language = "java";
     info.buildTool = "gradle";
     info.testFramework = "junit";
-  } else if (existsSync6(join9(projectRoot2, "go.mod"))) {
+  } else if (existsSync7(join9(projectRoot2, "go.mod"))) {
     info.language = "go";
     info.buildTool = "go";
     info.testFramework = "go-test";
-  } else if (existsSync6(join9(projectRoot2, "Cargo.toml"))) {
+  } else if (existsSync7(join9(projectRoot2, "Cargo.toml"))) {
     info.language = "rust";
     info.buildTool = "cargo";
     info.testFramework = "cargo-test";
-  } else if (existsSync6(join9(projectRoot2, "requirements.txt")) || existsSync6(join9(projectRoot2, "pyproject.toml"))) {
+  } else if (existsSync7(join9(projectRoot2, "requirements.txt")) || existsSync7(join9(projectRoot2, "pyproject.toml"))) {
     info.language = "python";
     info.buildTool = "pip";
     info.testFramework = "pytest";
     try {
-      const reqs = existsSync6(join9(projectRoot2, "requirements.txt")) ? readFileSync5(join9(projectRoot2, "requirements.txt"), "utf-8") : readFileSync5(join9(projectRoot2, "pyproject.toml"), "utf-8");
+      const reqs = existsSync7(join9(projectRoot2, "requirements.txt")) ? readFileSync5(join9(projectRoot2, "requirements.txt"), "utf-8") : readFileSync5(join9(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";
@@ -500,7 +510,7 @@ function buildDependencyGraph(projectRoot2, modules) {
   }
   for (const mod of modules) {
     const modPath = join9(projectRoot2, mod.path);
-    if (!existsSync6(modPath)) continue;
+    if (!existsSync7(modPath)) continue;
     try {
       const imports = scanImports(modPath);
       for (const otherMod of modules) {
@@ -702,7 +712,7 @@ function extractEntities(projectRoot2, modules) {
   const seen = /* @__PURE__ */ new Set();
   for (const mod of modules) {
     const modPath = join9(projectRoot2, mod.path);
-    if (!existsSync6(modPath)) continue;
+    if (!existsSync7(modPath)) continue;
     try {
       const files = readDirRecursive(modPath);
       for (const file of files) {
@@ -725,7 +735,7 @@ function extractApis(projectRoot2, modules) {
   const seen = /* @__PURE__ */ new Set();
   for (const mod of modules) {
     const modPath = join9(projectRoot2, mod.path);
-    if (!existsSync6(modPath)) continue;
+    if (!existsSync7(modPath)) continue;
     try {
       const files = readDirRecursive(modPath);
       for (const file of files) {
@@ -754,7 +764,7 @@ var init_graph_builder = __esm({
 });
 
 // src/core/context-engine/context-writer.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync7, statSync as statSync2, mkdirSync as mkdirSync5 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync8, statSync as statSync2, mkdirSync as mkdirSync5 } from "fs";
 import { join as join10 } from "path";
 import { execFileSync } from "child_process";
 function buildContext(projectRoot2, config) {
@@ -799,7 +809,7 @@ function buildContext(projectRoot2, config) {
 }
 function loadContext(specLoreDir) {
   const contextPath = join10(specLoreDir, CONTEXT_FILENAME);
-  if (!existsSync7(contextPath)) {
+  if (!existsSync8(contextPath)) {
     logger.debug("No cached context.json found");
     return null;
   }
@@ -824,7 +834,7 @@ function loadContext(specLoreDir) {
   }
 }
 function writeContextFile(specLoreDir, context) {
-  if (!existsSync7(specLoreDir)) {
+  if (!existsSync8(specLoreDir)) {
     mkdirSync5(specLoreDir, { recursive: true });
   }
   const contextPath = join10(specLoreDir, CONTEXT_FILENAME);
@@ -847,7 +857,7 @@ function hasGitHeadChanged(specLoreDir) {
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     const headFile = join10(specLoreDir, ".git-head");
-    if (!existsSync7(headFile)) return true;
+    if (!existsSync8(headFile)) return true;
     const savedHead = readFileSync6(headFile, "utf-8").trim();
     if (savedHead !== head) {
       writeFileSync5(headFile, head, "utf-8");
@@ -949,7 +959,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;
       }
       /**
@@ -1016,7 +1026,7 @@ var init_cost_tracker = __esm({
 });
 
 // src/core/state-manager/index.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync6 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
 import { join as join12 } from "path";
 import yaml2 from "js-yaml";
 import { globSync as globSync2 } from "glob";
@@ -1048,7 +1058,7 @@ var init_state_manager = __esm({
       }
       /** Load state from disk, or return default if not exists */
       load() {
-        if (!existsSync8(this.statePath)) {
+        if (!existsSync9(this.statePath)) {
           return createDefaultState();
         }
         try {
@@ -1064,14 +1074,14 @@ var init_state_manager = __esm({
       /** Persist state to disk */
       save(state) {
         const dir = join12(this.projectRoot, ".speclore");
-        if (!existsSync8(dir)) {
+        if (!existsSync9(dir)) {
           mkdirSync6(dir, { recursive: true });
         }
         writeFileSync6(this.statePath, yaml2.dump(state, { lineWidth: 120 }), "utf-8");
       }
       /** Ensure state file exists with default values */
       ensureInitialized() {
-        if (!existsSync8(this.statePath)) {
+        if (!existsSync9(this.statePath)) {
           const state2 = createDefaultState();
           this.save(state2);
           return state2;
@@ -1220,7 +1230,7 @@ var status_exports = {};
 __export(status_exports, {
   registerStatusCommand: () => registerStatusCommand
 });
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { join as join13 } from "path";
 import { globSync as globSync3 } from "glob";
 function registerStatusCommand(program) {
@@ -1233,7 +1243,7 @@ function registerStatusCommand(program) {
     console.log("");
     const config = loadConfig(projectRoot2);
     const configPath = join13(projectRoot2, ".speclore", "config.yaml");
-    if (existsSync9(configPath)) {
+    if (existsSync10(configPath)) {
       console.log(`\u2713 Config: ${configPath}`);
       console.log(`  Project: ${config.project.name || "(unnamed)"}`);
       console.log(`  Profile: ${config.project.profile}`);
@@ -1242,13 +1252,13 @@ function registerStatusCommand(program) {
       console.log("\u2717 Config not found. Run `speclore setup` first.");
     }
     const contextPath = join13(projectRoot2, ".speclore", "context.json");
-    if (existsSync9(contextPath)) {
+    if (existsSync10(contextPath)) {
       console.log(`\u2713 Context: ${contextPath}`);
     } else {
       console.log("\u2717 Context not found. Run `speclore init` first.");
     }
     const specsDir = join13(projectRoot2, config.spec.outputDir);
-    if (existsSync9(specsDir)) {
+    if (existsSync10(specsDir)) {
       const features = globSync3("**/*.feature", { cwd: specsDir });
       console.log(`\u2713 Features: ${features.length} file(s) in ${config.spec.outputDir}/`);
     } else {
@@ -1329,7 +1339,7 @@ var init_status = __esm({
 });
 
 // src/plugins/builtin/md-reader.ts
-import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync11 } from "fs";
 var MarkdownReader;
 var init_md_reader = __esm({
   "src/plugins/builtin/md-reader.ts"() {
@@ -1341,7 +1351,7 @@ var init_md_reader = __esm({
         return /\.md$/i.test(source) || /\.markdown$/i.test(source);
       }
       read(source) {
-        if (!existsSync10(source)) {
+        if (!existsSync11(source)) {
           throw new Error(`File not found: ${source}`);
         }
         const content = readFileSync8(source, "utf-8");
@@ -1496,8 +1506,8 @@ var init_pdf_reader = __esm({
         } catch {
           throw new Error("pdfjs-dist package is required for PDF support. Install: npm i pdfjs-dist");
         }
-        const { readFileSync: readFileSync24 } = await import("fs");
-        const buffer = readFileSync24(source);
+        const { readFileSync: readFileSync25 } = await import("fs");
+        const buffer = readFileSync25(source);
         const uint8 = new Uint8Array(buffer);
         const doc = await pdfjsLib.getDocument({
           data: uint8,
@@ -2112,13 +2122,13 @@ var init_image_reader = __esm({
         return /\.(png|jpe?g|webp)$/i.test(source);
       }
       async read(source) {
-        const { existsSync: existsSync31, readFileSync: readFileSync24 } = await import("fs");
-        if (!existsSync31(source)) {
+        const { existsSync: existsSync32, readFileSync: readFileSync25 } = await import("fs");
+        if (!existsSync32(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 = readFileSync24(source);
+        const buffer = readFileSync25(source);
         let text;
         try {
           const { createProvider: createProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
@@ -2147,7 +2157,7 @@ var init_image_reader = __esm({
 });
 
 // src/plugins/builtin/cursor-writer.ts
-import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, existsSync as existsSync11, rmSync } from "fs";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, existsSync as existsSync12, rmSync } from "fs";
 import { join as join14 } from "path";
 var CursorWriter;
 var init_cursor_writer = __esm({
@@ -2158,7 +2168,7 @@ var init_cursor_writer = __esm({
       configFile = ".cursor/rules/speclore.mdc";
       projectRoot = "";
       detect(projectRoot2) {
-        return existsSync11(join14(projectRoot2, ".cursor"));
+        return existsSync12(join14(projectRoot2, ".cursor"));
       }
       write(constraints) {
         this.projectRoot = constraints.projectRoot;
@@ -2178,7 +2188,7 @@ var init_cursor_writer = __esm({
       }
       remove() {
         const filePath = join14(this.projectRoot, ".cursor", "rules", "speclore.mdc");
-        if (existsSync11(filePath)) rmSync(filePath);
+        if (existsSync12(filePath)) rmSync(filePath);
         return Promise.resolve();
       }
       buildMarkdown(c) {
@@ -2242,7 +2252,7 @@ var init_cursor_writer = __esm({
 });
 
 // src/plugins/builtin/claude-writer.ts
-import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, existsSync as existsSync12, rmSync as rmSync2 } from "fs";
+import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, existsSync as existsSync13, rmSync as rmSync2 } from "fs";
 import { join as join15 } from "path";
 var ClaudeWriter;
 var init_claude_writer = __esm({
@@ -2253,7 +2263,7 @@ var init_claude_writer = __esm({
       configFile = ".claude/rules/speclore.md";
       projectRoot = "";
       detect(projectRoot2) {
-        return existsSync12(join15(projectRoot2, ".claude")) || existsSync12(join15(projectRoot2, ".mcp.json"));
+        return existsSync13(join15(projectRoot2, ".claude")) || existsSync13(join15(projectRoot2, ".mcp.json"));
       }
       write(constraints) {
         this.projectRoot = constraints.projectRoot;
@@ -2265,7 +2275,7 @@ var init_claude_writer = __esm({
       }
       remove() {
         const filePath = join15(this.projectRoot, ".claude", "rules", "speclore.md");
-        if (existsSync12(filePath)) rmSync2(filePath);
+        if (existsSync13(filePath)) rmSync2(filePath);
         return Promise.resolve();
       }
       buildMarkdown(c) {
@@ -2324,30 +2334,33 @@ var init_claude_writer = __esm({
 });
 
 // src/plugins/builtin/qoder-writer.ts
-import { writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, existsSync as existsSync13, rmSync as rmSync3 } from "fs";
+import { writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, existsSync as existsSync14, rmSync as rmSync3 } from "fs";
 import { join as join16 } from "path";
 var QoderWriter;
 var init_qoder_writer = __esm({
   "src/plugins/builtin/qoder-writer.ts"() {
     "use strict";
+    init_path_utils();
     QoderWriter = class {
       toolName = "qoder";
       configFile = ".qoder/rules/speclore.md";
       projectRoot = "";
       detect(projectRoot2) {
-        return existsSync13(join16(projectRoot2, ".qoder"));
+        return existsSync14(join16(projectRoot2, ".qoder")) || existsSync14(join16(projectRoot2, ".qoder-cn"));
       }
       write(constraints) {
         this.projectRoot = constraints.projectRoot;
-        const rulesDir = join16(constraints.projectRoot, ".qoder", "rules");
+        const qoderDir = resolveQoderDir(constraints.projectRoot);
+        const rulesDir = join16(constraints.projectRoot, qoderDir, "rules");
         mkdirSync9(rulesDir, { recursive: true });
         const content = this.buildMarkdown(constraints);
         writeFileSync9(join16(rulesDir, "speclore.md"), content, "utf-8");
         return Promise.resolve();
       }
       remove() {
-        const filePath = join16(this.projectRoot, ".qoder", "rules", "speclore.md");
-        if (existsSync13(filePath)) rmSync3(filePath);
+        const qoderDir = resolveQoderDir(this.projectRoot);
+        const filePath = join16(this.projectRoot, qoderDir, "rules", "speclore.md");
+        if (existsSync14(filePath)) rmSync3(filePath);
         return Promise.resolve();
       }
       buildMarkdown(c) {
@@ -2941,8 +2954,34 @@ var init_image_reader2 = __esm({
   }
 });
 
+// src/core/requirement-reader/text-reader.ts
+import { readFileSync as readFileSync12 } from "fs";
+import { basename as basename7, extname as extname7 } from "path";
+function readTextFile(filePath) {
+  const content = readFileSync12(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) ?? basename7(filePath, extname7(filePath));
+  return Promise.resolve({
+    id,
+    title,
+    description: content,
+    rawContent: content,
+    confidence: 1
+  });
+}
+function deriveId2(filePath) {
+  const name = basename7(filePath, extname7(filePath));
+  return name.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-");
+}
+var init_text_reader = __esm({
+  "src/core/requirement-reader/text-reader.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/requirement-reader/url-reader.ts
-import { basename as basename7 } from "path";
+import { basename as basename8 } from "path";
 async function readUrl(url) {
   validateUrl(url);
   logger.info(`Fetching URL: ${url}`);
@@ -2980,7 +3019,7 @@ async function readUrl(url) {
       content = content.slice(0, MAX_CONTENT_LENGTH) + "\n... (truncated)";
     }
     const urlPath = new URL(url).pathname;
-    const id = basename7(urlPath).toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-") || "url-content";
+    const id = basename8(urlPath).toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-") || "url-content";
     return {
       id,
       title,
@@ -3039,34 +3078,48 @@ var init_url_reader = __esm({
 // src/core/requirement-reader/index.ts
 var requirement_reader_exports = {};
 __export(requirement_reader_exports, {
-  readRequirement: () => readRequirement
+  readRequirement: () => readRequirement,
+  sanitizeSource: () => sanitizeSource
 });
-import { existsSync as existsSync14 } from "fs";
-import { extname as extname7 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { extname as extname8 } from "path";
+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 = extname7(source).toLowerCase();
-  const supportedExts = [".md", ".docx", ".xlsx", ".xls", ".pdf", ".png", ".jpg", ".jpeg", ".webp"];
-  if (supportedExts.includes(ext) && existsSync14(source)) {
+  const ext = extname8(source).toLowerCase();
+  const supportedExts = [".md", ".txt", ".docx", ".xlsx", ".xls", ".pdf", ".png", ".jpg", ".jpeg", ".webp"];
+  if (supportedExts.includes(ext) && existsSync15(source)) {
     return "file";
   }
-  if (existsSync14(source) && (source.includes("/") || source.includes("\\"))) {
+  if (existsSync15(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) {
@@ -3080,10 +3133,12 @@ async function readFromFile(filePath) {
     }
     return results[0];
   }
-  const ext = extname7(filePath).toLowerCase();
+  const ext = extname8(filePath).toLowerCase();
   switch (ext) {
     case ".md":
       return readMarkdownFile(filePath);
+    case ".txt":
+      return readTextFile(filePath);
     case ".docx":
       return readDocxFile(filePath);
     case ".xlsx":
@@ -3126,6 +3181,7 @@ var init_requirement_reader = __esm({
     init_xlsx_reader2();
     init_pdf_reader2();
     init_image_reader2();
+    init_text_reader();
     init_url_reader();
   }
 });
@@ -3356,7 +3412,7 @@ var init_prompt_builder = __esm({
 });
 
 // src/core/feature-generator/generator.ts
-import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync10, existsSync as existsSync15 } from "fs";
+import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync10, existsSync as existsSync16 } from "fs";
 import { join as join17, dirname as dirname2 } from "path";
 import { Parser as Parser2, GherkinClassicTokenMatcher as GherkinClassicTokenMatcher2, AstBuilder as AstBuilder2 } from "@cucumber/gherkin";
 import { IdGenerator as IdGenerator2 } from "@cucumber/messages";
@@ -3424,7 +3480,7 @@ Please fix these issues and regenerate the complete Feature file.`;
   const outputDir = join17(projectRoot2, config.spec.outputDir);
   const moduleDir = inferModule(requirement, context);
   const filePath = join17(outputDir, moduleDir, `${requirement.id}.feature`);
-  if (!existsSync15(dirname2(filePath))) {
+  if (!existsSync16(dirname2(filePath))) {
     mkdirSync10(dirname2(filePath), { recursive: true });
   }
   writeFileSync10(filePath, featureContent, "utf-8");
@@ -3583,21 +3639,21 @@ var init_feature_generator = __esm({
 });
 
 // src/core/constraint-coder/ai-tool-detector.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { join as join19 } from "path";
 function detectAITools2(projectRoot2) {
   const tools = [];
-  if (existsSync16(join19(projectRoot2, ".cursor"))) {
+  if (existsSync17(join19(projectRoot2, ".cursor"))) {
     tools.push("cursor");
     logger.debug("Detected Cursor (.cursor/)");
   }
-  if (existsSync16(join19(projectRoot2, ".claude")) || existsSync16(join19(projectRoot2, "CLAUDE.md"))) {
+  if (existsSync17(join19(projectRoot2, ".claude")) || existsSync17(join19(projectRoot2, "CLAUDE.md"))) {
     tools.push("claude");
     logger.debug("Detected Claude Code (.claude/ or CLAUDE.md)");
   }
-  if (existsSync16(join19(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;
@@ -3606,11 +3662,12 @@ var init_ai_tool_detector = __esm({
   "src/core/constraint-coder/ai-tool-detector.ts"() {
     "use strict";
     init_logger();
+    init_path_utils();
   }
 });
 
 // src/core/constraint-coder/constraint-writer.ts
-import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync11, existsSync as existsSync17 } from "fs";
+import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync11, existsSync as existsSync18 } from "fs";
 import { join as join20 } from "path";
 function writeConstraints(projectRoot2, tools, content) {
   const writtenFiles = [];
@@ -3684,7 +3741,7 @@ function buildConstraintText(content) {
 }
 function writeCursorRule2(projectRoot2, text) {
   const dir = join20(projectRoot2, ".cursor", "rules");
-  if (!existsSync17(dir)) mkdirSync11(dir, { recursive: true });
+  if (!existsSync18(dir)) mkdirSync11(dir, { recursive: true });
   const filePath = join20(dir, "speclore.mdc");
   const frontmatter = [
     "---",
@@ -3699,14 +3756,15 @@ function writeCursorRule2(projectRoot2, text) {
 }
 function writeClaudeRule2(projectRoot2, text) {
   const dir = join20(projectRoot2, ".claude", "rules");
-  if (!existsSync17(dir)) mkdirSync11(dir, { recursive: true });
+  if (!existsSync18(dir)) mkdirSync11(dir, { recursive: true });
   const filePath = join20(dir, "speclore.md");
   writeFileSync11(filePath, text, "utf-8");
   return filePath;
 }
 function writeQoderRule2(projectRoot2, text) {
-  const dir = join20(projectRoot2, ".qoder", "rules");
-  if (!existsSync17(dir)) mkdirSync11(dir, { recursive: true });
+  const qoderDir = resolveQoderDir(projectRoot2);
+  const dir = join20(projectRoot2, qoderDir, "rules");
+  if (!existsSync18(dir)) mkdirSync11(dir, { recursive: true });
   const filePath = join20(dir, "speclore.md");
   writeFileSync11(filePath, text, "utf-8");
   return filePath;
@@ -3764,7 +3822,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)}`);
       }
@@ -3793,15 +3851,15 @@ Keep mapping files in sync whenever tests are modified.`;
 });
 
 // src/core/test-scaffolder/framework-detector.ts
-import { readFileSync as readFileSync12, existsSync as existsSync18 } from "fs";
+import { readFileSync as readFileSync13, existsSync as existsSync19 } from "fs";
 import { join as join21 } from "path";
 function detectTestFramework(projectRoot2) {
   const pkgPath = join21(projectRoot2, "package.json");
-  if (!existsSync18(pkgPath)) {
+  if (!existsSync19(pkgPath)) {
     return "vitest";
   }
   try {
-    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync13(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";
@@ -3817,8 +3875,8 @@ var init_framework_detector = __esm({
 });
 
 // src/core/test-scaffolder/index.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync12, existsSync as existsSync19, mkdirSync as mkdirSync12 } from "fs";
-import { join as join22, relative as relative3, dirname as dirname3, basename as basename8 } from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync12, existsSync as existsSync20, mkdirSync as mkdirSync12 } from "fs";
+import { join as join22, relative as relative3, dirname as dirname3, basename as basename9 } from "path";
 function generateTestScaffolding(projectRoot2, features, config) {
   const framework = detectTestFramework(projectRoot2);
   const results = [];
@@ -3830,7 +3888,7 @@ function generateTestScaffolding(projectRoot2, features, config) {
     }
     const absTestPath = join22(projectRoot2, testFilePath);
     const scenarios = feature.scenarios;
-    if (existsSync19(absTestPath)) {
+    if (existsSync20(absTestPath)) {
       const appended = appendMissingScenarios(absTestPath, scenarios, framework);
       if (appended > 0) {
         results.push({ testFile: testFilePath, framework, scenarios: appended });
@@ -3839,7 +3897,7 @@ function generateTestScaffolding(projectRoot2, features, config) {
     } else {
       const content = generateTestFileContent(feature.featureName, scenarios, framework);
       const dir = dirname3(absTestPath);
-      if (!existsSync19(dir)) {
+      if (!existsSync20(dir)) {
         mkdirSync12(dir, { recursive: true });
       }
       writeFileSync12(absTestPath, content, "utf-8");
@@ -3858,7 +3916,7 @@ function resolveTestFilePath(projectRoot2, featurePath, config) {
       return resolveTestFromPattern(match, pattern);
     }
   }
-  const featureBase = basename8(featurePath, ".feature");
+  const featureBase = basename9(featurePath, ".feature");
   const featureDir = dirname3(relative3(projectRoot2, featurePath));
   return join22(featureDir, `${featureBase}.test.ts`).replace(/\\/g, "/");
 }
@@ -3913,7 +3971,7 @@ function generateTestFileContent(featureName, scenarios, framework) {
   return lines.join("\n");
 }
 function appendMissingScenarios(testFilePath, scenarios, _framework) {
-  const content = readFileSync13(testFilePath, "utf-8");
+  const content = readFileSync14(testFilePath, "utf-8");
   const missing = [];
   for (const scenario of scenarios) {
     if (!content.includes(`Scenario: ${scenario.name}`)) {
@@ -3954,7 +4012,7 @@ var init_test_scaffolder = __esm({
 });
 
 // src/core/verifier/mapping-resolver.ts
-import { readFileSync as readFileSync15, existsSync as existsSync21, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync16, existsSync as existsSync22, readdirSync as readdirSync2 } from "fs";
 import { join as join24 } from "path";
 function resolveMappings(projectRoot2, features, testOutput) {
   const results = [];
@@ -3979,17 +4037,17 @@ function resolveMapping(projectRoot2, feature, scenario, _testOutput) {
 }
 function resolveFromMappingFile(projectRoot2, _feature, scenario) {
   const mappingsDir = join24(projectRoot2, ".speclore", "mappings");
-  if (!existsSync21(mappingsDir)) return null;
+  if (!existsSync22(mappingsDir)) return null;
   try {
     const files = findMappingFiles(mappingsDir);
     for (const file of files) {
       try {
-        const content = readFileSync15(file, "utf-8");
+        const content = readFileSync16(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",
@@ -4009,18 +4067,18 @@ function resolveFromMappingFile(projectRoot2, _feature, scenario) {
 }
 function resolveFromTag(projectRoot2, _feature, scenario) {
   const testsDir = join24(projectRoot2, "tests");
-  if (!existsSync21(testsDir)) return null;
+  if (!existsSync22(testsDir)) return null;
   try {
     const files = findTestFiles(testsDir);
     for (const file of files) {
       try {
-        const content = readFileSync15(file, "utf-8");
+        const content = readFileSync16(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",
@@ -4194,12 +4252,12 @@ var report_generator_exports = {};
 __export(report_generator_exports, {
   generateReport: () => generateReport
 });
-import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync13, existsSync as existsSync22, readFileSync as readFileSync16 } from "fs";
+import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync13, existsSync as existsSync23, readFileSync as readFileSync17 } from "fs";
 import { join as join25, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function generateReport(report, projectRoot2, config) {
   const reportsDir = join25(projectRoot2, ".speclore", "reports");
-  if (!existsSync22(reportsDir)) {
+  if (!existsSync23(reportsDir)) {
     mkdirSync13(reportsDir, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
@@ -4257,7 +4315,7 @@ function renderHtmlReport(report) {
   const templatePath = join25(dirname4(fileURLToPath2(import.meta.url)), "..", "..", "cli", "templates", "report.html");
   let template;
   try {
-    template = readFileSync16(templatePath, "utf-8");
+    template = readFileSync17(templatePath, "utf-8");
   } catch {
     template = getInlineTemplate();
   }
@@ -4336,7 +4394,7 @@ var init_verifier = __esm({
 });
 
 // src/core/analyzer/rdg-builder.ts
-import { readFileSync as readFileSync17, existsSync as existsSync23, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync18, existsSync as existsSync24, readdirSync as readdirSync3 } from "fs";
 import { join as join26 } from "path";
 var init_rdg_builder = __esm({
   "src/core/analyzer/rdg-builder.ts"() {
@@ -4444,11 +4502,11 @@ var init_analyzer = __esm({
 });
 
 // src/infra/file-lock.ts
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync16, unlinkSync, existsSync as existsSync28, statSync as statSync3 } from "fs";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync16, unlinkSync, existsSync as existsSync29, statSync as statSync3 } from "fs";
 import { join as join31 } from "path";
 function acquireLock(specLoreDir) {
   const lockPath = join31(specLoreDir, LOCK_FILENAME);
-  if (existsSync28(lockPath)) {
+  if (existsSync29(lockPath)) {
     const existing = readLockInfo(lockPath);
     if (existing && !isLockExpired(existing)) {
       logger.debug(`Lock already held by PID ${existing.pid}, not expired`);
@@ -4464,7 +4522,7 @@ function acquireLock(specLoreDir) {
   try {
     writeFileSync16(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}`);
@@ -4472,7 +4530,7 @@ function acquireLock(specLoreDir) {
 }
 function releaseLock(specLoreDir) {
   const lockPath = join31(specLoreDir, LOCK_FILENAME);
-  if (!existsSync28(lockPath)) {
+  if (!existsSync29(lockPath)) {
     return;
   }
   const existing = readLockInfo(lockPath);
@@ -4483,7 +4541,7 @@ function releaseLock(specLoreDir) {
 }
 function readLockInfo(lockPath) {
   try {
-    const content = readFileSync21(lockPath, "utf-8");
+    const content = readFileSync22(lockPath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed.pid === "number" && typeof parsed.timestamp === "number") {
       return parsed;
@@ -4554,17 +4612,18 @@ var init_schemas = __esm({
 
 // src/mcp/tools.ts
 import { join as join32 } from "path";
-import { readFileSync as readFileSync22, existsSync as existsSync29, mkdirSync as mkdirSync14, writeFileSync as writeFileSync17 } from "fs";
+import { readFileSync as readFileSync23, existsSync as existsSync30, mkdirSync as mkdirSync14, writeFileSync as writeFileSync17 } from "fs";
 import { globSync as globSync7 } from "glob";
 import { toJSONSchema } from "zod";
 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 = join32(projectRoot2, ".speclore");
   const context = loadContext(specLoreDir) ?? buildContext(projectRoot2, config);
   const feature = await generateFeature(req, context, config, projectRoot2);
@@ -4715,10 +4774,10 @@ function ensureProjectReady(projectRoot2) {
   const specLoreDir = join32(projectRoot2, ".speclore");
   const configPath = join32(specLoreDir, "config.yaml");
   let configCreated = false;
-  if (!existsSync29(specLoreDir)) {
+  if (!existsSync30(specLoreDir)) {
     mkdirSync14(specLoreDir, { recursive: true });
   }
-  if (!existsSync29(configPath)) {
+  if (!existsSync30(configPath)) {
     const projectName = projectRoot2.split(/[/\\]/).pop() ?? "my-project";
     writeFileSync17(configPath, generateDefaultConfigYaml(projectName), "utf-8");
     configCreated = true;
@@ -4770,8 +4829,8 @@ function resolveFeatureFiles(patterns, projectRoot2, config) {
   for (const pattern of searchPatterns) {
     const matches = globSync7(pattern, { cwd: projectRoot2, absolute: true });
     for (const filePath of matches) {
-      if (existsSync29(filePath)) {
-        const content = readFileSync22(filePath, "utf-8");
+      if (existsSync30(filePath)) {
+        const content = readFileSync23(filePath, "utf-8");
         files.push(parseFeatureFile(filePath, content));
       }
     }
@@ -4868,10 +4927,23 @@ var init_tools = __esm({
     init_config2();
     init_logger();
     init_schemas();
-    SPEC_TOOL_DESC = "Convert a requirement (text, file path, or URL) into structured BDD .feature files with scenario-level acceptance criteria.";
-    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.";
-    VERIFY_TOOL_DESC = "Run tests and map results back to .feature scenarios, producing an acceptance report. Requires test scaffolding generated by speclore.code.";
-    STATUS_TOOL_DESC = "Get current project workflow status, feature states, and recommended next steps. Call this first to understand where the project stands.";
+    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(" ");
+    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(" ");
+    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(" ");
+    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(" ");
     specJsonSchema = toJSONSchema(specInputSchema, { target: "draft-07" });
     codeJsonSchema = toJSONSchema(codeInputSchema, { target: "draft-07" });
     verifyJsonSchema = toJSONSchema(verifyInputSchema, { target: "draft-07" });
@@ -4879,7 +4951,7 @@ var init_tools = __esm({
 });
 
 // src/mcp/status.ts
-import { readFileSync as readFileSync23, existsSync as existsSync30, mkdirSync as mkdirSync15, writeFileSync as writeFileSync18 } from "fs";
+import { readFileSync as readFileSync24, existsSync as existsSync31, mkdirSync as mkdirSync15, writeFileSync as writeFileSync18 } from "fs";
 import { join as join33 } from "path";
 import { globSync as globSync8 } from "glob";
 function executeStatusTool(args, projectRoot2) {
@@ -4896,9 +4968,9 @@ function executeStatusTool(args, projectRoot2) {
       continue;
     }
     let scenarioCount = 0;
-    if (existsSync30(path)) {
+    if (existsSync31(path)) {
       try {
-        const content = readFileSync23(path, "utf-8");
+        const content = readFileSync24(path, "utf-8");
         const matches = content.match(/Scenario(?: Outline)?:/g);
         scenarioCount = matches?.length ?? 0;
       } catch {
@@ -4921,7 +4993,7 @@ function executeStatusTool(args, projectRoot2) {
     if (args.feature && !filePath.includes(args.feature)) continue;
     let scenarioCount = 0;
     try {
-      const content = readFileSync23(filePath, "utf-8");
+      const content = readFileSync24(filePath, "utf-8");
       const matches = content.match(/Scenario(?: Outline)?:/g);
       scenarioCount = matches?.length ?? 0;
     } catch {
@@ -4981,10 +5053,10 @@ function ensureProjectReadyForStatus(projectRoot2) {
   const specLoreDir = join33(projectRoot2, ".speclore");
   const configPath = join33(specLoreDir, "config.yaml");
   let configCreated = false;
-  if (!existsSync30(specLoreDir)) {
+  if (!existsSync31(specLoreDir)) {
     mkdirSync15(specLoreDir, { recursive: true });
   }
-  if (!existsSync30(configPath)) {
+  if (!existsSync31(configPath)) {
     const projectName = projectRoot2.split(/[/\\]/).pop() ?? "my-project";
     writeFileSync18(configPath, generateDefaultConfigYaml(projectName), "utf-8");
     configCreated = true;
@@ -5028,10 +5100,10 @@ async function startMcpServer() {
     mkdirSync16(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);
@@ -5051,6 +5123,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");
+}
 var server, projectRoot;
 var init_server = __esm({
   "src/mcp/server.ts"() {
@@ -5079,7 +5203,11 @@ var init_server = __esm({
           { 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(
@@ -5096,7 +5224,11 @@ var init_server = __esm({
           { 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(
@@ -5110,7 +5242,11 @@ var init_server = __esm({
           { 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(
@@ -5124,7 +5260,11 @@ var init_server = __esm({
           { 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)}` }] };
       }
     );
     projectRoot = process.env.SPECLORE_PROJECT_ROOT ?? process.cwd();
@@ -5138,18 +5278,18 @@ import { Command } from "commander";
 init_logger();
 init_config2();
 init_detector();
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
 
 // src/setup/config-writer.ts
-import { writeFileSync as writeFileSync2, existsSync as existsSync4, readFileSync as readFileSync4, mkdirSync as mkdirSync2 } from "fs";
-import { join as join5 } from "path";
+import { writeFileSync as writeFileSync2, existsSync as existsSync5, readFileSync as readFileSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join6 } from "path";
 
 // src/infra/install-detector.ts
 init_logger();
 init_version();
-import { readFileSync as readFileSync3, existsSync as existsSync3, writeFileSync, mkdirSync } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync4, writeFileSync, mkdirSync } from "fs";
+import { join as join5 } from "path";
 import { createRequire } from "module";
 var INSTALL_PATH_FILE = ".install-path";
 function detectInstallMethod(projectRoot2) {
@@ -5177,13 +5317,13 @@ function detectNpmInstall() {
   }
 }
 function detectCloneInstall(projectRoot2) {
-  const installPathFile = join4(projectRoot2, ".speclore", INSTALL_PATH_FILE);
-  if (!existsSync3(installPathFile)) {
+  const installPathFile = join5(projectRoot2, ".speclore", INSTALL_PATH_FILE);
+  if (!existsSync4(installPathFile)) {
     return null;
   }
   try {
     const localPath = readFileSync3(installPathFile, "utf-8").trim();
-    if (existsSync3(localPath)) {
+    if (existsSync4(localPath)) {
       return { mode: "clone", version: VERSION, localPath };
     }
   } catch {
@@ -5193,6 +5333,7 @@ function detectCloneInstall(projectRoot2) {
 
 // src/setup/config-writer.ts
 init_logger();
+init_path_utils();
 function writeMcpConfig(projectRoot2, tools, _globalMode) {
   const installInfo = detectInstallMethod(projectRoot2);
   const serverCommand = getServerCommand(installInfo);
@@ -5215,19 +5356,21 @@ function writeMcpForClient(projectRoot2, client) {
   const serverCommand = getServerCommand(installInfo);
   switch (client) {
     case "cursor":
-      mkdirSync2(join5(projectRoot2, ".cursor"), { recursive: true });
+      mkdirSync2(join6(projectRoot2, ".cursor"), { recursive: true });
       writeCursorMcp(projectRoot2, serverCommand);
       break;
     case "claude":
-      if (!existsSync4(join5(projectRoot2, ".claude"))) {
-        mkdirSync2(join5(projectRoot2, ".claude"), { recursive: true });
+      if (!existsSync5(join6(projectRoot2, ".claude"))) {
+        mkdirSync2(join6(projectRoot2, ".claude"), { recursive: true });
       }
       writeClaudeMcp(projectRoot2, serverCommand);
       break;
-    case "qoder":
-      mkdirSync2(join5(projectRoot2, ".qoder"), { recursive: true });
+    case "qoder": {
+      const qoderDir = resolveQoderDir(projectRoot2);
+      mkdirSync2(join6(projectRoot2, qoderDir), { recursive: true });
       writeQoderMcp(projectRoot2, serverCommand);
       break;
+    }
   }
 }
 function getServerCommand(installInfo) {
@@ -5235,12 +5378,12 @@ function getServerCommand(installInfo) {
     return { command: "npx", args: ["speclore", "mcp"] };
   }
   const localPath = installInfo.localPath ?? process.cwd();
-  return { command: "node", args: [join5(localPath, "dist", "mcp", "server.js")] };
+  return { command: "node", args: [join6(localPath, "dist", "mcp", "server.js")] };
 }
 function writeCursorMcp(projectRoot2, serverCmd) {
-  const mcpDir = join5(projectRoot2, ".cursor");
-  if (!existsSync4(mcpDir)) return;
-  const mcpPath = join5(mcpDir, "mcp.json");
+  const mcpDir = join6(projectRoot2, ".cursor");
+  if (!existsSync5(mcpDir)) return;
+  const mcpPath = join6(mcpDir, "mcp.json");
   const existing = readExistingJson(mcpPath);
   if (!existing.mcpServers) existing.mcpServers = {};
   existing.mcpServers.speclore = {
@@ -5252,10 +5395,10 @@ function writeCursorMcp(projectRoot2, serverCmd) {
   logger.info(`  Cursor: ${mcpPath}`);
 }
 function writeClaudeMcp(projectRoot2, serverCmd) {
-  const hasClaudeDir = existsSync4(join5(projectRoot2, ".claude"));
-  const hasClaudeMd = existsSync4(join5(projectRoot2, "CLAUDE.md"));
+  const hasClaudeDir = existsSync5(join6(projectRoot2, ".claude"));
+  const hasClaudeMd = existsSync5(join6(projectRoot2, "CLAUDE.md"));
   if (!hasClaudeDir && !hasClaudeMd) return;
-  const mcpPath = join5(projectRoot2, ".mcp.json");
+  const mcpPath = join6(projectRoot2, ".mcp.json");
   const existing = readExistingJson(mcpPath);
   if (!existing.mcpServers) existing.mcpServers = {};
   existing.mcpServers.speclore = {
@@ -5267,9 +5410,10 @@ function writeClaudeMcp(projectRoot2, serverCmd) {
   logger.info(`  Claude Code: ${mcpPath}`);
 }
 function writeQoderMcp(projectRoot2, serverCmd) {
-  const mcpDir = join5(projectRoot2, ".qoder");
-  if (!existsSync4(mcpDir)) return;
-  const mcpPath = join5(mcpDir, "mcp.json");
+  const qoderDir = resolveQoderDir(projectRoot2);
+  const mcpDir = join6(projectRoot2, qoderDir);
+  if (!existsSync5(mcpDir)) return;
+  const mcpPath = join6(mcpDir, "mcp.json");
   const existing = readExistingJson(mcpPath);
   if (!existing.mcpServers) existing.mcpServers = {};
   existing.mcpServers.speclore = {
@@ -5281,7 +5425,7 @@ function writeQoderMcp(projectRoot2, serverCmd) {
   logger.info(`  Qoder: ${mcpPath}`);
 }
 function readExistingJson(filePath) {
-  if (existsSync4(filePath)) {
+  if (existsSync5(filePath)) {
     try {
       return JSON.parse(readFileSync4(filePath, "utf-8"));
     } catch {
@@ -5292,9 +5436,10 @@ function readExistingJson(filePath) {
 }
 
 // src/setup/rule-writer.ts
+init_path_utils();
 init_logger();
 import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function writeRuleFiles(projectRoot2, tools) {
   for (const tool of tools) {
     switch (tool.tool) {
@@ -5311,7 +5456,7 @@ function writeRuleFiles(projectRoot2, tools) {
   }
 }
 function writeCursorRule(projectRoot2) {
-  const rulesDir = join6(projectRoot2, ".cursor", "rules");
+  const rulesDir = join7(projectRoot2, ".cursor", "rules");
   mkdirSync3(rulesDir, { recursive: true });
   const content = `---
 description: SpecLore \u2014 AI coding constraints (setup placeholder)
@@ -5329,11 +5474,11 @@ SpecLore is configured for this project. When the \`speclore.spec\` MCP tool is
 
 > This is a placeholder. Run \`speclore code\` to generate full constraints with module boundaries.
 `;
-  writeFileSync3(join6(rulesDir, "speclore.mdc"), content, "utf-8");
+  writeFileSync3(join7(rulesDir, "speclore.mdc"), content, "utf-8");
   logger.info(`  Cursor rule: .cursor/rules/speclore.mdc`);
 }
 function writeClaudeRule(projectRoot2) {
-  const rulesDir = join6(projectRoot2, ".claude", "rules");
+  const rulesDir = join7(projectRoot2, ".claude", "rules");
   mkdirSync3(rulesDir, { recursive: true });
   const content = `# SpecLore
 
@@ -5345,11 +5490,12 @@ SpecLore is configured for this project. When the \`speclore.spec\` MCP tool is
 
 > This is a placeholder. Run \`speclore code\` to generate full constraints with module boundaries.
 `;
-  writeFileSync3(join6(rulesDir, "speclore.md"), content, "utf-8");
+  writeFileSync3(join7(rulesDir, "speclore.md"), content, "utf-8");
   logger.info(`  Claude Code rule: .claude/rules/speclore.md`);
 }
 function writeQoderRule(projectRoot2) {
-  const rulesDir = join6(projectRoot2, ".qoder", "rules");
+  const qoderDir = resolveQoderDir(projectRoot2);
+  const rulesDir = join7(projectRoot2, qoderDir, "rules");
   mkdirSync3(rulesDir, { recursive: true });
   const content = `# SpecLore
 
@@ -5361,8 +5507,8 @@ SpecLore is configured for this project. When the \`speclore.spec\` MCP tool is
 
 > This is a placeholder. Run \`speclore code\` to generate full constraints with module boundaries.
 `;
-  writeFileSync3(join6(rulesDir, "speclore.md"), content, "utf-8");
-  logger.info(`  Qoder rule: .qoder/rules/speclore.md`);
+  writeFileSync3(join7(rulesDir, "speclore.md"), content, "utf-8");
+  logger.info(`  Qoder rule: ${qoderDir}/rules/speclore.md`);
 }
 
 // src/cli/commands/setup.ts
@@ -5371,26 +5517,26 @@ function registerSetupCommand(program) {
     if (opts.verbose) logger.setLevel("debug");
     const projectRoot2 = process.cwd();
     logger.info("SpecLore Setup");
-    logger.info("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    logger.info("---------------");
     const tools = detectAITools(projectRoot2);
     if (tools.length === 0) {
       logger.warn("No supported AI tools detected.");
       logger.info("");
       logger.info("  To enable MCP integration, open your AI client in this project first,");
       logger.info("  then re-run setup. Or use manual configuration:");
-      logger.info("    speclore mcp add cursor   \u2014 configure for Cursor");
-      logger.info("    speclore mcp add claude   \u2014 configure for Claude Code");
-      logger.info("    speclore mcp add qoder    \u2014 configure for Qoder");
+      logger.info("    speclore mcp add cursor   - configure for Cursor");
+      logger.info("    speclore mcp add claude   - configure for Claude Code");
+      logger.info("    speclore mcp add qoder    - configure for Qoder");
       logger.info("");
     } else {
       logger.info(`Detected AI tools: ${tools.map((t) => t.tool).join(", ")}`);
     }
-    const specLoreDir = opts.global ? join7(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".speclore") : join7(projectRoot2, ".speclore");
-    if (!existsSync5(specLoreDir)) {
+    const specLoreDir = opts.global ? join8(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".speclore") : join8(projectRoot2, ".speclore");
+    if (!existsSync6(specLoreDir)) {
       mkdirSync4(specLoreDir, { recursive: true });
     }
-    const configPath = join7(specLoreDir, "config.yaml");
-    if (!existsSync5(configPath)) {
+    const configPath = join8(specLoreDir, "config.yaml");
+    if (!existsSync6(configPath)) {
       const projectName = projectRoot2.split(/[/\\]/).pop() ?? "my-project";
       writeFileSync4(configPath, generateDefaultConfigYaml(projectName), "utf-8");
       logger.info(`Created config: ${configPath}`);
@@ -5400,18 +5546,18 @@ function registerSetupCommand(program) {
     logger.info("");
     logger.info("Setup complete! Next steps:");
     logger.info("");
-    logger.info("  Option A \u2014 CLI workflow (terminal users):");
-    logger.info('    speclore spec "your requirement"   \u2192 generate .feature');
-    logger.info("    speclore code                      \u2192 generate constraints + tests");
-    logger.info("    speclore verify                    \u2192 run acceptance");
+    logger.info("  Option A - CLI workflow (terminal users):");
+    logger.info('    speclore spec "your requirement"   -> generate .feature');
+    logger.info("    speclore code                      -> generate constraints + tests");
+    logger.info("    speclore verify                    -> run acceptance");
     logger.info("");
-    logger.info("  Option B \u2014 AI client workflow (recommended):");
+    logger.info("  Option B - AI client workflow (recommended):");
     logger.info("    Open Cursor / Qoder / Claude Code and start chatting.");
-    logger.info("    MCP is already configured \u2014 AI handles the full pipeline.");
+    logger.info("    MCP is already configured - AI handles the full pipeline.");
     logger.info("");
-    logger.info("  Optional \u2014 Pre-scan project context:");
-    logger.info("    speclore init   \u2192 scan modules/entities/APIs for better AI context");
-    logger.info("    (Not required \u2014 context is auto-built on first spec/code call)");
+    logger.info("  Optional - Pre-scan project context:");
+    logger.info("    speclore init   -> scan modules/entities/APIs for better AI context");
+    logger.info("    (Not required - context is auto-built on first spec/code call)");
   });
 }
 
@@ -5425,7 +5571,7 @@ function registerInitCommand(program) {
     if (opts.verbose) logger.setLevel("debug");
     const projectRoot2 = process.cwd();
     logger.info("SpecLore Init");
-    logger.info("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    logger.info("--------------");
     const config = loadConfig(projectRoot2);
     logger.info(`Project: ${config.project.name || "(unnamed)"}`);
     const context = buildContext(projectRoot2, config);
@@ -5456,11 +5602,12 @@ function registerSpecCommand(program) {
   program.command("spec").description("Convert a requirement source into BDD .feature file(s)").argument("<source>", "Requirement source: file path, URL, or text").option("-m, --module <name>", "Target module name").option("-v, --verbose", "Enable debug logging").action(async (source, opts) => {
     if (opts.verbose) logger.setLevel("debug");
     const projectRoot2 = process.cwd();
-    logger.info(`Reading requirement: ${source.slice(0, 80)}...`);
+    const cleanedSource = sanitizeSource(source);
+    logger.info(`Reading requirement: ${cleanedSource.slice(0, 120)}`);
     const config = loadConfig(projectRoot2);
     const specLoreDir = join18(projectRoot2, ".speclore");
     const context = loadContext(specLoreDir) ?? buildContext(projectRoot2, config);
-    const requirements = await readRequirement(source);
+    const requirements = await readRequirement(cleanedSource);
     const features = await generateFeature(requirements, context, config, projectRoot2);
     logger.info(`Created: ${features.path} (${features.scenarios.length} scenarios)`);
     if (features.needsReview.length > 0) {
@@ -5485,7 +5632,7 @@ init_test_scaffolder();
 init_context_engine();
 init_state_manager();
 import { join as join23 } from "path";
-import { readFileSync as readFileSync14, existsSync as existsSync20 } from "fs";
+import { readFileSync as readFileSync15, existsSync as existsSync21 } from "fs";
 import { globSync as globSync4 } from "glob";
 function registerCodeCommand(program) {
   program.command("code").description("Generate AI coding constraint files from .feature specs").argument("[features...]", "Feature file paths or glob patterns (all if omitted)").option("-v, --verbose", "Enable debug logging").action(async (features, opts) => {
@@ -5540,8 +5687,8 @@ function resolveFeatures(patterns, projectRoot2, config) {
   for (const pattern of searchPatterns) {
     const matches = globSync4(pattern, { cwd: projectRoot2, absolute: true });
     for (const filePath of matches) {
-      if (existsSync20(filePath)) {
-        const content = readFileSync14(filePath, "utf-8");
+      if (existsSync21(filePath)) {
+        const content = readFileSync15(filePath, "utf-8");
         const featureMatch = content.match(/Feature:\s*(.+)/);
         files.push({
           path: filePath,
@@ -5565,7 +5712,7 @@ init_context_engine();
 init_analyzer();
 init_state_manager();
 import { join as join27 } from "path";
-import { readFileSync as readFileSync18, existsSync as existsSync24 } from "fs";
+import { readFileSync as readFileSync19, existsSync as existsSync25 } from "fs";
 import { globSync as globSync6 } from "glob";
 function registerVerifyCommand(program) {
   program.command("verify").description("Run tests and map results to .feature scenarios").argument("[features...]", "Feature file paths or glob patterns (all if omitted)").option("--impact", "Enable change impact analysis").option("--watch", "Watch for .feature file changes and re-run").option("--timeout <minutes>", "Watch timeout in minutes (default: 30)", "30").option("-v, --verbose", "Enable debug logging").action(async (features, opts) => {
@@ -5651,8 +5798,8 @@ function resolveFeatures2(patterns, projectRoot2, config) {
   for (const pattern of searchPatterns) {
     const matches = globSync6(pattern, { cwd: projectRoot2, absolute: true });
     for (const filePath of matches) {
-      if (existsSync24(filePath)) {
-        const content = readFileSync18(filePath, "utf-8");
+      if (existsSync25(filePath)) {
+        const content = readFileSync19(filePath, "utf-8");
         const featureMatch = content.match(/Feature:\s*(.+)/);
         files.push({
           path: filePath,
@@ -5673,36 +5820,38 @@ init_logger();
 
 // src/setup/cleanup.ts
 init_logger();
-import { rmSync as rmSync4, existsSync as existsSync25, readFileSync as readFileSync19, writeFileSync as writeFileSync14 } from "fs";
+init_path_utils();
+import { rmSync as rmSync4, existsSync as existsSync26, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "fs";
 import { join as join28 } from "path";
 function runTeardown(projectRoot2, globalMode) {
   if (globalMode) {
     const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "";
     const globalDir = join28(homeDir, ".speclore");
-    if (existsSync25(globalDir)) {
+    if (existsSync26(globalDir)) {
       rmSync4(globalDir, { recursive: true, force: true });
       logger.info(`Removed: ${globalDir}`);
     }
   } else {
     const specLoreDir = join28(projectRoot2, ".speclore");
-    if (existsSync25(specLoreDir)) {
+    if (existsSync26(specLoreDir)) {
       rmSync4(specLoreDir, { recursive: true, force: true });
       logger.info(`Removed: ${specLoreDir}`);
     }
     removeMcpEntry(join28(projectRoot2, ".cursor", "mcp.json"), "speclore");
     removeMcpEntry(join28(projectRoot2, ".mcp.json"), "speclore");
-    removeMcpEntry(join28(projectRoot2, ".qoder", "mcp.json"), "speclore");
+    const qoderDir = resolveQoderDir(projectRoot2);
+    removeMcpEntry(join28(projectRoot2, qoderDir, "mcp.json"), "speclore");
     removeIfExists(join28(projectRoot2, ".cursor", "rules", "speclore.mdc"));
     removeIfExists(join28(projectRoot2, ".claude", "rules", "speclore.md"));
-    removeIfExists(join28(projectRoot2, ".qoder", "rules", "speclore.md"));
+    removeIfExists(join28(projectRoot2, qoderDir, "rules", "speclore.md"));
     logger.info("Project teardown complete.");
   }
   return Promise.resolve();
 }
 function removeMcpEntry(mcpPath, serverName) {
-  if (!existsSync25(mcpPath)) return;
+  if (!existsSync26(mcpPath)) return;
   try {
-    const config = JSON.parse(readFileSync19(mcpPath, "utf-8"));
+    const config = JSON.parse(readFileSync20(mcpPath, "utf-8"));
     if (config.mcpServers?.[serverName]) {
       delete config.mcpServers[serverName];
       writeFileSync14(mcpPath, JSON.stringify(config, null, 2), "utf-8");
@@ -5712,7 +5861,7 @@ function removeMcpEntry(mcpPath, serverName) {
   }
 }
 function removeIfExists(filePath) {
-  if (existsSync25(filePath)) {
+  if (existsSync26(filePath)) {
     rmSync4(filePath);
     logger.info(`  Removed: ${filePath}`);
   }
@@ -5746,7 +5895,7 @@ init_config2();
 init_logger();
 init_state_manager();
 import { join as join29 } from "path";
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 function registerMigrateCommand(program) {
   program.command("migrate").description("Register existing .feature files into workflow state (for upgrading projects)").option("-v, --verbose", "Enable debug logging").action((opts) => {
     if (opts.verbose) logger.setLevel("debug");
@@ -5756,7 +5905,7 @@ function registerMigrateCommand(program) {
     console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
     console.log("");
     const configPath = join29(projectRoot2, ".speclore", "config.yaml");
-    if (!existsSync26(configPath)) {
+    if (!existsSync27(configPath)) {
       console.log("\u2717 No .speclore/config.yaml found. Run `speclore setup` first.");
       console.log("");
       return;
@@ -5767,7 +5916,7 @@ function registerMigrateCommand(program) {
     stateManager.ensureInitialized();
     console.log("\u2713 State file ready");
     const specsDir = join29(projectRoot2, config.spec.outputDir);
-    if (!existsSync26(specsDir)) {
+    if (!existsSync27(specsDir)) {
       console.log(`\u25CB No ${config.spec.outputDir}/ directory found \u2014 nothing to migrate.`);
       console.log("");
       return;
@@ -5800,8 +5949,9 @@ function registerMigrateCommand(program) {
 
 // src/cli/commands/mcp-config.ts
 init_logger();
-import { existsSync as existsSync27, readFileSync as readFileSync20, writeFileSync as writeFileSync15, rmSync as rmSync5 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync21, writeFileSync as writeFileSync15, rmSync as rmSync5 } from "fs";
 import { join as join30 } from "path";
+init_path_utils();
 var VALID_CLIENTS = ["cursor", "claude", "qoder"];
 function getMcpPath(projectRoot2, client) {
   switch (client) {
@@ -5809,8 +5959,10 @@ function getMcpPath(projectRoot2, client) {
       return join30(projectRoot2, ".cursor", "mcp.json");
     case "claude":
       return join30(projectRoot2, ".mcp.json");
-    case "qoder":
-      return join30(projectRoot2, ".qoder", "mcp.json");
+    case "qoder": {
+      const qoderDir = resolveQoderDir(projectRoot2);
+      return join30(projectRoot2, qoderDir, "mcp.json");
+    }
   }
 }
 function clientLabel(client) {
@@ -5832,20 +5984,20 @@ function registerMcpConfigCommands(program) {
     if (!client) return;
     logger.info(`Configuring MCP for ${clientLabel(client)}...`);
     writeMcpForClient(projectRoot2, client);
-    logger.info(`\u2713 ${clientLabel(client)} MCP configured at ${getMcpPath(projectRoot2, client)}`);
+    logger.info(`[OK] ${clientLabel(client)} MCP configured at ${getMcpPath(projectRoot2, client)}`);
   });
   mcpCmd.command("remove <client>").description("Remove SpecLore MCP config from a specific AI client (cursor | claude | qoder)").action((clientArg) => {
     const projectRoot2 = process.cwd();
     const client = validateClient(clientArg);
     if (!client) return;
     const mcpPath = getMcpPath(projectRoot2, client);
-    if (!existsSync27(mcpPath)) {
+    if (!existsSync28(mcpPath)) {
       logger.info(`${clientLabel(client)}: no MCP config file found at ${mcpPath}`);
       return;
     }
     const removed = removeMcpServerEntry(mcpPath, "speclore");
     if (removed) {
-      logger.info(`\u2713 Removed speclore from ${clientLabel(client)}: ${mcpPath}`);
+      logger.info(`[OK] Removed speclore from ${clientLabel(client)}: ${mcpPath}`);
     } else {
       logger.info(`${clientLabel(client)}: speclore entry not found in ${mcpPath}`);
     }
@@ -5853,24 +6005,24 @@ function registerMcpConfigCommands(program) {
   mcpCmd.command("list").description("Show current SpecLore MCP configuration status for all clients").action(() => {
     const projectRoot2 = process.cwd();
     logger.info("SpecLore MCP Configuration Status");
-    logger.info("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    logger.info("------------------------------");
     let anyFound = false;
     for (const client of VALID_CLIENTS) {
       const mcpPath = getMcpPath(projectRoot2, client);
-      if (!existsSync27(mcpPath)) {
-        logger.info(`  \u25CB ${clientLabel(client)}: no config file (${mcpPath})`);
+      if (!existsSync28(mcpPath)) {
+        logger.info(`  [-] ${clientLabel(client)}: no config file (${mcpPath})`);
         continue;
       }
       try {
-        const config = JSON.parse(readFileSync20(mcpPath, "utf-8"));
+        const config = JSON.parse(readFileSync21(mcpPath, "utf-8"));
         if (config.mcpServers?.["speclore"]) {
-          logger.info(`  \u2713 ${clientLabel(client)}: configured \u2192 ${mcpPath}`);
+          logger.info(`  [OK] ${clientLabel(client)}: configured -> ${mcpPath}`);
           anyFound = true;
         } else {
-          logger.info(`  \u25CB ${clientLabel(client)}: config file exists but speclore not registered \u2192 ${mcpPath}`);
+          logger.info(`  [-] ${clientLabel(client)}: config file exists but speclore not registered -> ${mcpPath}`);
         }
       } catch {
-        logger.info(`  \u2717 ${clientLabel(client)}: failed to parse ${mcpPath}`);
+        logger.info(`  [!] ${clientLabel(client)}: failed to parse ${mcpPath}`);
       }
     }
     if (!anyFound) {
@@ -5889,9 +6041,9 @@ function validateClient(arg) {
   return normalised;
 }
 function removeMcpServerEntry(mcpPath, serverName) {
-  if (!existsSync27(mcpPath)) return false;
+  if (!existsSync28(mcpPath)) return false;
   try {
-    const config = JSON.parse(readFileSync20(mcpPath, "utf-8"));
+    const config = JSON.parse(readFileSync21(mcpPath, "utf-8"));
     if (!config.mcpServers?.[serverName]) return false;
     delete config.mcpServers[serverName];
     const remainingServers = Object.keys(config.mcpServers ?? {});