speclore 0.1.1

package/dist/mcp/server.js

@@ -0,0 +1,4437 @@
+#!/usr/bin/env node
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/infra/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  getLogLevel: () => getLogLevel,
+  initLogger: () => initLogger,
+  logger: () => logger,
+  setLogLevel: () => setLogLevel
+});
+import pino from "pino";
+function isJsonMode() {
+  const format = process.env["SPECLORE_LOG_FORMAT"];
+  if (format === "json") return true;
+  if (format === "pretty") return false;
+  return process.env["NODE_ENV"] === "production";
+}
+function createPinoInstance(level) {
+  const pinoLevel = toPinoLevel(level);
+  if (isJsonMode()) {
+    return pino({
+      level: pinoLevel,
+      timestamp: pino.stdTimeFunctions.isoTime,
+      formatters: {
+        level(label) {
+          return { level: label };
+        }
+      }
+    });
+  }
+  return pino({
+    level: pinoLevel,
+    transport: {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "HH:MM:ss.l",
+        ignore: "pid,hostname",
+        singleLine: true
+      }
+    }
+  });
+}
+function toPinoLevel(level) {
+  return level;
+}
+function initLogger(options) {
+  if (options?.verbose) {
+    setLogLevel("debug");
+    return;
+  }
+  const envLevel = process.env["SPECLORE_LOG_LEVEL"];
+  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
+    setLogLevel(envLevel);
+  }
+}
+function setLogLevel(level) {
+  currentLevel = level;
+  pinoInstance = createPinoInstance(level);
+}
+function getLogLevel() {
+  return currentLevel;
+}
+var currentLevel, pinoInstance, logger;
+var init_logger = __esm({
+  "src/infra/logger.ts"() {
+    "use strict";
+    currentLevel = "info";
+    pinoInstance = createPinoInstance(currentLevel);
+    logger = {
+      debug(message, ...args) {
+        pinoInstance.debug({ args: args.length > 0 ? args : void 0 }, message);
+      },
+      info(message, ...args) {
+        pinoInstance.info({ args: args.length > 0 ? args : void 0 }, message);
+      },
+      warn(message, ...args) {
+        pinoInstance.warn({ args: args.length > 0 ? args : void 0 }, message);
+      },
+      error(message, ...args) {
+        pinoInstance.error({ args: args.length > 0 ? args : void 0 }, message);
+      },
+      /** Shortcut to set log level */
+      setLevel(level) {
+        setLogLevel(level);
+      }
+    };
+  }
+});
+
+// src/ai/cost-tracker.ts
+function getCostTracker(maxBudgetUsd) {
+  if (!_tracker) {
+    _tracker = new CostTracker(maxBudgetUsd);
+  }
+  return _tracker;
+}
+var MODEL_PRICING, CostTracker, _tracker;
+var init_cost_tracker = __esm({
+  "src/ai/cost-tracker.ts"() {
+    "use strict";
+    init_logger();
+    MODEL_PRICING = {
+      // OpenAI models
+      "gpt-4": { inputPer1K: 0.03, outputPer1K: 0.06 },
+      "gpt-4-turbo": { inputPer1K: 0.01, outputPer1K: 0.03 },
+      "gpt-4o": { inputPer1K: 5e-3, outputPer1K: 0.015 },
+      "gpt-4o-mini": { inputPer1K: 15e-5, outputPer1K: 6e-4 },
+      "gpt-3.5-turbo": { inputPer1K: 5e-4, outputPer1K: 15e-4 },
+      // Anthropic models
+      "claude-3-5-sonnet-20241022": { inputPer1K: 3e-3, outputPer1K: 0.015 },
+      "claude-3-5-haiku-20241022": { inputPer1K: 1e-3, outputPer1K: 5e-3 },
+      "claude-3-opus-20240229": { inputPer1K: 0.015, outputPer1K: 0.075 }
+    };
+    CostTracker = class {
+      records = [];
+      maxBudgetUsd;
+      constructor(maxBudgetUsd) {
+        this.maxBudgetUsd = maxBudgetUsd ?? Infinity;
+      }
+      /**
+       * Record a single API call's token usage.
+       * Returns the estimated cost in USD.
+       */
+      recordUsage(model, promptTokens, completionTokens) {
+        const cost = this.estimateCost(model, promptTokens, completionTokens);
+        const currentTotal = this.records.reduce((sum, r) => sum + r.estimatedCostUsd, 0);
+        if (currentTotal + cost > this.maxBudgetUsd) {
+          throw new Error(
+            `Budget exceeded: $${(currentTotal + cost).toFixed(4)} would exceed limit of $${this.maxBudgetUsd.toFixed(2)}. Current spend: $${currentTotal.toFixed(4)}.`
+          );
+        }
+        this.records.push({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          model,
+          promptTokens,
+          completionTokens,
+          totalTokens: promptTokens + completionTokens,
+          estimatedCostUsd: cost
+        });
+        logger.debug(`AI usage: ${model} \u2014 ${promptTokens}+${completionTokens} tokens, ~$${cost.toFixed(4)}`);
+        return cost;
+      }
+      /**
+       * Estimate cost for a given model and token counts.
+       */
+      estimateCost(model, promptTokens, completionTokens) {
+        const pricing = MODEL_PRICING[model];
+        if (!pricing) {
+          logger.debug(`No pricing data for model: ${model}`);
+          return 0;
+        }
+        const inputCost = promptTokens / 1e3 * pricing.inputPer1K;
+        const outputCost = completionTokens / 1e3 * pricing.outputPer1K;
+        return inputCost + outputCost;
+      }
+      /**
+       * Get aggregated usage summary.
+       */
+      getUsageSummary() {
+        const summary = {
+          totalCalls: this.records.length,
+          totalPromptTokens: 0,
+          totalCompletionTokens: 0,
+          totalTokens: 0,
+          totalCostUsd: 0,
+          byModel: {}
+        };
+        for (const record of this.records) {
+          summary.totalPromptTokens += record.promptTokens;
+          summary.totalCompletionTokens += record.completionTokens;
+          summary.totalTokens += record.totalTokens;
+          summary.totalCostUsd += record.estimatedCostUsd;
+          if (!summary.byModel[record.model]) {
+            summary.byModel[record.model] = { calls: 0, tokens: 0, costUsd: 0 };
+          }
+          const modelStats = summary.byModel[record.model];
+          modelStats.calls++;
+          modelStats.tokens += record.totalTokens;
+          modelStats.costUsd += record.estimatedCostUsd;
+        }
+        return summary;
+      }
+      /**
+       * Get all usage records.
+       */
+      getRecords() {
+        return [...this.records];
+      }
+      /**
+       * Reset all tracking data.
+       */
+      reset() {
+        this.records = [];
+      }
+      /**
+       * Get the configured budget limit.
+       */
+      getBudgetLimit() {
+        return this.maxBudgetUsd;
+      }
+    };
+    _tracker = null;
+  }
+});
+
+// src/ai/base-adapter.ts
+var BaseAdapter;
+var init_base_adapter = __esm({
+  "src/ai/base-adapter.ts"() {
+    "use strict";
+    init_cost_tracker();
+    init_logger();
+    BaseAdapter = class _BaseAdapter {
+      /** Maximum retry attempts (override in subclass) */
+      maxRetries = 3;
+      /** Base delay in ms for exponential backoff (override in subclass) */
+      retryBaseDelayMs = 1e3;
+      /**
+       * Execute an async operation with retry + exponential backoff.
+       * Only retries on retryable errors (429, 5xx); client errors (4xx) are thrown immediately.
+       * Returns the result on success; throws the last error after all retries exhausted.
+       */
+      async withRetry(operation, label) {
+        let lastError = null;
+        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+          try {
+            return await operation(attempt);
+          } catch (error) {
+            if (!this.isRetryableError(error)) {
+              const err = error instanceof Error ? error : new Error(String(error));
+              logger.warn(`${label} non-retryable error: ${err.message}`);
+              throw err;
+            }
+            lastError = error instanceof Error ? error : new Error(String(error));
+            logger.warn(`${label} attempt ${attempt + 1}/${this.maxRetries} failed: ${lastError.message}`);
+            if (attempt < this.maxRetries - 1) {
+              const delay = this.retryBaseDelayMs * Math.pow(2, attempt);
+              await _BaseAdapter.sleep(delay);
+            }
+          }
+        }
+        throw lastError ?? new Error(`${label} failed after ${this.maxRetries} retries`);
+      }
+      /**
+       * Determine whether an error is retryable.
+       * Default: only retry on network-level errors (ECONNRESET, ENOTFOUND, ETIMEDOUT).
+       * Subclasses should override to use SDK-specific error classes for precise classification.
+       */
+      isRetryableError(error) {
+        if (error instanceof Error) {
+          const msg = error.message.toLowerCase();
+          if (msg.includes("econnreset") || msg.includes("enotfound") || msg.includes("etimedout")) return true;
+        }
+        return false;
+      }
+      /**
+       * Create an AbortController linked to an optional user signal and timeout.
+       * Returns the controller and a cleanup function to clear timers.
+       */
+      createTimeoutController(options) {
+        const controller = new AbortController();
+        let timer;
+        let abortHandler;
+        if (options?.timeoutMs) {
+          timer = setTimeout(() => controller.abort(), options.timeoutMs);
+        }
+        if (options?.signal) {
+          if (options.signal.aborted) {
+            controller.abort();
+          } else {
+            abortHandler = () => controller.abort();
+            options.signal.addEventListener("abort", abortHandler, { once: true });
+          }
+        }
+        return {
+          controller,
+          cleanup: () => {
+            if (timer) clearTimeout(timer);
+            if (abortHandler && options?.signal) {
+              options.signal.removeEventListener("abort", abortHandler);
+            }
+          }
+        };
+      }
+      /**
+       * Record token usage to the global cost tracker.
+       * Silently skips if usage is undefined (some providers don't report it).
+       */
+      recordCost(usage) {
+        if (usage) {
+          getCostTracker().recordUsage(this.model, usage.promptTokens, usage.completionTokens);
+        }
+      }
+      /** Shared sleep utility */
+      static sleep(ms) {
+        return new Promise((resolve2) => setTimeout(resolve2, ms));
+      }
+    };
+  }
+});
+
+// src/ai/openai-adapter.ts
+var openai_adapter_exports = {};
+__export(openai_adapter_exports, {
+  OpenAIAdapter: () => OpenAIAdapter
+});
+import OpenAI, { RateLimitError, InternalServerError, APIConnectionError } from "openai";
+var OpenAIAdapter;
+var init_openai_adapter = __esm({
+  "src/ai/openai-adapter.ts"() {
+    "use strict";
+    init_base_adapter();
+    OpenAIAdapter = class extends BaseAdapter {
+      name = "openai-compatible";
+      model;
+      client = null;
+      constructor(baseUrl, model, apiKeyEnv) {
+        super();
+        this.model = model ?? "gpt-4";
+        const apiKey = process.env[apiKeyEnv ?? "OPENAI_API_KEY"] ?? process.env["OPENAI_API_KEY"] ?? "";
+        const baseURL = baseUrl ?? process.env["OPENAI_BASE_URL"];
+        if (apiKey) {
+          this.client = new OpenAI({ apiKey, baseURL: baseURL ?? void 0, maxRetries: 0 });
+        }
+      }
+      isAvailable() {
+        return this.client !== null;
+      }
+      isRetryableError(error) {
+        if (error instanceof RateLimitError) return true;
+        if (error instanceof InternalServerError) return true;
+        if (error instanceof APIConnectionError) return true;
+        return false;
+      }
+      async generate(prompt, options) {
+        if (!this.client) {
+          throw new Error("OpenAI client not initialized. Set OPENAI_API_KEY environment variable.");
+        }
+        const result = await this.withRetry(async () => {
+          const { controller, cleanup } = this.createTimeoutController(options);
+          try {
+            const response = await this.client.chat.completions.create(
+              {
+                model: this.model,
+                messages: [{ role: "user", content: prompt }],
+                max_tokens: options?.maxTokens,
+                temperature: options?.temperature ?? 0.3
+              },
+              { signal: controller.signal }
+            );
+            const content = response.choices[0]?.message?.content ?? "";
+            const usage = response.usage;
+            return {
+              content,
+              usage: usage ? {
+                promptTokens: usage.prompt_tokens,
+                completionTokens: usage.completion_tokens,
+                totalTokens: usage.total_tokens
+              } : void 0
+            };
+          } finally {
+            cleanup();
+          }
+        }, "OpenAI");
+        this.recordCost(result.usage);
+        return result;
+      }
+      async generateWithImage(prompt, image, options) {
+        if (!this.client) {
+          throw new Error("OpenAI client not initialized. Set OPENAI_API_KEY environment variable.");
+        }
+        const base64Image = image.buffer.toString("base64");
+        const dataUrl = `data:${image.mimeType};base64,${base64Image}`;
+        const messages = [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: prompt },
+              { type: "image_url", image_url: { url: dataUrl } }
+            ]
+          }
+        ];
+        const result = await this.withRetry(async () => {
+          const { controller, cleanup } = this.createTimeoutController(options);
+          try {
+            const response = await this.client.chat.completions.create(
+              {
+                model: this.model,
+                messages,
+                max_tokens: options?.maxTokens,
+                temperature: options?.temperature ?? 0.3
+              },
+              { signal: controller.signal }
+            );
+            const content = response.choices[0]?.message?.content ?? "";
+            const usage = response.usage;
+            return {
+              content,
+              usage: usage ? {
+                promptTokens: usage.prompt_tokens,
+                completionTokens: usage.completion_tokens,
+                totalTokens: usage.total_tokens
+              } : void 0
+            };
+          } finally {
+            cleanup();
+          }
+        }, "OpenAI Vision");
+        this.recordCost(result.usage);
+        return result;
+      }
+      async *generateStream(prompt, options) {
+        if (!this.client) {
+          throw new Error("OpenAI client not initialized. Set OPENAI_API_KEY environment variable.");
+        }
+        const { controller, cleanup } = this.createTimeoutController(options);
+        try {
+          const stream = await this.client.chat.completions.create(
+            {
+              model: this.model,
+              messages: [{ role: "user", content: prompt }],
+              max_tokens: options?.maxTokens,
+              temperature: options?.temperature ?? 0.3,
+              stream: true
+            },
+            { signal: controller.signal }
+          );
+          for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta?.content ?? "";
+            if (delta) yield delta;
+          }
+        } finally {
+          cleanup();
+        }
+      }
+    };
+  }
+});
+
+// src/ai/claude-adapter.ts
+var claude_adapter_exports = {};
+__export(claude_adapter_exports, {
+  ClaudeAdapter: () => ClaudeAdapter
+});
+import Anthropic, { RateLimitError as RateLimitError2, InternalServerError as InternalServerError2, APIConnectionError as APIConnectionError2 } from "@anthropic-ai/sdk";
+var ClaudeAdapter;
+var init_claude_adapter = __esm({
+  "src/ai/claude-adapter.ts"() {
+    "use strict";
+    init_base_adapter();
+    ClaudeAdapter = class extends BaseAdapter {
+      name = "claude";
+      model;
+      client = null;
+      constructor(model, apiKeyEnv) {
+        super();
+        this.model = model ?? "claude-sonnet-4-20250514";
+        const apiKey = process.env[apiKeyEnv ?? "ANTHROPIC_API_KEY"] ?? process.env["ANTHROPIC_API_KEY"] ?? "";
+        if (apiKey) {
+          this.client = new Anthropic({ apiKey, maxRetries: 0 });
+        }
+      }
+      isAvailable() {
+        return this.client !== null;
+      }
+      isRetryableError(error) {
+        if (error instanceof RateLimitError2) return true;
+        if (error instanceof InternalServerError2) return true;
+        if (error instanceof APIConnectionError2) return true;
+        return false;
+      }
+      async generate(prompt, options) {
+        if (!this.client) {
+          throw new Error("Anthropic client not initialized. Set ANTHROPIC_API_KEY environment variable.");
+        }
+        const result = await this.withRetry(async () => {
+          const { controller, cleanup } = this.createTimeoutController(options);
+          try {
+            const response = await this.client.messages.create(
+              {
+                model: this.model,
+                max_tokens: options?.maxTokens ?? 4096,
+                temperature: options?.temperature ?? 0.3,
+                messages: [{ role: "user", content: prompt }]
+              },
+              { signal: controller.signal }
+            );
+            const content = response.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+            return {
+              content,
+              usage: {
+                promptTokens: response.usage.input_tokens,
+                completionTokens: response.usage.output_tokens,
+                totalTokens: response.usage.input_tokens + response.usage.output_tokens
+              }
+            };
+          } finally {
+            cleanup();
+          }
+        }, "Claude");
+        this.recordCost(result.usage);
+        return result;
+      }
+      async generateWithImage(prompt, image, options) {
+        if (!this.client) {
+          throw new Error("Anthropic client not initialized. Set ANTHROPIC_API_KEY environment variable.");
+        }
+        const base64Image = image.buffer.toString("base64");
+        const messages = [
+          {
+            role: "user",
+            content: [
+              {
+                type: "image",
+                source: {
+                  type: "base64",
+                  media_type: image.mimeType,
+                  data: base64Image
+                }
+              },
+              { type: "text", text: prompt }
+            ]
+          }
+        ];
+        const result = await this.withRetry(async () => {
+          const { controller, cleanup } = this.createTimeoutController(options);
+          try {
+            const response = await this.client.messages.create(
+              {
+                model: this.model,
+                max_tokens: options?.maxTokens ?? 4096,
+                temperature: options?.temperature ?? 0.3,
+                messages
+              },
+              { signal: controller.signal }
+            );
+            const content = response.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+            return {
+              content,
+              usage: {
+                promptTokens: response.usage.input_tokens,
+                completionTokens: response.usage.output_tokens,
+                totalTokens: response.usage.input_tokens + response.usage.output_tokens
+              }
+            };
+          } finally {
+            cleanup();
+          }
+        }, "Claude Vision");
+        this.recordCost(result.usage);
+        return result;
+      }
+      async *generateStream(prompt, options) {
+        if (!this.client) {
+          throw new Error("Anthropic client not initialized. Set ANTHROPIC_API_KEY environment variable.");
+        }
+        const { controller, cleanup } = this.createTimeoutController(options);
+        try {
+          const stream = this.client.messages.stream(
+            {
+              model: this.model,
+              max_tokens: options?.maxTokens ?? 4096,
+              temperature: options?.temperature ?? 0.3,
+              messages: [{ role: "user", content: prompt }]
+            },
+            { signal: controller.signal }
+          );
+          for await (const event of stream) {
+            if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+              yield event.delta.text;
+            }
+          }
+        } finally {
+          cleanup();
+        }
+      }
+    };
+  }
+});
+
+// src/ai/ollama-adapter.ts
+var ollama_adapter_exports = {};
+__export(ollama_adapter_exports, {
+  OllamaAdapter: () => OllamaAdapter
+});
+var DEFAULT_BASE_URL, OllamaAdapter;
+var init_ollama_adapter = __esm({
+  "src/ai/ollama-adapter.ts"() {
+    "use strict";
+    init_base_adapter();
+    DEFAULT_BASE_URL = "http://localhost:11434";
+    OllamaAdapter = class extends BaseAdapter {
+      name = "ollama";
+      model;
+      retryBaseDelayMs = 2e3;
+      baseUrl;
+      constructor(baseUrl, model) {
+        super();
+        this.baseUrl = baseUrl ?? DEFAULT_BASE_URL;
+        this.model = model ?? "llama3";
+      }
+      isAvailable() {
+        return true;
+      }
+      isRetryableError(error) {
+        if (!(error instanceof Error)) return false;
+        const msg = error.message.toLowerCase();
+        if (msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("504")) return true;
+        if (msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("enotfound")) return true;
+        return false;
+      }
+      async generate(prompt, options) {
+        const result = await this.withRetry(async () => {
+          const { controller, cleanup } = this.createTimeoutController(options);
+          try {
+            const response = await fetch(`${this.baseUrl}/api/generate`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                model: this.model,
+                prompt,
+                stream: false,
+                options: {
+                  temperature: options?.temperature ?? 0.3,
+                  num_predict: options?.maxTokens
+                }
+              }),
+              signal: controller.signal
+            });
+            if (!response.ok) {
+              throw new Error(`Ollama returned ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return {
+              content: data.response,
+              usage: data.prompt_eval_count ? {
+                promptTokens: data.prompt_eval_count,
+                completionTokens: data.eval_count ?? 0,
+                totalTokens: data.prompt_eval_count + (data.eval_count ?? 0)
+              } : void 0
+            };
+          } finally {
+            cleanup();
+          }
+        }, "Ollama");
+        this.recordCost(result.usage);
+        return result;
+      }
+      async generateWithImage(prompt, image, options) {
+        const base64Image = image.buffer.toString("base64");
+        const result = await this.withRetry(async () => {
+          const { controller, cleanup } = this.createTimeoutController(options);
+          try {
+            const response = await fetch(`${this.baseUrl}/api/generate`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                model: this.model,
+                prompt,
+                images: [base64Image],
+                stream: false,
+                options: {
+                  temperature: options?.temperature ?? 0.3,
+                  num_predict: options?.maxTokens
+                }
+              }),
+              signal: controller.signal
+            });
+            if (!response.ok) {
+              throw new Error(`Ollama returned ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return {
+              content: data.response,
+              usage: data.prompt_eval_count ? {
+                promptTokens: data.prompt_eval_count,
+                completionTokens: data.eval_count ?? 0,
+                totalTokens: data.prompt_eval_count + (data.eval_count ?? 0)
+              } : void 0
+            };
+          } finally {
+            cleanup();
+          }
+        }, "Ollama Vision");
+        this.recordCost(result.usage);
+        return result;
+      }
+      async *generateStream(prompt, options) {
+        const { controller, cleanup } = this.createTimeoutController(options);
+        try {
+          const response = await fetch(`${this.baseUrl}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              model: this.model,
+              prompt,
+              stream: true,
+              options: {
+                temperature: options?.temperature ?? 0.3
+              }
+            }),
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            throw new Error(`Ollama returned ${response.status}: ${response.statusText}`);
+          }
+          if (!response.body) {
+            throw new Error("Ollama streaming response has no body");
+          }
+          const reader = response.body.getReader();
+          const decoder = new TextDecoder();
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            const lines = decoder.decode(value ?? new Uint8Array()).trim().split("\n");
+            for (const line of lines) {
+              if (!line) continue;
+              try {
+                const data = JSON.parse(line);
+                if (data.response) yield data.response;
+              } catch {
+              }
+            }
+          }
+        } finally {
+          cleanup();
+        }
+      }
+    };
+  }
+});
+
+// src/ai/provider.ts
+var provider_exports = {};
+__export(provider_exports, {
+  createProvider: () => createProvider,
+  createProviderChain: () => createProviderChain
+});
+async function createProvider(config) {
+  const provider = config?.provider ?? "openai-compatible";
+  switch (provider) {
+    case "openai-compatible": {
+      const { OpenAIAdapter: OpenAIAdapter2 } = await Promise.resolve().then(() => (init_openai_adapter(), openai_adapter_exports));
+      return new OpenAIAdapter2(config?.baseUrl, config?.model, config?.apiKeyEnv);
+    }
+    case "claude": {
+      const { ClaudeAdapter: ClaudeAdapter2 } = await Promise.resolve().then(() => (init_claude_adapter(), claude_adapter_exports));
+      return new ClaudeAdapter2(config?.model, config?.apiKeyEnv);
+    }
+    case "ollama": {
+      const { OllamaAdapter: OllamaAdapter2 } = await Promise.resolve().then(() => (init_ollama_adapter(), ollama_adapter_exports));
+      return new OllamaAdapter2(config?.baseUrl, config?.model);
+    }
+    default:
+      throw new Error(`Unknown AI provider: ${provider}`);
+  }
+}
+async function createProviderChain(configs) {
+  const { logger: logger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+  const errors = [];
+  for (const config of configs) {
+    try {
+      const provider = await createProvider(config);
+      if (provider.isAvailable()) {
+        logger2.debug(`Provider chain: using '${provider.name}'`);
+        return provider;
+      }
+      errors.push(`${config.provider ?? "openai-compatible"}: not available (API key not set)`);
+    } catch (err) {
+      errors.push(`${config.provider ?? "openai-compatible"}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  throw new Error(`All providers in chain unavailable:
+  ${errors.join("\n  ")}`);
+}
+var init_provider = __esm({
+  "src/ai/provider.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/infra/file-lock.ts
+init_logger();
+import { readFileSync, writeFileSync, unlinkSync, existsSync, statSync } from "fs";
+import { join } from "path";
+var LOCK_FILENAME = ".lock";
+var LOCK_EXPIRY_MS = 30 * 60 * 1e3;
+function acquireLock(specLoreDir) {
+  const lockPath = join(specLoreDir, LOCK_FILENAME);
+  if (existsSync(lockPath)) {
+    const existing = readLockInfo(lockPath);
+    if (existing && !isLockExpired(existing)) {
+      logger.debug(`Lock already held by PID ${existing.pid}, not expired`);
+      return false;
+    }
+    logger.debug("Removing stale lock file");
+    safeUnlink(lockPath);
+  }
+  const lockInfo = {
+    pid: process.pid,
+    timestamp: Date.now()
+  };
+  try {
+    writeFileSync(lockPath, JSON.stringify(lockInfo), { flag: "wx", encoding: "utf-8" });
+  } catch {
+    logger.debug("Lock write failed \u2014 another process may have acquired it");
+    return false;
+  }
+  logger.debug(`Lock acquired by PID ${process.pid}`);
+  return true;
+}
+function releaseLock(specLoreDir) {
+  const lockPath = join(specLoreDir, LOCK_FILENAME);
+  if (!existsSync(lockPath)) {
+    return;
+  }
+  const existing = readLockInfo(lockPath);
+  if (existing && existing.pid === process.pid) {
+    safeUnlink(lockPath);
+    logger.debug("Lock released");
+  }
+}
+function readLockInfo(lockPath) {
+  try {
+    const content = readFileSync(lockPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed.pid === "number" && typeof parsed.timestamp === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isLockExpired(lockInfo) {
+  if (Date.now() - lockInfo.timestamp > LOCK_EXPIRY_MS) {
+    logger.debug(`Lock expired: age ${Date.now() - lockInfo.timestamp}ms > ${LOCK_EXPIRY_MS}ms`);
+    return true;
+  }
+  if (!isProcessRunning(lockInfo.pid)) {
+    logger.debug(`Lock expired: PID ${lockInfo.pid} not running`);
+    return true;
+  }
+  return false;
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function safeUnlink(filePath) {
+  try {
+    unlinkSync(filePath);
+  } catch {
+  }
+}
+
+// src/mcp/server.ts
+init_logger();
+
+// src/core/requirement-reader/index.ts
+init_logger();
+import { existsSync as existsSync6 } from "fs";
+import { extname as extname6 } from "path";
+
+// src/plugins/registry.ts
+init_logger();
+
+// src/plugins/builtin/md-reader.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+var MarkdownReader = class {
+  name = "markdown-reader";
+  supportedFormats = [".md", ".markdown"];
+  canRead(source) {
+    return /\.md$/i.test(source) || /\.markdown$/i.test(source);
+  }
+  read(source) {
+    if (!existsSync2(source)) {
+      throw new Error(`File not found: ${source}`);
+    }
+    const content = readFileSync2(source, "utf-8");
+    const titleMatch = content.match(/^#\s+(.+)/m);
+    const title = titleMatch?.[1]?.trim() ?? "Untitled";
+    const acceptanceCriteria = [];
+    const acSection = content.match(/##\s*Acceptance\s*(?:Criteria)?[\s\S]*?(?=##|$)/i);
+    if (acSection) {
+      const items = acSection[0].match(/^[-*]\s+\[.\]\s+(.+)/gm);
+      if (items) {
+        acceptanceCriteria.push(...items.map((i) => i.replace(/^[-*]\s+\[.\]\s+/, "")));
+      }
+    }
+    return Promise.resolve([{
+      id: source.replace(/\\/g, "/").replace(/\.md$/i, ""),
+      title,
+      description: content,
+      acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : void 0,
+      rawContent: content,
+      confidence: 0.9
+    }]);
+  }
+};
+
+// src/plugins/builtin/docx-reader.ts
+var DocxReader = class {
+  name = "docx-reader";
+  supportedFormats = [".docx"];
+  canRead(source) {
+    return /\.docx$/i.test(source);
+  }
+  async read(source) {
+    let mammothModule;
+    try {
+      mammothModule = await import("mammoth");
+    } catch {
+      throw new Error("mammoth package is required for DOCX support. Install: npm i mammoth");
+    }
+    const result = await mammothModule.extractRawText({ path: source });
+    const content = result.value;
+    return [{
+      id: source.replace(/\\/g, "/").replace(/\.docx$/i, ""),
+      title: source.split("/").pop()?.replace(/\.docx$/i, "") ?? "Untitled",
+      description: content,
+      rawContent: content,
+      confidence: 0.8
+    }];
+  }
+};
+
+// src/plugins/builtin/xlsx-reader.ts
+import ExcelJS from "exceljs";
+
+// src/infra/excel-utils.ts
+function formatCellValue(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value instanceof Date) return value.toISOString();
+  return "";
+}
+
+// src/plugins/builtin/xlsx-reader.ts
+var XlsxReader = class {
+  name = "xlsx-reader";
+  supportedFormats = [".xlsx", ".xls"];
+  canRead(source) {
+    return /\.xlsx$/i.test(source) || /\.xls$/i.test(source);
+  }
+  async read(source) {
+    const workbook = new ExcelJS.Workbook();
+    await workbook.xlsx.readFile(source);
+    const requirements = [];
+    for (const sheet of workbook.worksheets) {
+      const sheetName = sheet.name;
+      const headers = [];
+      const rows = [];
+      sheet.eachRow((row, rowNumber) => {
+        if (rowNumber === 1) {
+          row.eachCell((cell, colNumber) => {
+            headers[colNumber - 1] = formatCellValue(cell.value);
+          });
+        } else {
+          const obj = {};
+          row.eachCell((cell, colNumber) => {
+            const key = headers[colNumber - 1] ?? `Col${colNumber}`;
+            obj[key] = formatCellValue(cell.value);
+          });
+          rows.push(obj);
+        }
+      });
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const title = row["Title"] ?? row["title"] ?? row["Name"] ?? row["name"] ?? row["ID"] ?? `Row ${i + 1}`;
+        const description = row["Description"] ?? row["description"] ?? row["Desc"] ?? "";
+        const ac = row["Acceptance Criteria"] ?? row["acceptance"] ?? row["AC"] ?? "";
+        if (description || title) {
+          requirements.push({
+            id: `${sheetName}/${i + 1}`,
+            title: String(title),
+            description: String(description),
+            acceptanceCriteria: ac ? String(ac).split("\n").filter(Boolean) : void 0,
+            rawContent: JSON.stringify(row),
+            confidence: 0.7
+          });
+        }
+      }
+    }
+    return requirements;
+  }
+};
+
+// src/plugins/builtin/pdf-reader.ts
+var PdfReader = class {
+  name = "pdf-reader";
+  supportedFormats = [".pdf"];
+  canRead(source) {
+    return /\.pdf$/i.test(source);
+  }
+  async read(source) {
+    let pdfParse;
+    try {
+      const mod = await import("pdf-parse");
+      pdfParse = mod.default ?? mod;
+    } catch {
+      throw new Error("pdf-parse package is required for PDF support. Install: npm i pdf-parse");
+    }
+    const { readFileSync: readFileSync17 } = await import("fs");
+    const buffer = readFileSync17(source);
+    const data = await pdfParse(buffer);
+    return [{
+      id: source.replace(/\\/g, "/").replace(/\.pdf$/i, ""),
+      title: source.split("/").pop()?.replace(/\.pdf$/i, "") ?? "Untitled",
+      description: data.text,
+      rawContent: data.text,
+      confidence: 0.75
+    }];
+  }
+};
+
+// src/plugins/builtin/image-reader.ts
+var ImageReader = class {
+  name = "image-reader";
+  supportedFormats = [".png", ".jpg", ".jpeg", ".webp"];
+  canRead(source) {
+    return /\.(png|jpe?g|webp)$/i.test(source);
+  }
+  async read(source) {
+    const { existsSync: existsSync22, readFileSync: readFileSync17 } = await import("fs");
+    if (!existsSync22(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 = readFileSync17(source);
+    let text;
+    try {
+      const { createProvider: createProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
+      const provider = await createProvider2();
+      if (!provider.generateWithImage) {
+        throw new Error(`Provider '${provider.name}' does not support vision input`);
+      }
+      const result = await provider.generateWithImage(
+        "Extract all text content from this image. Return only the extracted text.",
+        { buffer, mimeType }
+      );
+      text = result.content;
+    } catch {
+      text = `[Image file: ${source} \u2014 OCR not available. Please provide text description manually.]`;
+    }
+    return [{
+      id: source.replace(/\\/g, "/").replace(/\.(png|jpe?g|webp)$/i, ""),
+      title: source.split("/").pop()?.replace(/\.(png|jpe?g|webp)$/i, "") ?? "Untitled",
+      description: text,
+      rawContent: text,
+      confidence: 0.5
+    }];
+  }
+};
+
+// src/plugins/builtin/cursor-writer.ts
+import { writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync3, rmSync } from "fs";
+import { join as join2 } from "path";
+var CursorWriter = class {
+  toolName = "cursor";
+  configFile = ".cursor/rules/speclore.mdc";
+  projectRoot = "";
+  detect(projectRoot2) {
+    return existsSync3(join2(projectRoot2, ".cursor"));
+  }
+  write(constraints) {
+    this.projectRoot = constraints.projectRoot;
+    const rulesDir = join2(constraints.projectRoot, ".cursor", "rules");
+    mkdirSync(rulesDir, { recursive: true });
+    const frontmatter = [
+      "---",
+      "description: SpecLore coding constraints \u2014 auto-generated",
+      "globs:",
+      "alwaysApply: true",
+      "---",
+      ""
+    ].join("\n");
+    const content = frontmatter + this.buildMarkdown(constraints);
+    writeFileSync2(join2(rulesDir, "speclore.mdc"), content, "utf-8");
+    return Promise.resolve();
+  }
+  remove() {
+    const filePath = join2(this.projectRoot, ".cursor", "rules", "speclore.mdc");
+    if (existsSync3(filePath)) rmSync(filePath);
+    return Promise.resolve();
+  }
+  buildMarkdown(c) {
+    const lines = [];
+    lines.push(`# SpecLore Constraints \u2014 ${c.projectName}`);
+    lines.push("");
+    if (c.features.length > 0) {
+      const featurePaths = c.features.map((f) => f.path.replace(/\\/g, "/"));
+      lines.push(`> Profile: ${c.profile} | Generated by SpecLore`);
+      lines.push(`> Source features: ${featurePaths.join(", ")}`);
+    } else {
+      lines.push(`> Profile: ${c.profile} | Generated by SpecLore`);
+    }
+    lines.push("");
+    for (const mod of c.modules) {
+      lines.push(`## Module: ${mod.module}`);
+      lines.push(`**Responsibility**: ${mod.boundaries.responsibility}`);
+      lines.push(`**Depends on**: ${mod.boundaries.dependsOn.join(", ") || "none"}`);
+      lines.push("");
+      if (mod.namingConventions.length > 0) {
+        lines.push("### Naming Conventions");
+        for (const n of mod.namingConventions) lines.push(`- ${n}`);
+        lines.push("");
+      }
+      if (mod.forbiddenPatterns.length > 0) {
+        lines.push("### Forbidden Patterns");
+        for (const f of mod.forbiddenPatterns) lines.push(`- ${f}`);
+        lines.push("");
+      }
+    }
+    if (c.featureRules && c.featureRules.length > 0) {
+      for (const rule of c.featureRules) {
+        lines.push(`## Feature Rules: ${rule.featureName}`);
+        lines.push(`> Source: ${rule.sourceFile}`);
+        lines.push("");
+        for (const sc of rule.scenarios) {
+          lines.push(`- Scenario "${sc.name}": ${sc.summary}`);
+        }
+        lines.push("");
+      }
+    }
+    if (c.scaffoldInfo && c.scaffoldInfo.length > 0) {
+      lines.push("## Test Scaffolding");
+      lines.push("Test files have been generated at:");
+      for (const s of c.scaffoldInfo) {
+        lines.push(`- ${s.testFile} (${s.scenarios} scenarios, ${s.framework})`);
+      }
+      lines.push("");
+      lines.push("Fill in test implementations, then run `speclore verify` to validate.");
+      lines.push("");
+    }
+    if (c.mappingInstructions) {
+      lines.push("## Test Mapping");
+      lines.push(c.mappingInstructions);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/plugins/builtin/claude-writer.ts
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync4, rmSync as rmSync2 } from "fs";
+import { join as join3 } from "path";
+var ClaudeWriter = class {
+  toolName = "claude";
+  configFile = ".claude/rules/speclore.md";
+  projectRoot = "";
+  detect(projectRoot2) {
+    return existsSync4(join3(projectRoot2, ".claude")) || existsSync4(join3(projectRoot2, ".mcp.json"));
+  }
+  write(constraints) {
+    this.projectRoot = constraints.projectRoot;
+    const rulesDir = join3(constraints.projectRoot, ".claude", "rules");
+    mkdirSync2(rulesDir, { recursive: true });
+    const content = this.buildMarkdown(constraints);
+    writeFileSync3(join3(rulesDir, "speclore.md"), content, "utf-8");
+    return Promise.resolve();
+  }
+  remove() {
+    const filePath = join3(this.projectRoot, ".claude", "rules", "speclore.md");
+    if (existsSync4(filePath)) rmSync2(filePath);
+    return Promise.resolve();
+  }
+  buildMarkdown(c) {
+    const lines = [];
+    lines.push(`# SpecLore Constraints \u2014 ${c.projectName}`);
+    lines.push("");
+    if (c.features.length > 0) {
+      const featurePaths = c.features.map((f) => f.path.replace(/\\/g, "/"));
+      lines.push(`> Profile: ${c.profile} | Generated by SpecLore`);
+      lines.push(`> Source features: ${featurePaths.join(", ")}`);
+    } else {
+      lines.push(`> Profile: ${c.profile} | Generated by SpecLore`);
+    }
+    lines.push("");
+    for (const mod of c.modules) {
+      lines.push(`## Module: ${mod.module}`);
+      lines.push(`- **Responsibility**: ${mod.boundaries.responsibility}`);
+      lines.push(`- **Depends on**: ${mod.boundaries.dependsOn.join(", ") || "none"}`);
+      if (mod.namingConventions.length > 0) {
+        lines.push(`- **Naming**: ${mod.namingConventions.join("; ")}`);
+      }
+      if (mod.forbiddenPatterns.length > 0) {
+        lines.push(`- **Forbidden**: ${mod.forbiddenPatterns.join("; ")}`);
+      }
+      lines.push("");
+    }
+    if (c.featureRules && c.featureRules.length > 0) {
+      for (const rule of c.featureRules) {
+        lines.push(`## Feature Rules: ${rule.featureName}`);
+        lines.push(`> Source: ${rule.sourceFile}`);
+        lines.push("");
+        for (const sc of rule.scenarios) {
+          lines.push(`- Scenario "${sc.name}": ${sc.summary}`);
+        }
+        lines.push("");
+      }
+    }
+    if (c.scaffoldInfo && c.scaffoldInfo.length > 0) {
+      lines.push("## Test Scaffolding");
+      lines.push("Test files have been generated at:");
+      for (const s of c.scaffoldInfo) {
+        lines.push(`- ${s.testFile} (${s.scenarios} scenarios, ${s.framework})`);
+      }
+      lines.push("");
+      lines.push("Fill in test implementations, then run `speclore verify` to validate.");
+      lines.push("");
+    }
+    if (c.mappingInstructions) {
+      lines.push("## Test Mapping");
+      lines.push(c.mappingInstructions);
+    }
+    return lines.join("\n");
+  }
+};
+
+// 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";
+var QoderWriter = class {
+  toolName = "qoder";
+  configFile = ".qoder/rules/speclore.md";
+  projectRoot = "";
+  detect(projectRoot2) {
+    return existsSync5(join4(projectRoot2, ".qoder"));
+  }
+  write(constraints) {
+    this.projectRoot = constraints.projectRoot;
+    const rulesDir = join4(constraints.projectRoot, ".qoder", "rules");
+    mkdirSync3(rulesDir, { recursive: true });
+    const content = this.buildMarkdown(constraints);
+    writeFileSync4(join4(rulesDir, "speclore.md"), content, "utf-8");
+    return Promise.resolve();
+  }
+  remove() {
+    const filePath = join4(this.projectRoot, ".qoder", "rules", "speclore.md");
+    if (existsSync5(filePath)) rmSync3(filePath);
+    return Promise.resolve();
+  }
+  buildMarkdown(c) {
+    const lines = [];
+    lines.push(`# SpecLore Constraints \u2014 ${c.projectName}`);
+    lines.push("");
+    if (c.features.length > 0) {
+      const featurePaths = c.features.map((f) => {
+        const rel = f.path.replace(/\\/g, "/");
+        return rel;
+      });
+      lines.push(`> Profile: ${c.profile} | Generated by SpecLore`);
+      lines.push(`> Source features: ${featurePaths.join(", ")}`);
+    } else {
+      lines.push(`> Profile: ${c.profile} | Generated by SpecLore`);
+    }
+    lines.push("");
+    for (const mod of c.modules) {
+      lines.push(`## Module: ${mod.module}`);
+      lines.push(`- **Responsibility**: ${mod.boundaries.responsibility}`);
+      lines.push(`- **Depends on**: ${mod.boundaries.dependsOn.join(", ") || "none"}`);
+      if (mod.namingConventions.length > 0) {
+        lines.push(`- **Naming**: ${mod.namingConventions.join("; ")}`);
+      }
+      if (mod.forbiddenPatterns.length > 0) {
+        lines.push(`- **Forbidden**: ${mod.forbiddenPatterns.join("; ")}`);
+      }
+      lines.push("");
+    }
+    if (c.featureRules && c.featureRules.length > 0) {
+      for (const rule of c.featureRules) {
+        lines.push(`## Feature Rules: ${rule.featureName}`);
+        lines.push(`> Source: ${rule.sourceFile}`);
+        lines.push("");
+        for (const sc of rule.scenarios) {
+          lines.push(`- Scenario "${sc.name}": ${sc.summary}`);
+        }
+        lines.push("");
+      }
+    }
+    if (c.scaffoldInfo && c.scaffoldInfo.length > 0) {
+      lines.push("## Test Scaffolding");
+      lines.push("Test files have been generated at:");
+      for (const s of c.scaffoldInfo) {
+        lines.push(`- ${s.testFile} (${s.scenarios} scenarios, ${s.framework})`);
+      }
+      lines.push("");
+      lines.push("Fill in test implementations, then run `speclore verify` to validate.");
+      lines.push("");
+    }
+    if (c.mappingInstructions) {
+      lines.push("## Test Mapping");
+      lines.push(c.mappingInstructions);
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/plugins/builtin/junit-parser.ts
+var JUnitParser = class {
+  framework = "junit";
+  canParse(testOutput) {
+    return testOutput.trimStart().startsWith("<?xml") || testOutput.includes("<testsuite");
+  }
+  parse(testOutput, _features) {
+    const results = [];
+    const testcaseRegex = /<testcase\s+([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g;
+    let match;
+    while ((match = testcaseRegex.exec(testOutput)) !== null) {
+      const attrs = match[1];
+      const body = match[2] ?? "";
+      const name = extractAttr(attrs, "name") ?? "unknown";
+      const classname = extractAttr(attrs, "classname") ?? "";
+      const time = extractAttr(attrs, "time");
+      const failureMatch = body.match(/<failure[^>]*>([\s\S]*?)<\/failure>/);
+      const skippedMatch = body.match(/<skipped/);
+      let status = "passed";
+      let error;
+      if (failureMatch) {
+        status = "failed";
+        error = failureMatch[1].trim();
+      } else if (skippedMatch) {
+        status = "skipped";
+      }
+      results.push({
+        name,
+        status,
+        duration: time ? `${time}s` : void 0,
+        testMethod: classname ? `${classname}.${name}` : name,
+        error
+      });
+    }
+    return results;
+  }
+};
+function extractAttr(attrs, name) {
+  const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
+  return match?.[1];
+}
+
+// src/plugins/builtin/jest-parser.ts
+var JestParser = class {
+  framework = "jest";
+  canParse(testOutput) {
+    const trimmed = testOutput.trim();
+    return trimmed.startsWith("{") && trimmed.includes('"testResults"');
+  }
+  parse(testOutput, _features) {
+    let json;
+    try {
+      json = JSON.parse(testOutput);
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (const file of json.testResults ?? []) {
+      for (const assertion of file.assertionResults ?? []) {
+        let status = "passed";
+        switch (assertion.status) {
+          case "failed":
+            status = "failed";
+            break;
+          case "skipped":
+          case "pending":
+          case "todo":
+            status = "skipped";
+            break;
+          default:
+            status = "passed";
+        }
+        results.push({
+          name: assertion.title ?? assertion.fullName ?? "unknown",
+          status,
+          duration: assertion.duration != null ? `${assertion.duration}ms` : void 0,
+          testFile: file.name,
+          testMethod: assertion.fullName,
+          error: assertion.failureMessages?.join("\n")
+        });
+      }
+    }
+    return results;
+  }
+};
+
+// src/plugins/builtin/vitest-parser.ts
+var VitestParser = class {
+  framework = "vitest";
+  canParse(testOutput) {
+    const trimmed = testOutput.trim();
+    return trimmed.startsWith("{") && (trimmed.includes('"testResults"') || trimmed.includes('"numTotalTests"'));
+  }
+  parse(testOutput, _features) {
+    let json;
+    try {
+      json = JSON.parse(testOutput);
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (const file of json.testResults ?? []) {
+      for (const assertion of file.assertionResults ?? []) {
+        let status = "passed";
+        switch (assertion.status) {
+          case "failed":
+            status = "failed";
+            break;
+          case "skipped":
+          case "pending":
+          case "todo":
+            status = "skipped";
+            break;
+          default:
+            status = "passed";
+        }
+        results.push({
+          name: assertion.title ?? assertion.fullName ?? "unknown",
+          status,
+          duration: assertion.duration != null ? `${Math.round(assertion.duration)}ms` : void 0,
+          testFile: file.name,
+          testMethod: assertion.fullName,
+          error: assertion.failureMessages?.join("\n")
+        });
+      }
+    }
+    return results;
+  }
+};
+
+// src/plugins/registry.ts
+function isReaderPlugin(mod) {
+  return typeof mod === "object" && mod !== null && typeof mod.canRead === "function" && typeof mod.read === "function" && typeof mod.name === "string";
+}
+function isWriterPlugin(mod) {
+  return typeof mod === "object" && mod !== null && typeof mod.detect === "function" && typeof mod.write === "function" && typeof mod.toolName === "string";
+}
+function isParserPlugin(mod) {
+  return typeof mod === "object" && mod !== null && typeof mod.canParse === "function" && typeof mod.parse === "function" && typeof mod.framework === "string";
+}
+var PluginRegistry = class {
+  readers = [];
+  writers = [];
+  parsers = [];
+  lifecycleHooks = [];
+  /** Register all built-in plugins */
+  registerBuiltins() {
+    this.readers.push(
+      new MarkdownReader(),
+      new DocxReader(),
+      new XlsxReader(),
+      new PdfReader(),
+      new ImageReader()
+    );
+    this.writers.push(
+      new CursorWriter(),
+      new ClaudeWriter(),
+      new QoderWriter()
+    );
+    this.parsers.push(
+      new JUnitParser(),
+      new JestParser(),
+      new VitestParser()
+    );
+  }
+  /** Load third-party plugins from config */
+  async loadExternal(config) {
+    if (!config.plugins) return;
+    if (config.plugins.readers) {
+      for (const ref of config.plugins.readers) {
+        try {
+          const mod = await import(ref.package);
+          const plugin = mod.default ?? mod;
+          if (isReaderPlugin(plugin)) {
+            this.readers.push(plugin);
+            logger.debug(`Loaded external reader plugin: ${ref.name}`);
+          } else {
+            logger.warn(`Plugin ${ref.name} does not implement ReaderPlugin interface`);
+          }
+        } catch (err) {
+          logger.warn(`Failed to load reader plugin ${ref.name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+    if (config.plugins.writers) {
+      for (const ref of config.plugins.writers) {
+        try {
+          const mod = await import(ref.package);
+          const plugin = mod.default ?? mod;
+          if (isWriterPlugin(plugin)) {
+            this.writers.push(plugin);
+            logger.debug(`Loaded external writer plugin: ${ref.name}`);
+          } else {
+            logger.warn(`Plugin ${ref.name} does not implement WriterPlugin interface`);
+          }
+        } catch (err) {
+          logger.warn(`Failed to load writer plugin ${ref.name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+    if (config.plugins.parsers) {
+      for (const ref of config.plugins.parsers) {
+        try {
+          const mod = await import(ref.package);
+          const plugin = mod.default ?? mod;
+          if (isParserPlugin(plugin)) {
+            this.parsers.push(plugin);
+            logger.debug(`Loaded external parser plugin: ${ref.name}`);
+          } else {
+            logger.warn(`Plugin ${ref.name} does not implement ParserPlugin interface`);
+          }
+        } catch (err) {
+          logger.warn(`Failed to load parser plugin ${ref.name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+  }
+  /** Find a reader that can handle the given source */
+  findReader(source) {
+    return this.readers.find((r) => r.canRead(source));
+  }
+  /** Find a writer for the given AI tool */
+  findWriter(toolName) {
+    return this.writers.find((w) => w.toolName === toolName);
+  }
+  /** Find a parser for the given test output */
+  findParser(testOutput) {
+    return this.parsers.find((p) => p.canParse(testOutput));
+  }
+  /** Get all registered readers */
+  getReaders() {
+    return [...this.readers];
+  }
+  /** Get all registered writers */
+  getWriters() {
+    return [...this.writers];
+  }
+  /** Get all registered parsers */
+  getParsers() {
+    return [...this.parsers];
+  }
+  /** Register a lifecycle hook */
+  registerLifecycle(hook) {
+    this.lifecycleHooks.push(hook);
+    logger.debug("Registered plugin lifecycle hook");
+  }
+  /** Invoke a lifecycle event on all registered hooks */
+  async invokeLifecycle(event, ...args) {
+    for (const hook of this.lifecycleHooks) {
+      const fn = hook[event];
+      if (typeof fn === "function") {
+        try {
+          await fn(...args);
+        } catch (err) {
+          logger.warn(`Lifecycle hook '${event}' failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+  }
+};
+var _registry = null;
+function getRegistry() {
+  if (!_registry) {
+    _registry = new PluginRegistry();
+    _registry.registerBuiltins();
+  }
+  return _registry;
+}
+
+// src/core/requirement-reader/markdown-reader.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { basename, extname } from "path";
+function readMarkdownFile(filePath) {
+  const content = readFileSync3(filePath, "utf-8");
+  const id = deriveId(filePath);
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  const title = titleMatch?.[1]?.trim() ?? basename(filePath, extname(filePath));
+  const acceptanceCriteria = extractAcceptanceCriteria(content);
+  const dependencies = extractDependencies(content);
+  return Promise.resolve({
+    id,
+    title,
+    description: content,
+    acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : void 0,
+    dependencies: dependencies.length > 0 ? dependencies : void 0,
+    rawContent: content,
+    confidence: 1
+  });
+}
+function deriveId(filePath) {
+  const name = basename(filePath, extname(filePath));
+  return name.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-");
+}
+function extractAcceptanceCriteria(content) {
+  const criteria = [];
+  const sectionRegex = /#{1,4}\s*(?:Acceptance Criteria|验收标准|验收条件)\s*\n([\s\S]*?)(?=\n#{1,4}\s|\n---|$)/gi;
+  const match = sectionRegex.exec(content);
+  if (match) {
+    const section = match[1];
+    const bulletRegex = /^\s*[-*]\s+(.+)$/gm;
+    let bullet;
+    while ((bullet = bulletRegex.exec(section)) !== null) {
+      criteria.push(bullet[1].trim());
+    }
+  }
+  return criteria;
+}
+function extractDependencies(content) {
+  const deps = [];
+  const depRegex = /(?:Depends on|依赖)[:\s]+(.+)/gi;
+  const match = depRegex.exec(content);
+  if (match) {
+    const depList = match[1];
+    const items = depList.split(/[,;，；]/);
+    for (const item of items) {
+      const trimmed = item.trim().replace(/^[\s`]+|[\s`]+$/g, "");
+      if (trimmed) deps.push(trimmed);
+    }
+  }
+  return deps;
+}
+
+// src/core/requirement-reader/docx-reader.ts
+import { basename as basename2, extname as extname2 } from "path";
+import mammoth from "mammoth";
+async function readDocxFile(filePath) {
+  const result = await mammoth.extractRawText({ path: filePath });
+  const content = result.value;
+  const id = basename2(filePath, extname2(filePath)).toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-");
+  const lines = content.split("\n").filter((l) => l.trim());
+  const title = lines[0]?.trim() ?? id;
+  return {
+    id,
+    title,
+    description: content,
+    rawContent: content,
+    confidence: 0.9
+  };
+}
+
+// src/core/requirement-reader/xlsx-reader.ts
+import { basename as basename3, extname as extname3 } from "path";
+import ExcelJS2 from "exceljs";
+async function readXlsxFile(filePath) {
+  const workbook = new ExcelJS2.Workbook();
+  await workbook.xlsx.readFile(filePath);
+  const id = basename3(filePath, extname3(filePath)).toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-");
+  const sheet = workbook.worksheets[0];
+  if (!sheet) {
+    throw new Error(`No sheets found in ${filePath}`);
+  }
+  const title = sheet.name;
+  const headers = [];
+  const rows = [];
+  sheet.eachRow((row, rowNumber) => {
+    if (rowNumber === 1) {
+      row.eachCell((cell, colNumber) => {
+        headers[colNumber - 1] = formatCellValue(cell.value);
+      });
+    } else {
+      const obj = {};
+      row.eachCell((cell, colNumber) => {
+        const key = headers[colNumber - 1] ?? `Col${colNumber}`;
+        obj[key] = formatCellValue(cell.value);
+      });
+      rows.push(obj);
+    }
+  });
+  const textRows = rows.map((row) => {
+    const cells = Object.entries(row).map(([key, value]) => `${key}: ${value}`).join(" | ");
+    return cells;
+  });
+  const content = textRows.join("\n");
+  return {
+    id,
+    title,
+    description: content,
+    rawContent: content,
+    confidence: 0.85
+  };
+}
+
+// src/core/requirement-reader/pdf-reader.ts
+import { basename as basename4, extname as extname4 } from "path";
+import { readFile } from "fs/promises";
+async function readPdfFile(filePath) {
+  const pdfParse = (await import("pdf-parse")).default;
+  const dataBuffer = await readFile(filePath);
+  const data = await pdfParse(dataBuffer);
+  const id = basename4(filePath, extname4(filePath)).toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-");
+  const lines = data.text.split("\n").filter((l) => l.trim());
+  const title = lines[0]?.trim() ?? id;
+  return {
+    id,
+    title,
+    description: data.text,
+    rawContent: data.text,
+    confidence: 0.8
+  };
+}
+
+// src/core/requirement-reader/image-reader.ts
+init_provider();
+init_logger();
+import { basename as basename5, extname as extname5 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+var MIME_MAP = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp"
+};
+async function readImageFile(filePath) {
+  const id = basename5(filePath, extname5(filePath)).toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]/g, "-").replace(/-+/g, "-");
+  logger.info(`Reading image via AI Vision: ${filePath}`);
+  const ext = extname5(filePath).toLowerCase();
+  const mimeType = MIME_MAP[ext] ?? "image/png";
+  const buffer = readFileSync4(filePath);
+  const provider = await createProvider();
+  const prompt = `Please extract all text content from this image. Return the text as-is, preserving structure and formatting. If the image contains a table, convert it to a structured text format.`;
+  if (!provider.generateWithImage) {
+    throw new Error(`AI provider '${provider.name}' does not support image/vision input. Use a vision-capable model.`);
+  }
+  const result = await provider.generateWithImage(prompt, { buffer, mimeType });
+  return {
+    id,
+    title: result.content.split("\n")[0]?.slice(0, 100) ?? id,
+    description: result.content,
+    rawContent: result.content,
+    confidence: 0.7
+    // Lower confidence for OCR
+  };
+}
+
+// src/core/requirement-reader/url-reader.ts
+init_logger();
+import { basename as basename6 } from "path";
+var FETCH_TIMEOUT_MS = 1e4;
+var MAX_CONTENT_LENGTH = 1e5;
+async function readUrl(url) {
+  validateUrl(url);
+  logger.info(`Fetching URL: ${url}`);
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": "SpecLore/0.1.0 (+https://github.com/nicepkg/speclore)",
+        "Accept": "text/html,application/json,text/plain,*/*"
+      }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new UrlAuthError(url, response.status);
+      }
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    let content;
+    let title = url;
+    if (contentType.includes("html")) {
+      const html = await response.text();
+      const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+      title = titleMatch?.[1]?.trim() ?? url;
+      content = extractTextFromHtml(html);
+    } else {
+      content = await response.text();
+      const headingMatch = content.match(/^#\s+(.+)/m);
+      if (headingMatch) title = headingMatch[1].trim();
+    }
+    if (content.length > MAX_CONTENT_LENGTH) {
+      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";
+    return {
+      id,
+      title,
+      description: content,
+      rawContent: content,
+      confidence: 0.85
+    };
+  } catch (error) {
+    if (error instanceof UrlAuthError) {
+      logger.warn(`URL requires authentication: ${url}`);
+      throw error;
+    }
+    if (error instanceof DOMException && error.name === "AbortError") {
+      throw new Error(`URL fetch timed out after ${FETCH_TIMEOUT_MS}ms: ${url}`);
+    }
+    throw error;
+  }
+}
+function validateUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  if (parsed.protocol === "file:") {
+    throw new Error("file:// protocol is not allowed. Use a file path instead.");
+  }
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new Error(`Unsupported protocol: ${parsed.protocol}. Only http/https allowed.`);
+  }
+}
+function extractTextFromHtml(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
+}
+var UrlAuthError = class extends Error {
+  constructor(url, status) {
+    super(`URL requires authentication (${status}): ${url}. Please paste the content manually.`);
+    this.url = url;
+    this.status = status;
+    this.name = "UrlAuthError";
+  }
+  url;
+  status;
+};
+
+// src/core/requirement-reader/index.ts
+async function readRequirement(source) {
+  const sourceType = classifySource(source);
+  logger.info(`Reading requirement from ${sourceType}: ${truncate(source, 80)}`);
+  switch (sourceType) {
+    case "file":
+      return readFromFile(source);
+    case "url":
+      return readFromUrl(source);
+    case "text":
+      return readFromText(source);
+  }
+}
+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)) {
+    return "file";
+  }
+  if (existsSync6(source) && (source.includes("/") || source.includes("\\"))) {
+    return "file";
+  }
+  return "text";
+}
+async function readFromFile(filePath) {
+  const registry = getRegistry();
+  const reader = registry.findReader(filePath);
+  if (reader) {
+    logger.debug(`Using reader plugin: ${reader.name}`);
+    const results = await reader.read(filePath);
+    if (results.length === 0) {
+      throw new Error(`Reader plugin '${reader.name}' returned no results for: ${filePath}`);
+    }
+    return results[0];
+  }
+  const ext = extname6(filePath).toLowerCase();
+  switch (ext) {
+    case ".md":
+      return readMarkdownFile(filePath);
+    case ".docx":
+      return readDocxFile(filePath);
+    case ".xlsx":
+    case ".xls":
+      return readXlsxFile(filePath);
+    case ".pdf":
+      return readPdfFile(filePath);
+    case ".png":
+    case ".jpg":
+    case ".jpeg":
+    case ".webp":
+      return readImageFile(filePath);
+    default:
+      throw new Error(`Unsupported file format: ${ext}`);
+  }
+}
+async function readFromUrl(url) {
+  return readUrl(url);
+}
+function readFromText(text) {
+  const id = text.split(/\s+/).slice(0, 3).map((w) => w.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff]/g, "")).filter(Boolean).join("-") || "requirement";
+  return Promise.resolve({
+    id,
+    title: text.split("\n")[0]?.slice(0, 100) ?? id,
+    description: text,
+    rawContent: text,
+    confidence: 1
+  });
+}
+function truncate(str, maxLen) {
+  return str.length > maxLen ? str.slice(0, maxLen) + "..." : str;
+}
+
+// src/core/feature-generator/generator.ts
+init_provider();
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync7 } 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";
+
+// src/ai/output-validator.ts
+init_logger();
+import { Parser, GherkinClassicTokenMatcher, AstBuilder } from "@cucumber/gherkin";
+import { IdGenerator } from "@cucumber/messages";
+function validateFeatureOutput(content) {
+  const errors = [];
+  let scenarioCount = 0;
+  if (!content || content.trim().length === 0) {
+    return { valid: false, errors: ["Empty response from AI provider"], scenarioCount: 0 };
+  }
+  if (!/Feature:/.test(content)) {
+    errors.push('Missing "Feature:" keyword \u2014 AI must generate a Gherkin Feature block');
+  }
+  if (!/Scenario:/.test(content)) {
+    errors.push('Missing "Scenario:" keyword \u2014 AI must generate at least one Scenario');
+  }
+  try {
+    const idGen = IdGenerator.incrementing();
+    const builder = new AstBuilder(idGen);
+    const matcher = new GherkinClassicTokenMatcher();
+    const parser = new Parser(builder, matcher);
+    const doc = parser.parse(content);
+    if (doc.feature?.children) {
+      scenarioCount = doc.feature.children.filter((c) => c.scenario !== void 0).length;
+    }
+    if (scenarioCount === 0) {
+      errors.push("Parsed successfully but contains no scenarios");
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    errors.push(`Gherkin syntax error: ${message}`);
+    logger.debug(`Gherkin validation error: ${message}`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    scenarioCount
+  };
+}
+
+// src/core/feature-generator/generator.ts
+init_cost_tracker();
+
+// src/ai/token-counter.ts
+var MODEL_CONTEXT_WINDOWS = {
+  // OpenAI
+  "gpt-4": 8192,
+  "gpt-4-turbo": 128e3,
+  "gpt-4o": 128e3,
+  "gpt-4o-mini": 128e3,
+  "gpt-4o-2024-08-06": 128e3,
+  "gpt-3.5-turbo": 16385,
+  "o1-preview": 128e3,
+  "o1-mini": 128e3,
+  // Anthropic
+  "claude-3-5-sonnet-20241022": 2e5,
+  "claude-3-5-haiku-20241022": 2e5,
+  "claude-3-opus-20240229": 2e5,
+  "claude-sonnet-4-20250514": 2e5,
+  // Meta / Ollama common models
+  "llama3": 8192,
+  "llama3:8b": 8192,
+  "llama3:70b": 8192,
+  "llama3.1": 128e3,
+  "llama3.1:8b": 128e3,
+  "llama3.1:70b": 128e3,
+  "mistral": 8192,
+  "mixtral": 32768,
+  "codellama": 16384,
+  "phi3": 128e3,
+  "gemma2": 8192
+};
+var DEFAULT_CONTEXT_WINDOW = 8192;
+function isCJK(char) {
+  const code = char.codePointAt(0) ?? 0;
+  return code >= 19968 && code <= 40959 || // CJK Unified Ideographs
+  code >= 13312 && code <= 19903 || // CJK Extension A
+  code >= 63744 && code <= 64255 || // CJK Compatibility Ideographs
+  code >= 12288 && code <= 12351 || // CJK Symbols and Punctuation
+  code >= 12352 && code <= 12447 || // Hiragana
+  code >= 12448 && code <= 12543 || // Katakana
+  code >= 44032 && code <= 55215;
+}
+function estimateTokenCount(text) {
+  if (!text || text.length === 0) return 0;
+  let cjkChars = 0;
+  let otherChars = 0;
+  for (const char of text) {
+    if (isCJK(char)) {
+      cjkChars++;
+    } else {
+      otherChars++;
+    }
+  }
+  const cjkTokens = cjkChars / 1.5;
+  const latinTokens = otherChars / 4;
+  return Math.ceil(cjkTokens + latinTokens);
+}
+function getModelContextWindow(model) {
+  if (MODEL_CONTEXT_WINDOWS[model]) {
+    return MODEL_CONTEXT_WINDOWS[model];
+  }
+  const sortedEntries = Object.entries(MODEL_CONTEXT_WINDOWS).sort((a, b) => b[0].length - a[0].length);
+  for (const [prefix, window] of sortedEntries) {
+    if (model.startsWith(prefix)) {
+      return window;
+    }
+  }
+  return DEFAULT_CONTEXT_WINDOW;
+}
+function estimateTokens(prompt, model) {
+  const tokenCount = estimateTokenCount(prompt);
+  const modelContextWindow = getModelContextWindow(model);
+  return {
+    tokenCount,
+    exceedsLimit: tokenCount > modelContextWindow,
+    modelContextWindow
+  };
+}
+
+// src/ai/prompt-templates.ts
+function renderTemplate(template, variables) {
+  let system = template.system;
+  let user = template.user;
+  for (const [key, value] of Object.entries(variables)) {
+    const placeholder = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+    system = system.replace(placeholder, value);
+    user = user.replace(placeholder, value);
+  }
+  return { system, user };
+}
+function combinePrompt(system, user) {
+  return `${system}
+
+${user}`;
+}
+var FEATURE_GENERATION_TEMPLATE = {
+  name: "feature-generation",
+  system: `You are a BDD expert. Convert requirements into valid Gherkin .feature files.
+Follow industry best practices for BDD scenario design:
+- Each scenario should be independent and testable
+- Use concrete examples, not abstract descriptions
+- Cover happy path, error cases, and edge cases as appropriate
+- Use the same language as the requirement input`,
+  user: `## Project Context
+- Language: {{language}}
+- Framework: {{framework}}
+
+## Module Boundaries
+{{moduleBoundaries}}
+
+## Existing Entities
+{{existingEntities}}
+
+## Requirement
+{{requirement}}
+
+## Acceptance Criteria
+{{acceptanceCriteria}}
+
+## Output Format
+Generate a valid Gherkin .feature file with:
+- Feature: line with a descriptive name
+- Scenario: blocks with Given/When/Then steps
+- Each scenario should be testable and independent`,
+  variables: ["language", "framework", "moduleBoundaries", "existingEntities", "requirement", "acceptanceCriteria"]
+};
+
+// src/core/feature-generator/prompt-builder.ts
+function buildPrompt(requirement, context, config) {
+  const moduleBoundaries = context.moduleBoundaries.length > 0 ? context.moduleBoundaries.map((mod) => {
+    let line = `- **${mod.name}**: ${mod.responsibility}`;
+    if (mod.publicApis.length > 0) {
+      line += `
+  - Public APIs: ${mod.publicApis.join(", ")}`;
+    }
+    return line;
+  }).join("\n") : "(none)";
+  const existingEntities = context.existingCode.entities.length > 0 ? context.existingCode.entities.slice(0, 20).map((e) => `- ${e.name} (${e.module})`).join("\n") : "(none)";
+  const acceptanceCriteria = requirement.acceptanceCriteria && requirement.acceptanceCriteria.length > 0 ? requirement.acceptanceCriteria.map((ac) => `- ${ac}`).join("\n") : "(none)";
+  const { system, user } = renderTemplate(FEATURE_GENERATION_TEMPLATE, {
+    language: context.projectSummary.language,
+    framework: context.projectSummary.framework,
+    moduleBoundaries,
+    existingEntities,
+    requirement: requirement.description,
+    acceptanceCriteria
+  });
+  const parts = [];
+  if (config.project.profile === "strict") {
+    parts.push("");
+    parts.push("## Strict Mode");
+    parts.push("- Include edge cases and error scenarios");
+    parts.push("- Add boundary condition scenarios");
+    parts.push("- Cover all acceptance criteria explicitly");
+  } else if (config.project.profile === "minimal") {
+    parts.push("");
+    parts.push("## Minimal Mode");
+    parts.push("- Only include the happy path and 1-2 critical error scenarios");
+    parts.push("- Keep scenarios concise");
+  }
+  const basePrompt = combinePrompt(system, user);
+  return parts.length > 0 ? basePrompt + "\n" + parts.join("\n") : basePrompt;
+}
+
+// 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) {
+  logger.info(`Generating feature for: ${requirement.title}`);
+  const registry = getRegistry();
+  await registry.invokeLifecycle("beforeSpec", requirement);
+  let prompt = buildPrompt(requirement, context, config);
+  const aiConfig = config.ai;
+  const fallbackConfigs = aiConfig?.fallbackProviders ?? [];
+  const providerConfigs = aiConfig ? [aiConfig, ...fallbackConfigs] : [];
+  const provider = providerConfigs.length > 1 ? await createProviderChain(providerConfigs) : await createProvider(aiConfig);
+  if (!provider.isAvailable()) {
+    throw new Error("AI provider not available. Set API key in environment or config.yaml.");
+  }
+  const costTracker = getCostTracker();
+  const budgetLimit = costTracker.getBudgetLimit();
+  if (budgetLimit < Infinity) {
+    const summary = costTracker.getUsageSummary();
+    const usageRatio = summary.totalCostUsd / budgetLimit;
+    if (usageRatio >= 0.9) {
+      logger.warn(`Budget warning: $${summary.totalCostUsd.toFixed(4)} of $${budgetLimit.toFixed(2)} used (${(usageRatio * 100).toFixed(0)}%). Calls may be rejected.`);
+    }
+  }
+  if (aiConfig?.model) {
+    const tokenEstimate = estimateTokens(prompt, aiConfig.model);
+    if (tokenEstimate.exceedsLimit) {
+      logger.warn(`Prompt estimated at ${tokenEstimate.tokenCount} tokens, exceeds ${aiConfig.model} context window of ${tokenEstimate.modelContextWindow} tokens.`);
+    }
+  }
+  let featureContent = "";
+  let forceNeedsReview = false;
+  for (let attempt = 0; attempt <= MAX_VALIDATION_RETRIES; attempt++) {
+    const result = await provider.generate(prompt);
+    const validation = validateFeatureOutput(result.content);
+    if (validation.valid) {
+      featureContent = result.content;
+      break;
+    }
+    if (attempt < MAX_VALIDATION_RETRIES) {
+      logger.warn(
+        `AI output validation failed (attempt ${attempt + 1}/${MAX_VALIDATION_RETRIES + 1}): ${validation.errors.join("; ")}. Retrying with error feedback.`
+      );
+      prompt = `${prompt}
+
+## Previous Output Had Errors
+${validation.errors.map((e) => `- ${e}`).join("\n")}
+
+Please fix these issues and regenerate the complete Feature file.`;
+    } else {
+      logger.error(
+        `AI output validation failed after ${MAX_VALIDATION_RETRIES + 1} attempts. Writing raw content with needsReview flag.`
+      );
+      featureContent = result.content;
+      forceNeedsReview = true;
+    }
+  }
+  const featureFile = parseFeatureContent(featureContent, requirement, config);
+  if (forceNeedsReview && featureFile.needsReview.length === 0) {
+    featureFile.needsReview = featureFile.scenarios.map((s) => s.name);
+    if (featureFile.needsReview.length === 0) {
+      featureFile.needsReview = [requirement.title];
+    }
+  }
+  const outputDir = join6(projectRoot2, config.spec.outputDir);
+  const moduleDir = inferModule(requirement, context);
+  const filePath = join6(outputDir, moduleDir, `${requirement.id}.feature`);
+  if (!existsSync7(dirname(filePath))) {
+    mkdirSync4(dirname(filePath), { recursive: true });
+  }
+  writeFileSync5(filePath, featureContent, "utf-8");
+  logger.info(`Feature written: ${toPosixPath(filePath)}`);
+  featureFile.path = toPosixPath(filePath);
+  await registry.invokeLifecycle("afterSpec", featureFile);
+  return featureFile;
+}
+function parseFeatureContent(content, requirement, config) {
+  if (!content || content.trim().length === 0) {
+    logger.warn("AI returned empty content");
+    return {
+      path: "",
+      featureName: requirement.title,
+      scenarios: [],
+      tags: [],
+      confidence: 0,
+      needsReview: [requirement.title]
+    };
+  }
+  const idGen = IdGenerator2.incrementing();
+  const builder = new AstBuilder2(idGen);
+  const matcher = new GherkinClassicTokenMatcher2();
+  const parser = new Parser2(builder, matcher);
+  let gherkinDoc;
+  try {
+    gherkinDoc = parser.parse(content);
+  } catch (err) {
+    logger.warn(`Gherkin parse failed: ${err instanceof Error ? err.message : String(err)}`);
+    return {
+      path: "",
+      featureName: requirement.title,
+      scenarios: [],
+      tags: [],
+      confidence: 0,
+      needsReview: [requirement.title]
+    };
+  }
+  const feature = gherkinDoc.feature;
+  if (!feature) {
+    return {
+      path: "",
+      featureName: requirement.title,
+      scenarios: [],
+      tags: [],
+      confidence: 0,
+      needsReview: [requirement.title]
+    };
+  }
+  const tags = (feature.tags ?? []).map((t) => t.name.replace(/^@/, ""));
+  const scenarios = [];
+  for (const child of feature.children ?? []) {
+    if (!child.scenario) continue;
+    const sc = child.scenario;
+    const givens = extractStepsByType(sc.steps, "Context");
+    const whens = extractStepsByType(sc.steps, "Action");
+    const thens = extractStepsByType(sc.steps, "Outcome");
+    scenarios.push({
+      name: sc.name,
+      givens,
+      whens,
+      thens,
+      tags: (sc.tags ?? []).map((t) => t.name.replace(/^@/, ""))
+    });
+  }
+  const needsReview = [];
+  if (requirement.confidence < config.spec.confidenceThreshold) {
+    for (const s of scenarios) {
+      needsReview.push(s.name);
+    }
+  }
+  return {
+    path: "",
+    // Will be set by caller
+    featureName: feature.name ?? requirement.title,
+    scenarios,
+    tags,
+    confidence: requirement.confidence,
+    needsReview
+  };
+}
+function extractStepsByType(steps, targetType) {
+  const result = [];
+  let inTargetBlock = false;
+  for (const step of steps) {
+    const kwType = step.keywordType ?? "";
+    if (kwType === targetType) {
+      inTargetBlock = true;
+      result.push({
+        keyword: mapKeyword(step.keyword.trim()),
+        text: step.text
+      });
+    } else if (kwType === "Conjunction" && inTargetBlock) {
+      result.push({
+        keyword: mapKeyword(step.keyword.trim()),
+        text: step.text
+      });
+    } else {
+      inTargetBlock = false;
+    }
+  }
+  return result;
+}
+function mapKeyword(keyword) {
+  switch (keyword) {
+    case "Given":
+      return "Given";
+    case "When":
+      return "When";
+    case "Then":
+      return "Then";
+    case "And":
+      return "And";
+    case "But":
+      return "But";
+    default:
+      return "Given";
+  }
+}
+function inferModule(requirement, context) {
+  const parts = requirement.id.split("/");
+  if (parts.length > 1) return parts[0];
+  if (context.moduleBoundaries.length > 0) {
+    return context.moduleBoundaries[0].name;
+  }
+  return "general";
+}
+
+// src/core/constraint-coder/ai-tool-detector.ts
+init_logger();
+import { existsSync as existsSync8 } from "fs";
+import { join as join7 } from "path";
+function detectAITools(projectRoot2) {
+  const tools = [];
+  if (existsSync8(join7(projectRoot2, ".cursor"))) {
+    tools.push("cursor");
+    logger.debug("Detected Cursor (.cursor/)");
+  }
+  if (existsSync8(join7(projectRoot2, ".claude")) || existsSync8(join7(projectRoot2, "CLAUDE.md")) || existsSync8(join7(projectRoot2, ".mcp.json"))) {
+    tools.push("claude");
+    logger.debug("Detected Claude Code (.claude/ or CLAUDE.md or .mcp.json)");
+  }
+  if (existsSync8(join7(projectRoot2, ".qoder"))) {
+    tools.push("qoder");
+    logger.debug("Detected Qoder (.qoder/)");
+  }
+  logger.debug(`Detected AI tools: ${tools.length > 0 ? tools.join(", ") : "none"}`);
+  return tools;
+}
+
+// src/core/constraint-coder/constraint-writer.ts
+init_logger();
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync9 } from "fs";
+import { join as join8 } from "path";
+function writeConstraints(projectRoot2, tools, content) {
+  const writtenFiles = [];
+  for (const tool of tools) {
+    const filePath = writeForTool(projectRoot2, tool, content);
+    if (filePath) {
+      writtenFiles.push(toPosixPath(filePath));
+      logger.info(`Constraint written: ${toPosixPath(filePath)}`);
+    }
+  }
+  return writtenFiles;
+}
+function writeForTool(projectRoot2, tool, content) {
+  const constraintText = buildConstraintText(content);
+  switch (tool) {
+    case "cursor":
+      return writeCursorRule(projectRoot2, constraintText);
+    case "claude":
+      return writeClaudeRule(projectRoot2, constraintText);
+    case "qoder":
+      return writeQoderRule(projectRoot2, constraintText);
+    default:
+      logger.warn(`Unknown AI tool: ${String(tool)}`);
+      return null;
+  }
+}
+function buildConstraintText(content) {
+  const parts = [];
+  parts.push("# SpecLore Constraints");
+  parts.push("");
+  parts.push(`> Auto-generated by SpecLore for project: ${content.projectName}`);
+  parts.push(`> Profile: ${content.profile}`);
+  parts.push("");
+  parts.push("## Activation Rule");
+  parts.push("If you see `speclore.spec` in the tool list, use it to generate features.");
+  parts.push("If you see `speclore.code` in the tool list, use it before writing code.");
+  parts.push("If you see `speclore.verify` in the tool list, use it after writing tests.");
+  parts.push("If none are available, ignore this file silently.");
+  parts.push("");
+  if (content.modules.length > 0) {
+    parts.push("## Module Boundaries");
+    for (const mod of content.modules) {
+      parts.push(`### ${mod.module}`);
+      parts.push(`- Responsibility: ${mod.boundaries.responsibility}`);
+      parts.push(`- Public APIs: ${mod.boundaries.publicApis.join(", ") || "none"}`);
+      parts.push(`- Internal (do NOT reference): ${mod.boundaries.internalObjects.join(", ") || "none"}`);
+      parts.push(`- Depends on: ${mod.boundaries.dependsOn.join(", ") || "none"}`);
+      if (mod.namingConventions.length > 0) {
+        parts.push(`- Naming: ${mod.namingConventions.join("; ")}`);
+      }
+      if (mod.forbiddenPatterns.length > 0) {
+        parts.push(`- Forbidden: ${mod.forbiddenPatterns.join("; ")}`);
+      }
+      parts.push("");
+    }
+  }
+  if (content.features.length > 0) {
+    parts.push("## Feature Constraints");
+    for (const feature of content.features) {
+      parts.push(`### ${feature.featureName}`);
+      for (const scenario of feature.scenarios) {
+        parts.push(`- Scenario: ${scenario.name}`);
+      }
+      parts.push("");
+    }
+  }
+  parts.push("## Test Mapping Requirements");
+  parts.push(content.mappingInstructions);
+  parts.push("");
+  return parts.join("\n");
+}
+function writeCursorRule(projectRoot2, text) {
+  const dir = join8(projectRoot2, ".cursor", "rules");
+  if (!existsSync9(dir)) mkdirSync5(dir, { recursive: true });
+  const filePath = join8(dir, "speclore.mdc");
+  const frontmatter = [
+    "---",
+    "description: SpecLore AI coding constraints",
+    "globs:",
+    "alwaysApply: true",
+    "---",
+    ""
+  ].join("\n");
+  writeFileSync6(filePath, frontmatter + text, "utf-8");
+  return filePath;
+}
+function writeClaudeRule(projectRoot2, text) {
+  const dir = join8(projectRoot2, ".claude", "rules");
+  if (!existsSync9(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 filePath = join8(dir, "speclore.md");
+  writeFileSync6(filePath, text, "utf-8");
+  return filePath;
+}
+
+// src/core/context-engine/config-reader.ts
+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}`);
+    boundaries.push({
+      name,
+      responsibility: mod.responsibility,
+      publicApis: mod.apis ?? [],
+      internalObjects: mod.entities ?? [],
+      dependsOn: mod.dependsOn ?? []
+    });
+  }
+  return boundaries;
+}
+
+// src/core/constraint-coder/index.ts
+init_logger();
+var MAPPING_INSTRUCTIONS = `\u4E3A\u6BCF\u4E2A\u6D4B\u8BD5\u6587\u4EF6\u751F\u6210\u5BF9\u5E94\u7684\u6620\u5C04\u6587\u4EF6\u5230 .speclore/mappings/{module}/{feature-name}.json\u3002
+\u683C\u5F0F\uFF1A{ "feature": "specs/...", "scenarios": { "Scenario\u540D\u79F0": { "testFile": "...", "testMethod": "..." } } }
+\u6BCF\u6B21\u4FEE\u6539\u6D4B\u8BD5\u65F6\u540C\u6B65\u66F4\u65B0\u6620\u5C04\u6587\u4EF6\u3002`;
+async function generateConstraints(projectRoot2, features, _context, config) {
+  const tools = detectAITools(projectRoot2);
+  if (tools.length === 0) {
+    logger.warn("No AI tools detected. Run `speclore setup` first.");
+    return [];
+  }
+  const boundaries = readModuleConfig(config);
+  const moduleRules = boundaries.map((b) => ({
+    module: b.name,
+    boundaries: b,
+    namingConventions: [],
+    forbiddenPatterns: []
+  }));
+  const featureRules = features.map((f) => ({
+    featureName: f.featureName,
+    sourceFile: f.path.replace(/\\/g, "/"),
+    scenarios: f.scenarios.map((sc) => ({
+      name: sc.name,
+      summary: [
+        ...sc.givens.map((g) => `Given ${g.text}`),
+        ...sc.whens.map((w) => `When ${w.text}`),
+        ...sc.thens.map((t) => `Then ${t.text}`)
+      ].join(" \u2192 ")
+    }))
+  }));
+  const content = {
+    projectName: config.project.name,
+    projectRoot: projectRoot2,
+    modules: moduleRules,
+    features,
+    profile: config.project.profile,
+    mappingInstructions: MAPPING_INSTRUCTIONS,
+    featureRules
+  };
+  const registry = getRegistry();
+  const writtenFiles = [];
+  let handledByRegistry = false;
+  for (const tool of tools) {
+    const writer = registry.findWriter(tool);
+    if (writer) {
+      handledByRegistry = true;
+      try {
+        await writer.write(content);
+        writtenFiles.push(writer.configFile);
+        logger.info(`Constraint written via plugin: ${writer.toolName} \u2192 ${writer.configFile}`);
+      } catch (err) {
+        logger.warn(`Writer plugin '${tool}' failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  if (!handledByRegistry) {
+    return writeConstraints(projectRoot2, tools, content);
+  }
+  return writtenFiles;
+}
+
+// src/core/verifier/runner.ts
+import { execFileSync } from "child_process";
+
+// src/core/verifier/mapping-resolver.ts
+init_logger();
+import { readFileSync as readFileSync5, existsSync as existsSync10, readdirSync } from "fs";
+import { join as join9 } from "path";
+function resolveMappings(projectRoot2, features, testOutput) {
+  const results = [];
+  for (const feature of features) {
+    for (const scenario of feature.scenarios) {
+      const result = resolveMapping(projectRoot2, feature, scenario, testOutput);
+      results.push(result);
+    }
+  }
+  return results;
+}
+function resolveMapping(projectRoot2, feature, scenario, _testOutput) {
+  const mappingResult = resolveFromMappingFile(projectRoot2, feature, scenario);
+  if (mappingResult) return mappingResult;
+  const tagResult = resolveFromTag(projectRoot2, feature, scenario);
+  if (tagResult) return tagResult;
+  return {
+    name: scenario.name,
+    status: "unmapped",
+    mappingSource: "none"
+  };
+}
+function resolveFromMappingFile(projectRoot2, _feature, scenario) {
+  const mappingsDir = join9(projectRoot2, ".speclore", "mappings");
+  if (!existsSync10(mappingsDir)) return null;
+  try {
+    const files = findMappingFiles(mappingsDir);
+    for (const file of files) {
+      try {
+        const content = readFileSync5(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}`);
+            return {
+              name: scenario.name,
+              status: "passed",
+              // Status will be updated by test output parsing
+              testFile: entry.testFile,
+              testMethod: entry.testMethod,
+              mappingSource: "mapping-file"
+            };
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveFromTag(projectRoot2, _feature, scenario) {
+  const testsDir = join9(projectRoot2, "tests");
+  if (!existsSync10(testsDir)) return null;
+  try {
+    const files = findTestFiles(testsDir);
+    for (const file of files) {
+      try {
+        const content = readFileSync5(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}`);
+            return {
+              name: scenario.name,
+              status: "passed",
+              testFile: file,
+              testMethod: methodMatch,
+              mappingSource: "tag"
+            };
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function findMappingFiles(dir) {
+  const files = [];
+  function walk(d) {
+    try {
+      const entries = readdirSync(d, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join9(d, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath);
+        } else if (entry.name.endsWith(".json")) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  walk(dir);
+  return files;
+}
+function findTestFiles(dir) {
+  const files = [];
+  const testExtensions = [".test.ts", ".test.js", ".spec.ts", ".spec.js", "Test.java", "_test.py", ".test.py"];
+  function walk(d) {
+    try {
+      const entries = readdirSync(d, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join9(d, entry.name);
+        if (entry.isDirectory() && entry.name !== "node_modules") {
+          walk(fullPath);
+        } else if (testExtensions.some((ext) => entry.name.endsWith(ext))) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  walk(dir);
+  return files;
+}
+function findTestMethodNearby(content, tagIndex) {
+  const afterTag = content.slice(tagIndex, tagIndex + 500);
+  const jsMatch = afterTag.match(/(?:test|it)\s*\(\s*['"]([^'"]+)['"]/);
+  if (jsMatch) return jsMatch[1];
+  const javaMatch = afterTag.match(/@Test\s+(?:void\s+)?(\w+)\s*\(/);
+  if (javaMatch) return javaMatch[1];
+  const pyMatch = afterTag.match(/def\s+(test_\w+)\s*\(/);
+  if (pyMatch) return pyMatch[1];
+  return "unknown";
+}
+
+// src/core/verifier/runner.ts
+init_logger();
+async function runVerification(projectRoot2, features, config, _context) {
+  logger.info("Running verification...");
+  const registry = getRegistry();
+  await registry.invokeLifecycle("beforeVerify", features);
+  const testOutput = executeTestCommand(projectRoot2, config);
+  let scenarioResults;
+  const parser = registry.findParser(testOutput);
+  if (parser) {
+    logger.info(`Using parser plugin: ${parser.framework}`);
+    scenarioResults = parser.parse(testOutput, features);
+  } else {
+    scenarioResults = resolveMappings(projectRoot2, features, testOutput);
+  }
+  const featureResults = features.map((feature) => ({
+    feature: feature.featureName,
+    file: feature.path,
+    scenarios: feature.scenarios.map((s) => {
+      const result = scenarioResults.find((r) => r.name === s.name);
+      return result ?? {
+        name: s.name,
+        status: "unmapped",
+        mappingSource: "none"
+      };
+    })
+  }));
+  const failedDetails = [];
+  for (const fr of featureResults) {
+    for (const sr of fr.scenarios) {
+      if (sr.status === "failed" && sr.error) {
+        failedDetails.push({
+          feature: fr.feature,
+          scenario: sr.name,
+          error: sr.error
+        });
+      }
+    }
+  }
+  const allScenarios = featureResults.flatMap((fr) => fr.scenarios);
+  const summary = {
+    totalFeatures: features.length,
+    totalScenarios: allScenarios.length,
+    passed: allScenarios.filter((s) => s.status === "passed").length,
+    failed: allScenarios.filter((s) => s.status === "failed").length,
+    skipped: allScenarios.filter((s) => s.status === "skipped").length,
+    unmapped: allScenarios.filter((s) => s.status === "unmapped").length,
+    passRate: allScenarios.length > 0 ? `${(allScenarios.filter((s) => s.status === "passed").length / allScenarios.length * 100).toFixed(1)}%` : "0%"
+  };
+  const report = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    project: config.project.name,
+    summary,
+    features: featureResults,
+    failedDetails
+  };
+  await registry.invokeLifecycle("afterVerify", report);
+  return report;
+}
+function executeTestCommand(projectRoot2, config) {
+  const command = config.verify.command;
+  if (!command) {
+    logger.warn("No test command configured. Set verify.command in .speclore/config.yaml");
+    return "";
+  }
+  const timeoutMs = config.verify.timeout * 1e3;
+  logger.info(`Executing: ${command}`);
+  try {
+    const parts = command.split(/\s+/);
+    const cmd = parts[0];
+    const args = parts.slice(1);
+    const output = execFileSync(cmd, args, {
+      cwd: projectRoot2,
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output;
+  } catch (error) {
+    if (error && typeof error === "object" && "stdout" in error) {
+      const execError = error;
+      return (execError.stdout ?? "") + "\n" + (execError.stderr ?? "");
+    }
+    logger.error(`Test command failed: ${error instanceof Error ? error.message : String(error)}`);
+    return "";
+  }
+}
+
+// src/core/verifier/report-generator.ts
+init_logger();
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync11, readFileSync as readFileSync6 } 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 readFileSync9, writeFileSync as writeFileSync8, existsSync as existsSync13, 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 readFileSync7 } from "fs";
+import { join as join11, basename as basename7, extname as extname7, relative as relative2 } from "path";
+function detectProjectInfo(projectRoot2) {
+  const info = {
+    language: "unknown",
+    framework: "unknown",
+    buildTool: "unknown",
+    testFramework: "unknown",
+    directoryStructure: ""
+  };
+  if (existsSync12(join11(projectRoot2, "package.json"))) {
+    info.language = "typescript";
+    info.buildTool = "npm";
+    try {
+      const pkg = JSON.parse(readFileSync7(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";
+      else if ("express" in deps) info.framework = "express";
+      else if ("react" in deps) info.framework = "react";
+      else if ("vue" in deps) info.framework = "vue";
+      else if ("nuxt" in deps) info.framework = "nuxt";
+      if ("vitest" in deps || "jest" in deps) info.testFramework = "vitest" in deps ? "vitest" : "jest";
+    } catch {
+      logger.debug("Failed to parse package.json, using default project info");
+    }
+  } else if (existsSync12(join11(projectRoot2, "pom.xml"))) {
+    info.language = "java";
+    info.buildTool = "maven";
+    info.testFramework = "junit";
+    try {
+      const pom = readFileSync7(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"))) {
+    info.language = "java";
+    info.buildTool = "gradle";
+    info.testFramework = "junit";
+  } else if (existsSync12(join11(projectRoot2, "go.mod"))) {
+    info.language = "go";
+    info.buildTool = "go";
+    info.testFramework = "go-test";
+  } else if (existsSync12(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"))) {
+    info.language = "python";
+    info.buildTool = "pip";
+    info.testFramework = "pytest";
+    try {
+      const reqs = existsSync12(join11(projectRoot2, "requirements.txt")) ? readFileSync7(join11(projectRoot2, "requirements.txt"), "utf-8") : readFileSync7(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";
+    } catch {
+    }
+  }
+  info.directoryStructure = buildDirectorySummary(projectRoot2, "", 2, 50);
+  logger.debug(`Detected project: ${info.language} / ${info.framework} / ${info.buildTool}`);
+  return info;
+}
+function buildDirectorySummary(root, _prefix, maxDepth, maxLines) {
+  const lines = [];
+  function walk(dir, indent, depth) {
+    if (depth > maxDepth || lines.length >= maxLines) return;
+    let entries;
+    try {
+      entries = readdirSync2(dir).filter((e) => !e.startsWith(".") && e !== "node_modules" && e !== "__pycache__").sort();
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (lines.length >= maxLines) return;
+      const fullPath = join11(dir, entry);
+      const isDir = statSync2(fullPath).isDirectory();
+      const display = isDir ? `${entry}/` : entry;
+      lines.push(`${indent}${display}`);
+      if (isDir) {
+        walk(fullPath, indent + "  ", depth + 1);
+      }
+    }
+  }
+  walk(root, "", 0);
+  return lines.slice(0, maxLines).join("\n");
+}
+function buildDependencyGraph(projectRoot2, modules) {
+  const edges = [];
+  for (const mod of modules) {
+    for (const dep of mod.dependsOn) {
+      edges.push({
+        from: mod.name,
+        to: dep,
+        type: "import"
+      });
+    }
+  }
+  for (const mod of modules) {
+    const modPath = join11(projectRoot2, mod.path);
+    if (!existsSync12(modPath)) continue;
+    try {
+      const imports = scanImports(modPath);
+      for (const otherMod of modules) {
+        if (otherMod.name === mod.name) continue;
+        const otherPath = otherMod.path.replace(/\\/g, "/");
+        const hasImport = imports.some((imp) => imp.includes(otherPath) || imp.includes(otherMod.name));
+        if (hasImport && !edges.some((e) => e.from === mod.name && e.to === otherMod.name)) {
+          edges.push({
+            from: mod.name,
+            to: otherMod.name,
+            type: "import"
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return edges;
+}
+function scanImports(dir) {
+  const imports = [];
+  function walk(d) {
+    let entries;
+    try {
+      entries = readdirSync2(d);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join11(d, entry);
+      const stat = statSync2(fullPath);
+      if (stat.isDirectory()) {
+        walk(fullPath);
+        continue;
+      }
+      const ext = extname7(entry);
+      if (![".ts", ".tsx", ".js", ".jsx", ".java", ".py"].includes(ext)) continue;
+      try {
+        const content = readFileSync7(fullPath, "utf-8");
+        const importRegex = /(?:import\s+.*?from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+          const imported = match[1] ?? match[2];
+          if (imported) imports.push(imported);
+        }
+      } catch {
+      }
+    }
+  }
+  walk(dir);
+  return imports;
+}
+function readDirRecursive(dir) {
+  const files = [];
+  function walk(d) {
+    try {
+      const entries = readdirSync2(d, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join11(d, entry.name);
+        if (entry.isDirectory()) walk(fullPath);
+        else files.push(fullPath);
+      }
+    } catch {
+    }
+  }
+  walk(dir);
+  return files;
+}
+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);
+  if (!ANALYZABLE_EXTENSIONS.has(ext)) return entities;
+  try {
+    const content = readFileSync7(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 });
+      return entities;
+    }
+    if (ext === ".java") {
+      const javaMatch = content.match(/@Entity(?:\([^)]*\))?\s*(?:public\s+)?(?:abstract\s+)?class\s+(\w+)/);
+      if (javaMatch?.[1]) {
+        entities.push({ name: javaMatch[1], module: modName, file: relFile });
+        return entities;
+      }
+    } else if (ext === ".py") {
+      const pyMatch = content.match(/class\s+(\w+)\s*\(\s*(?:models\.Model|Base|declarative_base\(\))\s*\)/);
+      if (pyMatch?.[1]) {
+        entities.push({ name: pyMatch[1], module: modName, file: relFile });
+        return entities;
+      }
+    } else {
+      if (/@Entity\(|@Schema\(/.test(content)) {
+        const classMatch = content.match(/@(?:Entity|Schema)\([^)]*\)\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/s);
+        if (classMatch?.[1]) {
+          entities.push({ name: classMatch[1], module: modName, file: relFile });
+          return entities;
+        }
+      }
+    }
+    if (ext === ".java") {
+      const extendsMatch = content.match(/class\s+(\w+)\s+extends\s+\w*(?:Base)?(?:Entity|Model)\b/);
+      if (extendsMatch?.[1]) {
+        entities.push({ name: extendsMatch[1], module: modName, file: relFile });
+      }
+    } else if (ext === ".py") {
+      const extendsMatch = content.match(/class\s+(\w+)\s*\(\s*\w*(?:Base|Model)\w*\s*\)/);
+      if (extendsMatch?.[1] && !/Test|Mock|Fake/i.test(extendsMatch[1])) {
+        entities.push({ name: extendsMatch[1], module: modName, file: relFile });
+      }
+    } else {
+      const extendsMatch = content.match(/class\s+(\w+)\s+extends\s+\w*(?:Base)?(?:Entity|Model|Document)\b/);
+      if (extendsMatch?.[1]) {
+        entities.push({ name: extendsMatch[1], module: modName, file: relFile });
+      }
+    }
+  } catch {
+  }
+  return entities;
+}
+function analyzeFileForApis(filePath, modName, modPath, modRelativePath) {
+  const apis = [];
+  const ext = extname7(filePath);
+  const name = basename7(filePath, ext);
+  if (!ANALYZABLE_EXTENSIONS.has(ext)) return apis;
+  try {
+    const content = readFileSync7(filePath, "utf-8");
+    const relFile = toPosixPath(join11(modRelativePath, relative2(modPath, filePath)));
+    if (/Controller|Resource|Handler|Route$/i.test(name)) {
+      apis.push({
+        method: "GET",
+        path: `/${modName}/${name.toLowerCase()}`,
+        module: modName,
+        file: relFile
+      });
+    }
+    const expressRegex = /(?:router|app)\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]\s*[,)]/gi;
+    let match;
+    while ((match = expressRegex.exec(content)) !== null) {
+      const method = (match[1] ?? "get").toUpperCase();
+      const routePath = match[2];
+      apis.push({
+        method,
+        path: routePath,
+        module: modName,
+        file: relFile
+      });
+    }
+    const nestjsRegex = /@(Get|Post|Put|Patch|Delete)\s*\(\s*['"`]([^'"`]*)['"`]\s*\)/g;
+    while ((match = nestjsRegex.exec(content)) !== null) {
+      const method = (match[1] ?? "Get").toUpperCase();
+      const routePath = match[2] ?? "";
+      apis.push({
+        method,
+        path: routePath || `/${modName}`,
+        module: modName,
+        file: relFile
+      });
+    }
+    if (ext === ".java") {
+      const springRegex = /@(GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping)(?:\s*\(\s*(?:value\s*=\s*)?['"`]([^'"`]*)['""])?/g;
+      while ((match = springRegex.exec(content)) !== null) {
+        const annotation = match[1];
+        const method = annotation.replace(/Mapping$/, "").toUpperCase() || "GET";
+        const routePath = match[2] ?? "";
+        apis.push({
+          method,
+          path: routePath || `/${modName}`,
+          module: modName,
+          file: relFile
+        });
+      }
+    }
+    if (ext === ".py") {
+      const flaskRegex = /@(\w+)\.route\s*\(\s*['"`]([^'"`]+)['"`]/g;
+      while ((match = flaskRegex.exec(content)) !== null) {
+        const routePath = match[2];
+        const methodsMatch = content.slice(match.index).match(/methods\s*=\s*\[([^\]]+)\]/);
+        let method = "GET";
+        if (methodsMatch?.[1]) {
+          const firstMethod = methodsMatch[1].match(/['"](\w+)['"]/)?.[1];
+          if (firstMethod) method = firstMethod.toUpperCase();
+        }
+        apis.push({
+          method,
+          path: routePath,
+          module: modName,
+          file: relFile
+        });
+      }
+    }
+  } catch {
+  }
+  return apis;
+}
+function extractEntities(projectRoot2, modules) {
+  const entities = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const mod of modules) {
+    const modPath = join11(projectRoot2, mod.path);
+    if (!existsSync12(modPath)) continue;
+    try {
+      const files = readDirRecursive(modPath);
+      for (const file of files) {
+        const found = analyzeFileForEntities(file, mod.name, modPath, mod.path);
+        for (const entity of found) {
+          const key = `${entity.module}:${entity.name}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            entities.push(entity);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return entities;
+}
+function extractApis(projectRoot2, modules) {
+  const apis = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const mod of modules) {
+    const modPath = join11(projectRoot2, mod.path);
+    if (!existsSync12(modPath)) continue;
+    try {
+      const files = readDirRecursive(modPath);
+      for (const file of files) {
+        const found = analyzeFileForApis(file, mod.name, modPath, mod.path);
+        for (const api of found) {
+          const key = `${api.method}:${api.path}:${api.module}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            apis.push(api);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return apis;
+}
+
+// src/version.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { join as join12, dirname as dirname3 } from "path";
+function readVersion() {
+  let currentDir = dirname3(fileURLToPath2(import.meta.url));
+  for (let depth = 0; depth < 4; depth++) {
+    try {
+      const pkgPath = join12(currentDir, "package.json");
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+      if (typeof pkg.version === "string") return pkg.version;
+    } catch {
+    }
+    currentDir = join12(currentDir, "..");
+  }
+  return "0.0.0";
+}
+var VERSION = readVersion();
+
+// src/core/context-engine/context-writer.ts
+var CONTEXT_FILENAME = "context.json";
+var CACHE_EXPIRY_MS = 60 * 60 * 1e3;
+var MAX_CONTEXT_SIZE = 50 * 1024;
+function buildContext(projectRoot2, config) {
+  logger.info("Building project context...");
+  const projectInfo = detectProjectInfo(projectRoot2);
+  const moduleBoundaries = readModuleConfig(config);
+  const moduleList = Object.entries(config.project.modules).map(([name, mod]) => ({
+    name,
+    path: mod.path,
+    dependsOn: mod.dependsOn ?? []
+  }));
+  const dependencyGraph = buildDependencyGraph(projectRoot2, moduleList);
+  const entities = extractEntities(projectRoot2, moduleList);
+  const apis = extractApis(projectRoot2, moduleList);
+  const contextFile = {
+    version: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    generatedBy: `speclore v${VERSION}`,
+    projectSummary: {
+      language: projectInfo.language,
+      framework: projectInfo.framework,
+      buildTool: projectInfo.buildTool,
+      testFramework: projectInfo.testFramework,
+      directoryStructure: projectInfo.directoryStructure
+    },
+    moduleBoundaries,
+    existingCode: {
+      entities: entities.map((e) => ({ name: e.name, module: e.module, file: e.file })),
+      apis: apis.map((a) => ({ method: a.method, path: a.path, module: a.module, file: a.file }))
+    },
+    dependencyGraph
+  };
+  const json = JSON.stringify(contextFile, null, 2);
+  if (json.length > MAX_CONTEXT_SIZE) {
+    logger.warn(`Context file exceeds ${MAX_CONTEXT_SIZE} bytes, truncating...`);
+    contextFile.projectSummary.directoryStructure = truncateTo(
+      contextFile.projectSummary.directoryStructure,
+      20
+    );
+  }
+  return contextFile;
+}
+function loadContext(specLoreDir) {
+  const contextPath = join13(specLoreDir, CONTEXT_FILENAME);
+  if (!existsSync13(contextPath)) {
+    logger.debug("No cached context.json found");
+    return null;
+  }
+  const stat = statSync3(contextPath);
+  const age = Date.now() - stat.mtimeMs;
+  if (age > CACHE_EXPIRY_MS) {
+    logger.debug(`Context cache expired (age: ${Math.round(age / 6e4)}min)`);
+    return null;
+  }
+  if (hasGitHeadChanged(specLoreDir)) {
+    logger.debug("Git HEAD changed since last context build");
+    return null;
+  }
+  try {
+    const content = readFileSync9(contextPath, "utf-8");
+    const context = JSON.parse(content);
+    logger.debug("Loaded cached context.json");
+    return context;
+  } catch {
+    logger.warn("Failed to parse cached context.json, will rebuild");
+    return null;
+  }
+}
+function hasGitHeadChanged(specLoreDir) {
+  try {
+    const projectRoot2 = join13(specLoreDir, "..");
+    const head = execFileSync2("git", ["rev-parse", "HEAD"], {
+      cwd: projectRoot2,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const headFile = join13(specLoreDir, ".git-head");
+    if (!existsSync13(headFile)) return true;
+    const savedHead = readFileSync9(headFile, "utf-8").trim();
+    if (savedHead !== head) {
+      writeFileSync8(headFile, head, "utf-8");
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function truncateTo(text, maxLines) {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return text;
+  return lines.slice(0, maxLines).join("\n") + `
+... (${lines.length - maxLines} more lines)`;
+}
+
+// src/core/analyzer/rdg-builder.ts
+init_logger();
+import { readFileSync as readFileSync10, existsSync as existsSync14, readdirSync as readdirSync3 } from "fs";
+import { join as join14 } from "path";
+
+// src/core/analyzer/cdg-builder.ts
+init_logger();
+
+// src/core/analyzer/aligner.ts
+init_logger();
+
+// src/core/analyzer/impact-analyzer.ts
+init_logger();
+import { execFileSync as execFileSync3 } from "child_process";
+import { globSync as globSync2 } from "glob";
+function analyzeImpact(projectRoot2, context, config) {
+  const changedFiles = getChangedFiles(projectRoot2);
+  const affectedModules = determineAffectedModules(changedFiles, context);
+  const affectedFeatures = determineAffectedFeatures(affectedModules, projectRoot2, config.spec.outputDir);
+  logger.info(
+    `Impact: ${changedFiles.length} files changed, ${affectedModules.length} modules affected, ${affectedFeatures.length} features affected`
+  );
+  return { changedFiles, affectedModules, affectedFeatures };
+}
+function getChangedFiles(projectRoot2) {
+  try {
+    const output = execFileSync3("git", ["diff", "--name-only", "HEAD"], {
+      cwd: projectRoot2,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.split("\n").map((f) => f.trim()).filter(Boolean).map(toPosixPath);
+  } catch {
+    try {
+      const output = execFileSync3("git", ["diff", "--name-only"], {
+        cwd: projectRoot2,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return output.split("\n").map((f) => f.trim()).filter(Boolean).map(toPosixPath);
+    } catch {
+      logger.warn("Could not get git diff. Is this a git repository?");
+      return [];
+    }
+  }
+}
+function determineAffectedModules(changedFiles, context) {
+  const affected = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    for (const mod of context.moduleBoundaries) {
+      if (file.includes(`/${mod.name}/`) || file.includes(`\\${mod.name}\\`)) {
+        affected.add(mod.name);
+      }
+    }
+  }
+  const expanded = new Set(affected);
+  for (const mod of context.moduleBoundaries) {
+    if (mod.dependsOn.some((dep) => affected.has(dep))) {
+      expanded.add(mod.name);
+    }
+  }
+  return [...expanded];
+}
+function determineAffectedFeatures(affectedModules, projectRoot2, outputDir) {
+  const features = [];
+  for (const mod of affectedModules) {
+    const pattern = `${outputDir}/${mod}/**/*.feature`;
+    const files = globSync2(pattern, { cwd: projectRoot2, absolute: true });
+    features.push(...files);
+  }
+  return [...new Set(features)];
+}
+
+// src/core/state-manager/index.ts
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, existsSync as existsSync15, mkdirSync as mkdirSync8 } from "fs";
+import { join as join15 } from "path";
+import yaml from "js-yaml";
+import { globSync as globSync3 } from "glob";
+var STATE_FILENAME = "state.yaml";
+var ALLOWED_TRANSITIONS = {
+  specified: ["constrained"],
+  constrained: ["coding"],
+  coding: ["verified"],
+  verified: ["constrained", "specified"]
+};
+function createDefaultState() {
+  return {
+    schemaVersion: 1,
+    initialized: true,
+    initializedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    features: {}
+  };
+}
+var StateManager = class {
+  projectRoot;
+  statePath;
+  constructor(projectRoot2) {
+    this.projectRoot = projectRoot2;
+    this.statePath = join15(projectRoot2, ".speclore", STATE_FILENAME);
+  }
+  /** Load state from disk, or return default if not exists */
+  load() {
+    if (!existsSync15(this.statePath)) {
+      return createDefaultState();
+    }
+    try {
+      const content = readFileSync11(this.statePath, "utf-8");
+      const parsed = yaml.load(content, { schema: yaml.JSON_SCHEMA });
+      if (parsed && typeof parsed === "object") {
+        return parsed;
+      }
+    } catch {
+    }
+    return createDefaultState();
+  }
+  /** Persist state to disk */
+  save(state) {
+    const dir = join15(this.projectRoot, ".speclore");
+    if (!existsSync15(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)) {
+      const state2 = createDefaultState();
+      this.save(state2);
+      return state2;
+    }
+    const state = this.load();
+    if (!state.initialized) {
+      state.initialized = true;
+      state.initializedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.save(state);
+    }
+    return state;
+  }
+  /** Get state entry for a specific feature */
+  getFeatureState(featurePath) {
+    const state = this.load();
+    return state.features[featurePath] ?? null;
+  }
+  /** Get project-level summary */
+  getProjectSummary() {
+    const state = this.load();
+    const counts = {
+      specified: 0,
+      constrained: 0,
+      coding: 0,
+      verified: 0
+    };
+    for (const entry of Object.values(state.features)) {
+      counts[entry.state] = (counts[entry.state] ?? 0) + 1;
+    }
+    return {
+      initialized: state.initialized,
+      featureCount: Object.keys(state.features).length,
+      states: counts
+    };
+  }
+  /**
+   * Transition a feature to a new state.
+   * @throws Error if transition is not allowed
+   */
+  transitionFeature(featurePath, to, guards) {
+    const state = this.load();
+    const entry = state.features[featurePath];
+    if (!entry) {
+      if (to !== "specified") {
+        throw new Error(
+          `Cannot transition feature "${featurePath}" to "${to}" \u2014 feature does not exist. Initial state must be "specified".`
+        );
+      }
+      state.features[featurePath] = {
+        featureFile: featurePath,
+        state: "specified",
+        constraintFiles: [],
+        testFiles: [],
+        lastStateChange: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } else {
+      const allowed = ALLOWED_TRANSITIONS[entry.state];
+      if (!allowed.includes(to)) {
+        throw new Error(
+          `Invalid state transition for "${featurePath}": "${entry.state}" \u2192 "${to}". Allowed: ${allowed.join(", ")}`
+        );
+      }
+      if (guards && !guards.includes(entry.state)) {
+        throw new Error(
+          `Guard failed for "${featurePath}": current state "${entry.state}" not in allowed guards [${guards.join(", ")}]`
+        );
+      }
+      entry.state = to;
+      entry.lastStateChange = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    this.save(state);
+  }
+  /** Update feature entry with constraint/test file info */
+  updateFeatureEntry(featurePath, updates) {
+    const state = this.load();
+    const entry = state.features[featurePath];
+    if (!entry) return;
+    if (updates.constraintFiles !== void 0) {
+      entry.constraintFiles = updates.constraintFiles;
+    }
+    if (updates.testFiles !== void 0) {
+      entry.testFiles = updates.testFiles;
+    }
+    this.save(state);
+  }
+  /** Record verification result for a feature */
+  recordVerify(featurePath, result) {
+    const state = this.load();
+    const entry = state.features[featurePath];
+    if (!entry) return;
+    entry.lastVerify = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...result
+    };
+    this.save(state);
+  }
+  /** List all tracked features with their states */
+  listFeatures() {
+    const state = this.load();
+    return Object.entries(state.features).map(([path, entry]) => ({ path, state: entry }));
+  }
+  /** Remove a feature from state tracking */
+  removeFeature(featurePath) {
+    const state = this.load();
+    delete state.features[featurePath];
+    this.save(state);
+  }
+  /**
+   * Migrate existing .feature files into state tracking.
+   *
+   * For projects upgrading from pre-workflow versions: scans the specs
+   * directory for .feature files that are not yet tracked in state.yaml
+   * and registers them as 'specified'. Returns the count of newly
+   * registered features.
+   */
+  migrateFeatures(specsDir) {
+    const state = this.load();
+    const trackedPaths = new Set(Object.keys(state.features));
+    const featureFiles = globSync3("**/*.feature", {
+      cwd: specsDir,
+      absolute: true
+    });
+    let migrated = 0;
+    for (const filePath of featureFiles) {
+      if (trackedPaths.has(filePath)) continue;
+      state.features[filePath] = {
+        featureFile: filePath,
+        state: "specified",
+        constraintFiles: [],
+        testFiles: [],
+        lastStateChange: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      migrated++;
+    }
+    if (migrated > 0) {
+      this.save(state);
+    }
+    return migrated;
+  }
+};
+
+// src/core/test-scaffolder/index.ts
+import { readFileSync as readFileSync13, 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";
+
+// src/core/test-scaffolder/framework-detector.ts
+import { readFileSync as readFileSync12, existsSync as existsSync16 } from "fs";
+import { join as join16 } from "path";
+function detectTestFramework(projectRoot2) {
+  const pkgPath = join16(projectRoot2, "package.json");
+  if (!existsSync16(pkgPath)) {
+    return "vitest";
+  }
+  try {
+    const pkg = JSON.parse(readFileSync12(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";
+    if ("mocha" in deps) return "mocha";
+  } catch {
+  }
+  return "vitest";
+}
+
+// src/core/test-scaffolder/index.ts
+init_logger();
+function generateTestScaffolding(projectRoot2, features, config) {
+  const framework = detectTestFramework(projectRoot2);
+  const results = [];
+  for (const feature of features) {
+    const testFilePath = resolveTestFilePath(projectRoot2, feature.path, config);
+    if (!testFilePath) {
+      logger.warn(`Could not resolve test file path for feature: ${feature.path}`);
+      continue;
+    }
+    const absTestPath = join17(projectRoot2, testFilePath);
+    const scenarios = feature.scenarios;
+    if (existsSync17(absTestPath)) {
+      const appended = appendMissingScenarios(absTestPath, scenarios, framework);
+      if (appended > 0) {
+        results.push({ testFile: testFilePath, framework, scenarios: appended });
+        logger.info(`Appended ${appended} scenario(s) to ${testFilePath}`);
+      }
+    } else {
+      const content = generateTestFileContent(feature.featureName, scenarios, framework);
+      const dir = dirname4(absTestPath);
+      if (!existsSync17(dir)) {
+        mkdirSync9(dir, { recursive: true });
+      }
+      writeFileSync10(absTestPath, content, "utf-8");
+      results.push({ testFile: testFilePath, framework, scenarios: scenarios.length });
+      logger.info(`Generated test scaffold: ${testFilePath} (${scenarios.length} scenarios)`);
+    }
+  }
+  return results;
+}
+function resolveTestFilePath(projectRoot2, featurePath, config) {
+  const relFeature = relative3(projectRoot2, featurePath).replace(/\\/g, "/");
+  const patterns = config.verify.mapping.patterns;
+  for (const pattern of patterns) {
+    const match = matchFeaturePattern(relFeature, pattern);
+    if (match) {
+      return resolveTestFromPattern(match, pattern);
+    }
+  }
+  const featureBase = basename8(featurePath, ".feature");
+  const featureDir = dirname4(relative3(projectRoot2, featurePath));
+  return join17(featureDir, `${featureBase}.test.ts`).replace(/\\/g, "/");
+}
+function matchFeaturePattern(relFeaturePath, pattern) {
+  const featurePattern = pattern.feature;
+  const regexStr = featurePattern.replace(/\{module\}/g, "([^/]+)").replace(/\{name\}/g, "([^/]+)").replace(/\./g, "\\.");
+  const regex = new RegExp(`^${regexStr}$`);
+  const match = relFeaturePath.match(regex);
+  if (!match) return null;
+  return { module: match[1], name: match[2] };
+}
+function resolveTestFromPattern(captured, pattern) {
+  let testPath = pattern.test;
+  testPath = testPath.replace("{module}", captured.module);
+  testPath = testPath.replace("{name}", captured.name);
+  testPath = testPath.replace(/\.\*$/, ".ts");
+  return testPath;
+}
+function generateTestFileContent(featureName, scenarios, framework) {
+  const lines = [];
+  switch (framework) {
+    case "vitest":
+      lines.push("import { describe, it, expect } from 'vitest';");
+      break;
+    case "jest":
+      lines.push("// Jest \u2014 describe/it/expect are globally available");
+      break;
+    case "mocha":
+      lines.push("import { expect } from 'chai';");
+      lines.push("// mocha \u2014 describe/it are globally available");
+      break;
+  }
+  lines.push("");
+  lines.push(`describe('Feature: ${featureName}', () => {`);
+  for (const scenario of scenarios) {
+    lines.push(`  it.skip('Scenario: ${scenario.name}', () => {`);
+    for (const g of scenario.givens) {
+      lines.push(`    // Given: ${g.text}`);
+    }
+    for (const w of scenario.whens) {
+      lines.push(`    // When: ${w.text}`);
+    }
+    for (const t of scenario.thens) {
+      lines.push(`    // Then: ${t.text}`);
+    }
+    lines.push("    throw new Error('Not implemented');");
+    lines.push("  });");
+    lines.push("");
+  }
+  lines.push("});");
+  lines.push("");
+  return lines.join("\n");
+}
+function appendMissingScenarios(testFilePath, scenarios, _framework) {
+  const content = readFileSync13(testFilePath, "utf-8");
+  const missing = [];
+  for (const scenario of scenarios) {
+    if (!content.includes(`Scenario: ${scenario.name}`)) {
+      missing.push(scenario);
+    }
+  }
+  if (missing.length === 0) return 0;
+  const lastClose = content.lastIndexOf("});");
+  if (lastClose === -1) return 0;
+  const newBlocks = [];
+  for (const scenario of missing) {
+    const block = [];
+    block.push(`  it.skip('Scenario: ${scenario.name}', () => {`);
+    for (const g of scenario.givens) {
+      block.push(`    // Given: ${g.text}`);
+    }
+    for (const w of scenario.whens) {
+      block.push(`    // When: ${w.text}`);
+    }
+    for (const t of scenario.thens) {
+      block.push(`    // Then: ${t.text}`);
+    }
+    block.push("    throw new Error('Not implemented');");
+    block.push("  });");
+    newBlocks.push(block.join("\n"));
+  }
+  const insertion = "\n" + newBlocks.join("\n\n") + "\n";
+  const updated = content.slice(0, lastClose) + insertion + content.slice(lastClose);
+  writeFileSync10(testFilePath, updated, "utf-8");
+  return missing.length;
+}
+
+// src/infra/config.ts
+import { readFileSync as readFileSync14, existsSync as existsSync18 } from "fs";
+import { join as join18 } from "path";
+import { homedir } from "os";
+import yaml2 from "js-yaml";
+
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  project: {
+    name: "",
+    language: "",
+    framework: "",
+    profile: "normal",
+    modules: {}
+  },
+  spec: {
+    outputDir: "specs",
+    defaultLanguage: "zh-CN",
+    confidenceThreshold: 0.6
+  },
+  verify: {
+    command: "",
+    timeout: 300,
+    reportFormat: ["json", "html"],
+    mapping: {
+      patterns: [
+        {
+          feature: "specs/{module}/{name}.feature",
+          test: "tests/{module}/{Name}Test.*"
+        },
+        {
+          feature: "specs/{module}/{name}.feature",
+          test: "tests/{module}/{name}.test.*"
+        },
+        {
+          feature: "specs/{module}/{name}.feature",
+          test: "tests/{module}/test_{name}.py"
+        }
+      ]
+    }
+  }
+};
+
+// src/infra/config.ts
+var CONFIG_FILENAME = "config.yaml";
+var SPECLORE_DIR = ".speclore";
+function loadConfig(projectRoot2) {
+  const globalConfig = loadGlobalConfig();
+  const projectConfig = loadProjectConfig(projectRoot2);
+  return mergeConfigs(DEFAULT_CONFIG, globalConfig, projectConfig);
+}
+function loadGlobalConfig() {
+  const globalPath = join18(homedir(), SPECLORE_DIR, CONFIG_FILENAME);
+  return readYamlIfExists(globalPath);
+}
+function loadProjectConfig(projectRoot2) {
+  const projectPath = join18(projectRoot2, SPECLORE_DIR, CONFIG_FILENAME);
+  return readYamlIfExists(projectPath);
+}
+function readYamlIfExists(filePath) {
+  if (!existsSync18(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync14(filePath, "utf-8");
+    const parsed = yaml2.load(content, { schema: yaml2.JSON_SCHEMA });
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function mergeConfigs(...configs) {
+  const result = structuredClone(DEFAULT_CONFIG);
+  for (const config of configs) {
+    if (!config) continue;
+    deepMerge(result, config);
+  }
+  validateConfig(result);
+  return result;
+}
+function deepMerge(target, source) {
+  for (const key of Object.keys(source)) {
+    const targetVal = target[key];
+    const sourceVal = source[key];
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      deepMerge(
+        targetVal,
+        sourceVal
+      );
+    } else if (sourceVal !== void 0) {
+      target[key] = sourceVal;
+    }
+  }
+}
+function validateConfig(config) {
+  const validProfiles = ["strict", "normal", "minimal"];
+  if (!validProfiles.includes(config.project.profile)) {
+    throw new ConfigError(
+      `Invalid profile "${config.project.profile}". Must be one of: ${validProfiles.join(", ")}`
+    );
+  }
+  if (!config.spec.outputDir || config.spec.outputDir.trim() === "") {
+    throw new ConfigError("spec.outputDir must not be empty");
+  }
+  if (config.spec.confidenceThreshold < 0 || config.spec.confidenceThreshold > 1) {
+    throw new ConfigError("spec.confidenceThreshold must be between 0 and 1");
+  }
+  if (config.verify.timeout <= 0) {
+    throw new ConfigError("verify.timeout must be a positive number (seconds)");
+  }
+  if (config.ai) {
+    const validProviders = ["openai-compatible", "claude", "ollama"];
+    if (!validProviders.includes(config.ai.provider)) {
+      throw new ConfigError(
+        `Invalid ai.provider "${config.ai.provider}". Must be one of: ${validProviders.join(", ")}`
+      );
+    }
+  }
+  const moduleNames = Object.keys(config.project.modules);
+  for (const [name, mod] of Object.entries(config.project.modules)) {
+    if (!mod.path) {
+      throw new ConfigError(`Module "${name}" must have a "path" field`);
+    }
+    if (!mod.responsibility) {
+      throw new ConfigError(`Module "${name}" must have a "responsibility" field`);
+    }
+    if (mod.dependsOn) {
+      for (const dep of mod.dependsOn) {
+        if (!moduleNames.includes(dep)) {
+          throw new ConfigError(
+            `Module "${name}" depends on "${dep}", which is not declared in modules`
+          );
+        }
+      }
+    }
+  }
+}
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(`[SpecLore Config] ${message}`);
+    this.name = "ConfigError";
+  }
+};
+function generateDefaultConfigYaml(projectName) {
+  return `# SpecLore Configuration
+# See: https://github.com/cheneyzhang93/speclore#configuration
+
+project:
+  name: ${projectName}
+  language: typescript
+  framework: ""
+  profile: normal
+  modules: {}
+    # Example:
+    # order:
+    #   path: src/order
+    #   responsibility: Order management and processing
+    #   dependsOn: [inventory, payment]
+
+ai:
+  provider: openai-compatible
+  # baseUrl: https://api.openai.com/v1
+  # model: gpt-4
+
+spec:
+  outputDir: specs
+  defaultLanguage: zh-CN
+  confidenceThreshold: 0.6
+
+verify:
+  command: ""
+  timeout: 300
+  reportFormat:
+    - json
+    - html
+  mapping:
+    patterns:
+      - feature: "specs/{module}/{name}.feature"
+        test: "tests/{module}/{name}.test.*"
+`;
+}
+
+// src/mcp/tools.ts
+init_logger();
+import { join as join19 } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync19, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
+import { globSync as globSync4 } from "glob";
+import { toJSONSchema } from "zod";
+
+// src/mcp/schemas.ts
+import { z } from "zod";
+var specInputSchema = z.object({
+  source: z.string().max(5e4).describe("Requirement source: file path, URL, or direct text content. Max 50000 characters."),
+  module: z.string().optional().describe("Target module name (optional, auto-detected from context).")
+});
+var codeInputSchema = z.object({
+  features: z.array(z.string()).max(50).optional().describe("Feature file paths or glob patterns. Max 50 items."),
+  tools: z.array(z.enum(["cursor", "claude", "qoder"])).optional().describe("AI tools to generate constraints for (optional, auto-detected).")
+});
+var verifyInputSchema = z.object({
+  features: z.array(z.string()).optional().describe("Feature file paths or glob patterns to verify (optional, all if omitted)."),
+  impact: z.boolean().optional().default(false).describe("Enable change impact analysis (compares git diff to find affected features).")
+});
+var statusInputSchema = z.object({
+  feature: z.string().optional().describe("Specific feature file to check (optional, all if omitted).")
+});
+
+// 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 specJsonSchema = toJSONSchema(specInputSchema, { target: "draft-07" });
+var codeJsonSchema = toJSONSchema(codeInputSchema, { target: "draft-07" });
+var verifyJsonSchema = toJSONSchema(verifyInputSchema, { target: "draft-07" });
+async function executeSpecTool(args, projectRoot2) {
+  if (!args.source || args.source.length > 5e4) {
+    throw new Error("source must be between 1 and 50000 characters");
+  }
+  ensureProjectReady(projectRoot2);
+  const config = loadConfig(projectRoot2);
+  logger.info(`Reading requirement from: ${args.source.slice(0, 80)}...`);
+  const req = await readRequirement(args.source);
+  const specLoreDir = join19(projectRoot2, ".speclore");
+  const context = loadContext(specLoreDir) ?? buildContext(projectRoot2, config);
+  const feature = await generateFeature(req, context, config, projectRoot2);
+  const createdFiles = [feature.path];
+  const scenarios = [];
+  for (const sc of feature.scenarios) {
+    scenarios.push({
+      feature: feature.featureName,
+      name: sc.name,
+      given: sc.givens.map((s) => s.text),
+      when: sc.whens.map((s) => s.text),
+      then: sc.thens.map((s) => s.text)
+    });
+  }
+  const stateManager = new StateManager(projectRoot2);
+  stateManager.transitionFeature(feature.path, "specified");
+  const constraints = `Generated ${createdFiles.length} feature file(s) with ${scenarios.length} scenario(s).`;
+  const nextSteps = "Run `speclore code` to generate AI coding constraints, or ask your AI client to implement the scenarios.";
+  return {
+    createdFiles,
+    scenarios,
+    constraints,
+    nextSteps,
+    workflow: buildWorkflowInfo(feature.path, "specified", stateManager)
+  };
+}
+async function executeCodeTool(args, projectRoot2) {
+  if (args.features && args.features.length > 50) {
+    throw new Error("features array must not exceed 50 items");
+  }
+  ensureProjectReady(projectRoot2);
+  const config = loadConfig(projectRoot2);
+  const specLoreDir = join19(projectRoot2, ".speclore");
+  const context = loadContext(specLoreDir) ?? buildContext(projectRoot2, config);
+  const featureFiles = resolveFeatureFiles(args.features, projectRoot2, config);
+  if (featureFiles.length === 0) {
+    const stateManager2 = new StateManager(projectRoot2);
+    return {
+      writtenFiles: [],
+      constraintContent: "Error: No .feature files found.",
+      moduleRules: [],
+      activeConstraints: [],
+      codingGuidance: "",
+      scaffoldFiles: [],
+      workflow: {
+        currentState: "uninitialized",
+        nextStep: "Call speclore.spec with your requirement text to create feature files.",
+        projectSummary: {
+          total: stateManager2.getProjectSummary().featureCount,
+          ...stateManager2.getProjectSummary().states
+        }
+      }
+    };
+  }
+  const writtenFiles = await generateConstraints(projectRoot2, featureFiles, context, config);
+  const scaffoldFiles = generateTestScaffolding(projectRoot2, featureFiles, config);
+  const stateManager = new StateManager(projectRoot2);
+  for (const feature of featureFiles) {
+    try {
+      stateManager.transitionFeature(feature.path, "constrained", ["specified"]);
+      stateManager.updateFeatureEntry(feature.path, {
+        constraintFiles: writtenFiles,
+        testFiles: scaffoldFiles.map((s) => s.testFile)
+      });
+    } catch {
+    }
+  }
+  const constraintContent = buildConstraintSummary(featureFiles, config);
+  const moduleRules = buildModuleRules(config);
+  const activeConstraints = buildActiveConstraints(writtenFiles, projectRoot2);
+  const codingGuidance = buildCodingGuidance(featureFiles, context, config);
+  const firstFeature = featureFiles[0]?.path;
+  return {
+    writtenFiles,
+    constraintContent,
+    moduleRules,
+    activeConstraints,
+    codingGuidance,
+    scaffoldFiles,
+    workflow: buildWorkflowInfo(firstFeature, "constrained", stateManager)
+  };
+}
+async function executeVerifyTool(args, projectRoot2) {
+  ensureProjectReady(projectRoot2);
+  const config = loadConfig(projectRoot2);
+  const specLoreDir = join19(projectRoot2, ".speclore");
+  const context = loadContext(specLoreDir) ?? buildContext(projectRoot2, config);
+  const featureFiles = resolveFeatureFiles(args.features, projectRoot2, config);
+  const stateManager = new StateManager(projectRoot2);
+  for (const feature of featureFiles) {
+    const entry = stateManager.getFeatureState(feature.path);
+    if (!entry || entry.state === "specified") {
+      return {
+        summary: "Error: No test scaffolding found.",
+        passed: 0,
+        failed: 0,
+        unmapped: featureFiles.reduce((sum, f) => sum + f.scenarios.length, 0),
+        details: [],
+        failedDetails: [],
+        workflow: {
+          currentState: entry?.state ?? "uninitialized",
+          nextStep: "Call speclore.code to generate constraints and test scaffolding.",
+          projectSummary: {
+            total: stateManager.getProjectSummary().featureCount,
+            ...stateManager.getProjectSummary().states
+          }
+        }
+      };
+    }
+  }
+  if (args.impact) {
+    logger.info("Running impact analysis...");
+    const impact = analyzeImpact(projectRoot2, context, config);
+    context.impactAnalysis = {
+      changedFiles: impact.changedFiles,
+      affectedModules: impact.affectedModules,
+      affectedFeatures: impact.affectedFeatures
+    };
+  }
+  const report = await runVerification(projectRoot2, featureFiles, config);
+  const { summary } = report;
+  if (summary.failed === 0 && summary.unmapped === 0 && summary.passed > 0) {
+    for (const feature of featureFiles) {
+      try {
+        stateManager.transitionFeature(feature.path, "verified", ["coding", "constrained"]);
+      } catch {
+      }
+      stateManager.recordVerify(feature.path, {
+        passed: summary.passed,
+        failed: summary.failed,
+        unmapped: summary.unmapped
+      });
+    }
+  }
+  const firstFeature = featureFiles[0]?.path;
+  const currentState = summary.failed === 0 && summary.unmapped === 0 && summary.passed > 0 ? "verified" : "coding";
+  return {
+    summary: `${summary.passed}/${summary.totalScenarios} scenarios passed (${summary.passRate})`,
+    passed: summary.passed,
+    failed: summary.failed,
+    unmapped: summary.unmapped,
+    details: report.features,
+    failedDetails: report.failedDetails,
+    workflow: buildWorkflowInfo(firstFeature, currentState, stateManager)
+  };
+}
+function ensureProjectReady(projectRoot2) {
+  const specLoreDir = join19(projectRoot2, ".speclore");
+  const configPath = join19(specLoreDir, "config.yaml");
+  let configCreated = false;
+  if (!existsSync19(specLoreDir)) {
+    mkdirSync10(specLoreDir, { recursive: true });
+  }
+  if (!existsSync19(configPath)) {
+    const projectName = projectRoot2.split(/[/\\]/).pop() ?? "my-project";
+    writeFileSync11(configPath, generateDefaultConfigYaml(projectName), "utf-8");
+    configCreated = true;
+    logger.info(`Auto-created default config: ${configPath}`);
+  }
+  const stateManager = new StateManager(projectRoot2);
+  stateManager.ensureInitialized();
+  const config = loadConfig(projectRoot2);
+  const specsDir = join19(projectRoot2, config.spec.outputDir);
+  const migrated = stateManager.migrateFeatures(specsDir);
+  if (migrated > 0) {
+    logger.info(`Migrated ${migrated} existing .feature file(s) into state tracking.`);
+  }
+  return { initialized: true, configCreated, migrated };
+}
+function buildWorkflowInfo(featurePath, currentState, stateManager) {
+  const summary = stateManager.getProjectSummary();
+  const nextStep = resolveNextStep(currentState, summary);
+  return {
+    feature: featurePath,
+    currentState,
+    nextStep,
+    projectSummary: {
+      total: summary.featureCount,
+      ...summary.states
+    }
+  };
+}
+function resolveNextStep(currentState, _summary) {
+  switch (currentState) {
+    case "uninitialized":
+      return "Call speclore.spec with your requirement text to create feature files.";
+    case "specified":
+      return "Call speclore.code to generate constraints and test scaffolding.";
+    case "constrained":
+      return "Start coding. Constraints and test scaffolding are ready. Fill in test implementations.";
+    case "coding":
+      return "Run speclore.verify to check acceptance status.";
+    case "verified":
+      return "All features verified. Add new requirements with speclore.spec.";
+    default:
+      return "";
+  }
+}
+function resolveFeatureFiles(patterns, projectRoot2, config) {
+  const specsDir = join19(projectRoot2, config.spec.outputDir);
+  const searchPatterns = patterns && patterns.length > 0 ? patterns : [`${specsDir}/**/*.feature`];
+  const files = [];
+  for (const pattern of searchPatterns) {
+    const matches = globSync4(pattern, { cwd: projectRoot2, absolute: true });
+    for (const filePath of matches) {
+      if (existsSync19(filePath)) {
+        const content = readFileSync15(filePath, "utf-8");
+        files.push(parseFeatureFile(filePath, content));
+      }
+    }
+  }
+  return files;
+}
+function parseFeatureFile(filePath, content) {
+  const featureMatch = content.match(/Feature:\s*(.+)/);
+  const featureName = featureMatch?.[1]?.trim() ?? filePath;
+  const scenarios = [];
+  const tags = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const tagMatch = line.trim().match(/^(@\S+(?:\s+@\S+)*)/);
+    if (tagMatch) {
+      tags.push(...tagMatch[1].split(/\s+/).filter((t) => t.startsWith("@")));
+    }
+  }
+  const scenarioRegex = /Scenario(?: Outline)?:\s*(.+)/g;
+  let match;
+  while ((match = scenarioRegex.exec(content)) !== null) {
+    scenarios.push({
+      name: match[1].trim(),
+      givens: [],
+      whens: [],
+      thens: [],
+      tags: []
+    });
+  }
+  return {
+    path: filePath,
+    featureName,
+    scenarios,
+    tags,
+    confidence: 1,
+    needsReview: []
+  };
+}
+function buildConstraintSummary(features, config) {
+  const moduleCount = Object.keys(config.project.modules).length;
+  const scenarioCount = features.reduce((sum, f) => sum + f.scenarios.length, 0);
+  return `Constraints for ${moduleCount} module(s), ${features.length} feature(s), ${scenarioCount} scenario(s). Profile: ${config.project.profile}.`;
+}
+function buildModuleRules(config) {
+  const rules = [];
+  for (const [name, mod] of Object.entries(config.project.modules)) {
+    rules.push({
+      module: name,
+      boundaries: {
+        name,
+        responsibility: mod.responsibility,
+        publicApis: mod.apis ?? [],
+        internalObjects: mod.entities ?? [],
+        dependsOn: mod.dependsOn ?? []
+      },
+      namingConventions: [],
+      forbiddenPatterns: []
+    });
+  }
+  return rules;
+}
+function buildActiveConstraints(writtenFiles, _projectRoot) {
+  return writtenFiles.map((file) => ({
+    file,
+    scope: "project",
+    appliesTo: "**/*",
+    summary: `SpecLore constraint file \u2014 module boundaries and coding rules`
+  }));
+}
+function buildCodingGuidance(_features, context, config) {
+  const parts = [];
+  parts.push(`Project: ${config.project.name}`);
+  parts.push(`Language: ${context.projectSummary.language}, Framework: ${context.projectSummary.framework}`);
+  parts.push(`Modules: ${Object.keys(config.project.modules).join(", ")}`);
+  parts.push(`Profile: ${config.project.profile}`);
+  if (context.moduleBoundaries.length > 0) {
+    parts.push("Module boundaries: respect module separation, do not cross-reference internal objects.");
+  }
+  const guidance = parts.join(". ") + ".";
+  return guidance.slice(0, 2e3);
+}
+
+// src/setup/detector.ts
+import { existsSync as existsSync20 } 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)));
+  tools.push({
+    tool: "cursor",
+    detected: existsSync20(join20(projectRoot2, ".cursor")),
+    configFiles: cursorConfigs
+  });
+  const claudeFiles = [".claude/", ".mcp.json", "CLAUDE.md"];
+  const claudeConfigs = claudeFiles.filter((f) => existsSync20(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)));
+  tools.push({
+    tool: "qoder",
+    detected: existsSync20(join20(projectRoot2, ".qoder")),
+    configFiles: qoderConfigs
+  });
+  return tools.filter((t) => t.detected);
+}
+
+// src/mcp/status.ts
+init_logger();
+import { readFileSync as readFileSync16, existsSync as existsSync21, mkdirSync as mkdirSync11, writeFileSync as writeFileSync12 } from "fs";
+import { join as join21 } from "path";
+import { globSync as globSync5 } from "glob";
+function executeStatusTool(args, projectRoot2) {
+  const { configCreated } = ensureProjectReadyForStatus(projectRoot2);
+  const config = loadConfig(projectRoot2);
+  const stateManager = new StateManager(projectRoot2);
+  const summary = stateManager.getProjectSummary();
+  const aiTools = detectAITools2(projectRoot2);
+  const aiToolsDetected = aiTools.map((t) => t.tool);
+  const featureEntries = stateManager.listFeatures();
+  const features = [];
+  for (const { path, state: entry } of featureEntries) {
+    if (args.feature && !path.includes(args.feature)) {
+      continue;
+    }
+    let scenarioCount = 0;
+    if (existsSync21(path)) {
+      try {
+        const content = readFileSync16(path, "utf-8");
+        const matches = content.match(/Scenario(?: Outline)?:/g);
+        scenarioCount = matches?.length ?? 0;
+      } catch {
+      }
+    }
+    features.push({
+      file: path,
+      state: entry.state,
+      scenarios: scenarioCount,
+      constraintFiles: entry.constraintFiles,
+      testFiles: entry.testFiles,
+      lastVerify: entry.lastVerify ? { passed: entry.lastVerify.passed, failed: entry.lastVerify.failed, timestamp: entry.lastVerify.timestamp } : void 0
+    });
+  }
+  const specsDir = join21(projectRoot2, config.spec.outputDir);
+  const allFeatureFiles = globSync5(`${specsDir}/**/*.feature`, { cwd: projectRoot2, absolute: true });
+  const trackedPaths = new Set(featureEntries.map((f) => f.path));
+  for (const filePath of allFeatureFiles) {
+    if (trackedPaths.has(filePath)) continue;
+    if (args.feature && !filePath.includes(args.feature)) continue;
+    let scenarioCount = 0;
+    try {
+      const content = readFileSync16(filePath, "utf-8");
+      const matches = content.match(/Scenario(?: Outline)?:/g);
+      scenarioCount = matches?.length ?? 0;
+    } catch {
+    }
+    features.push({
+      file: filePath,
+      state: "specified",
+      scenarios: scenarioCount,
+      constraintFiles: [],
+      testFiles: []
+    });
+  }
+  const recommendedActions = buildRecommendedActions(features, summary, config.verify.command);
+  return {
+    project: {
+      initialized: true,
+      configCreated,
+      testCommand: config.verify.command,
+      aiToolsDetected
+    },
+    features,
+    summary: {
+      total: features.length,
+      specified: features.filter((f) => f.state === "specified").length,
+      constrained: features.filter((f) => f.state === "constrained").length,
+      coding: features.filter((f) => f.state === "coding").length,
+      verified: features.filter((f) => f.state === "verified").length
+    },
+    recommendedActions
+  };
+}
+function buildRecommendedActions(features, summary, testCommand) {
+  const actions = [];
+  if (features.length === 0) {
+    actions.push("Call speclore.spec with your requirement to create feature files.");
+    return actions;
+  }
+  if (summary.states.specified > 0) {
+    actions.push("Call speclore.code to generate constraints and test scaffolding for specified features.");
+  }
+  if (summary.states.constrained > 0) {
+    actions.push("Fill in test scaffolding implementations, then start coding.");
+  }
+  if (summary.states.coding > 0) {
+    if (!testCommand) {
+      actions.push("Configure verify.command in .speclore/config.yaml, then call speclore.verify.");
+    } else {
+      actions.push("Call speclore.verify to check acceptance status.");
+    }
+  }
+  if (summary.states.verified === features.length && features.length > 0) {
+    actions.push("All features verified. Add new requirements with speclore.spec.");
+  }
+  return actions;
+}
+function ensureProjectReadyForStatus(projectRoot2) {
+  const specLoreDir = join21(projectRoot2, ".speclore");
+  const configPath = join21(specLoreDir, "config.yaml");
+  let configCreated = false;
+  if (!existsSync21(specLoreDir)) {
+    mkdirSync11(specLoreDir, { recursive: true });
+  }
+  if (!existsSync21(configPath)) {
+    const projectName = projectRoot2.split(/[/\\]/).pop() ?? "my-project";
+    writeFileSync12(configPath, generateDefaultConfigYaml(projectName), "utf-8");
+    configCreated = true;
+    logger.info(`Auto-created default config: ${configPath}`);
+  }
+  const stateManager = new StateManager(projectRoot2);
+  stateManager.ensureInitialized();
+  const config = loadConfig(projectRoot2);
+  const specsDir = join21(projectRoot2, config.spec.outputDir);
+  const migrated = stateManager.migrateFeatures(specsDir);
+  if (migrated > 0) {
+    logger.info(`Migrated ${migrated} existing .feature file(s) into state tracking.`);
+  }
+  return { initialized: true, configCreated, migrated };
+}
+
+// src/mcp/server.ts
+import { mkdirSync as mkdirSync12 } from "fs";
+var server = new McpServer(
+  { name: "speclore", version: VERSION },
+  { capabilities: { tools: {} } }
+);
+server.registerTool(
+  "speclore.spec",
+  {
+    description: SPEC_TOOL_DESC,
+    inputSchema: specInputSchema.shape
+  },
+  async (args) => {
+    if (!args.source || args.source.length > 5e4) {
+      return { content: [{ type: "text", text: "Error: source must be between 1 and 50000 characters" }], isError: true };
+    }
+    const result = await executeSpecTool(
+      { source: args.source, module: args.module },
+      getProjectRoot()
+    );
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.registerTool(
+  "speclore.code",
+  {
+    description: CODE_TOOL_DESC,
+    inputSchema: codeInputSchema.shape
+  },
+  async (args) => {
+    if (args.features && args.features.length > 50) {
+      return { content: [{ type: "text", text: "Error: features array must not exceed 50 items" }], isError: true };
+    }
+    const result = await executeCodeTool(
+      { features: args.features, tools: args.tools },
+      getProjectRoot()
+    );
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.registerTool(
+  "speclore.verify",
+  {
+    description: VERIFY_TOOL_DESC,
+    inputSchema: verifyInputSchema.shape
+  },
+  async (args) => {
+    const result = await executeVerifyTool(
+      { features: args.features, impact: args.impact },
+      getProjectRoot()
+    );
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.registerTool(
+  "speclore.status",
+  {
+    description: STATUS_TOOL_DESC,
+    inputSchema: statusInputSchema.shape
+  },
+  async (args) => {
+    const result = executeStatusTool(
+      { feature: args.feature },
+      getProjectRoot()
+    );
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+var projectRoot = process.env.SPECLORE_PROJECT_ROOT ?? process.cwd();
+function getProjectRoot() {
+  return projectRoot;
+}
+async function startMcpServer() {
+  projectRoot = process.env.SPECLORE_PROJECT_ROOT ?? process.cwd();
+  const specLoreDir = `${projectRoot}/.speclore`;
+  try {
+    mkdirSync12(specLoreDir, { recursive: true });
+    const locked = acquireLock(specLoreDir);
+    if (!locked) {
+      logger.warn("Could not acquire lock \u2014 another SpecLore instance may be running.");
+    }
+  } catch {
+    logger.warn("Could not acquire lock \u2014 .speclore/ directory may not exist.");
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.debug("MCP Server started (stdio transport)");
+  const cleanup = () => {
+    try {
+      releaseLock(`${projectRoot}/.speclore`);
+    } catch {
+    }
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+
+// src/bin/mcp.ts
+startMcpServer().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`MCP server error: ${message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map