musubix2 0.3.6 → 0.3.8

package/dist/index.js

@@ -1,3 +1,1457 @@
+// dist/index.js
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { randomUUID } from "node:crypto";
+import { readFile as readFile22, writeFile, mkdir } from "node:fs/promises";
+import { join as join22, dirname } from "node:path";
+import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import ts from "typescript";
+import { readFileSync, existsSync } from "node:fs";
+var ActionableError = class _ActionableError extends Error {
+  code;
+  severity;
+  context;
+  suggestions;
+  constructor(message, options) {
+    super(message);
+    this.name = "ActionableError";
+    this.code = options.code;
+    this.severity = options.severity ?? "error";
+    this.context = options.context ?? {};
+    this.suggestions = options.suggestions ?? [];
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ActionableError);
+    }
+    if (options.cause) {
+      this.cause = options.cause;
+    }
+  }
+  static withSuggestion(message, code, suggestion) {
+    return new _ActionableError(message, {
+      code,
+      suggestions: [suggestion]
+    });
+  }
+  static fromError(error, code, suggestions) {
+    return new _ActionableError(error.message, {
+      code,
+      cause: error,
+      suggestions
+    });
+  }
+  static isActionableError(error) {
+    return error instanceof _ActionableError;
+  }
+  addSuggestion(suggestion) {
+    this.suggestions.push(suggestion);
+    return this;
+  }
+  toFormattedString() {
+    return ErrorFormatter.format(this);
+  }
+};
+var ErrorCodes = {
+  // Validation errors
+  EARS_VALIDATION_FAILED: "EARS_VALIDATION_FAILED",
+  TRACEABILITY_MISSING: "TRACEABILITY_MISSING",
+  DESIGN_INCOMPLETE: "DESIGN_INCOMPLETE",
+  // File errors
+  FILE_NOT_FOUND: "FILE_NOT_FOUND",
+  FILE_PARSE_ERROR: "FILE_PARSE_ERROR",
+  FILE_WRITE_ERROR: "FILE_WRITE_ERROR",
+  // Configuration errors
+  CONFIG_MISSING: "CONFIG_MISSING",
+  CONFIG_INVALID: "CONFIG_INVALID",
+  // Workflow errors
+  PHASE_TRANSITION_BLOCKED: "PHASE_TRANSITION_BLOCKED",
+  QUALITY_GATE_FAILED: "QUALITY_GATE_FAILED",
+  APPROVAL_REQUIRED: "APPROVAL_REQUIRED",
+  // Generation errors
+  CODEGEN_FAILED: "CODEGEN_FAILED",
+  TEMPLATE_NOT_FOUND: "TEMPLATE_NOT_FOUND",
+  // Pattern errors
+  PATTERN_NOT_FOUND: "PATTERN_NOT_FOUND",
+  PATTERN_CONFLICT: "PATTERN_CONFLICT"
+};
+var ErrorFormatter = class _ErrorFormatter {
+  static useColors = true;
+  static setColorOutput(enabled) {
+    _ErrorFormatter.useColors = enabled;
+  }
+  static format(error) {
+    const lines = [];
+    const icon = _ErrorFormatter.getSeverityIcon(error.severity);
+    const header = `${icon} [${error.code}] ${error.message}`;
+    lines.push(_ErrorFormatter.colorize(header, error.severity));
+    if (error.context.file) {
+      let location = `   \u{1F4CD} ${error.context.file}`;
+      if (error.context.line !== void 0) {
+        location += `:${error.context.line}`;
+        if (error.context.column !== void 0) {
+          location += `:${error.context.column}`;
+        }
+      }
+      lines.push(location);
+    }
+    if (error.context.artifactId) {
+      lines.push(`   \u{1F4CE} Related: ${error.context.artifactId}`);
+    }
+    if (error.suggestions.length > 0) {
+      lines.push("");
+      lines.push("   \u{1F4A1} Suggestions:");
+      for (const suggestion of error.suggestions) {
+        lines.push(`      \u2022 ${suggestion.action}: ${suggestion.description}`);
+        if (suggestion.command) {
+          lines.push(`        $ ${suggestion.command}`);
+        }
+        if (suggestion.docLink) {
+          lines.push(`        \u{1F4D6} ${suggestion.docLink}`);
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  static formatAll(errors) {
+    if (errors.length === 0) {
+      return _ErrorFormatter.colorize("\u2705 No errors", "info");
+    }
+    const lines = [];
+    const counts = {
+      error: errors.filter((e) => e.severity === "error").length,
+      warning: errors.filter((e) => e.severity === "warning").length,
+      info: errors.filter((e) => e.severity === "info").length
+    };
+    lines.push(`Found ${errors.length} issue(s): ${counts.error} errors, ${counts.warning} warnings, ${counts.info} info
+`);
+    for (const error of errors) {
+      lines.push(_ErrorFormatter.format(error));
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  static formatAsJson(error) {
+    return JSON.stringify({
+      code: error.code,
+      severity: error.severity,
+      message: error.message,
+      context: error.context,
+      suggestions: error.suggestions
+    }, null, 2);
+  }
+  static getSeverityIcon(severity) {
+    switch (severity) {
+      case "error":
+        return "\u274C";
+      case "warning":
+        return "\u26A0\uFE0F";
+      case "info":
+        return "\u2139\uFE0F";
+    }
+  }
+  static colorize(text, severity) {
+    if (!_ErrorFormatter.useColors) {
+      return text;
+    }
+    const colors = {
+      error: "\x1B[31m",
+      warning: "\x1B[33m",
+      info: "\x1B[36m"
+    };
+    const reset = "\x1B[0m";
+    return `${colors[severity]}${text}${reset}`;
+  }
+};
+var CommonErrors = {
+  fileNotFound(path) {
+    return new ActionableError(`File not found: ${path}`, {
+      code: ErrorCodes.FILE_NOT_FOUND,
+      context: { file: path },
+      suggestions: [
+        {
+          action: "Check path",
+          description: "Verify the file path is correct"
+        },
+        {
+          action: "Create file",
+          description: "Create the missing file if needed",
+          command: `touch ${path}`
+        }
+      ]
+    });
+  },
+  earsValidationFailed(file, issues) {
+    return new ActionableError(`EARS validation failed with ${issues.length} issue(s)`, {
+      code: ErrorCodes.EARS_VALIDATION_FAILED,
+      context: { file },
+      suggestions: [
+        {
+          action: "Review EARS format",
+          description: "Ensure requirements follow EARS patterns (Ubiquitous, Event-driven, etc.)"
+        },
+        {
+          action: "Run validation",
+          description: "Use the validation command to see detailed issues",
+          command: `npx musubix requirements validate ${file}`
+        }
+      ]
+    });
+  },
+  traceabilityMissing(reqId, designId) {
+    return new ActionableError(`Missing traceability link: ${reqId} \u2192 ${designId}`, {
+      code: ErrorCodes.TRACEABILITY_MISSING,
+      severity: "warning",
+      context: { artifactId: reqId },
+      suggestions: [
+        {
+          action: "Add trace link",
+          description: `Link ${reqId} to its design element`,
+          command: "npx musubix trace sync"
+        }
+      ]
+    });
+  },
+  phaseTransitionBlocked(from, to, reason) {
+    return new ActionableError(`Cannot transition from ${from} to ${to}: ${reason}`, {
+      code: ErrorCodes.PHASE_TRANSITION_BLOCKED,
+      suggestions: [
+        {
+          action: "Complete requirements",
+          description: "Ensure all prerequisite artifacts are complete"
+        },
+        {
+          action: "Check quality gates",
+          description: "Verify all quality gates pass",
+          command: "npx musubix workflow get-status"
+        }
+      ]
+    });
+  },
+  qualityGateFailed(gate, details) {
+    return new ActionableError(`Quality gate failed: ${gate}`, {
+      code: ErrorCodes.QUALITY_GATE_FAILED,
+      suggestions: [
+        {
+          action: "Fix issues",
+          description: details
+        },
+        {
+          action: "View report",
+          description: "Check the quality gate report for details",
+          command: "npx musubix workflow validate-transition"
+        }
+      ]
+    });
+  }
+};
+var MemoryCacheProvider = class {
+  cache = /* @__PURE__ */ new Map();
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (entry.expires && entry.expires < Date.now()) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttl) {
+    this.cache.set(key, {
+      value,
+      expires: ttl ? Date.now() + ttl : 0
+    });
+  }
+  async delete(key) {
+    this.cache.delete(key);
+  }
+  async clear() {
+    this.cache.clear();
+  }
+};
+var MemoryQueueProvider = class {
+  queue = [];
+  counter = 0;
+  async enqueue(item) {
+    const id = `q-${Date.now()}-${++this.counter}`;
+    this.queue.push({ id, item });
+    return id;
+  }
+  async dequeue() {
+    const entry = this.queue.shift();
+    return entry ? entry.item : null;
+  }
+  async size() {
+    return this.queue.length;
+  }
+  async clear() {
+    this.queue = [];
+  }
+};
+var DEFAULT_DEGRADATION_CONFIG = {
+  services: [],
+  healthCheckInterval: 3e4,
+  autoRecovery: true,
+  maxQueueSize: 1e3
+};
+var GracefulDegradation = class {
+  config;
+  serviceStatus;
+  currentLevel = "full";
+  events = [];
+  eventCounter = 0;
+  healthCheckTimer;
+  cache;
+  queue;
+  constructor(config) {
+    this.config = { ...DEFAULT_DEGRADATION_CONFIG, ...config };
+    this.serviceStatus = /* @__PURE__ */ new Map();
+    this.cache = config?.cacheProvider ?? new MemoryCacheProvider();
+    this.queue = config?.queueProvider ?? new MemoryQueueProvider();
+    for (const service of this.config.services) {
+      this.serviceStatus.set(service.name, {
+        service: service.name,
+        status: "unknown"
+      });
+    }
+  }
+  start() {
+    this.runHealthChecks();
+    this.healthCheckTimer = setInterval(() => this.runHealthChecks(), this.config.healthCheckInterval);
+  }
+  stop() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = void 0;
+    }
+  }
+  registerService(service) {
+    this.config.services.push(service);
+    this.serviceStatus.set(service.name, {
+      service: service.name,
+      status: "unknown"
+    });
+  }
+  async execute(serviceName, operation, options) {
+    const service = this.config.services.find((s) => s.name === serviceName);
+    const status = this.serviceStatus.get(serviceName);
+    if (!status || status.status === "healthy" || status.status === "unknown") {
+      try {
+        const value = await this.withTimeout(operation, options?.timeout ?? 3e4);
+        if (options?.cacheKey) {
+          await this.cache.set(options.cacheKey, value, service?.cacheTtl);
+        }
+        return {
+          value,
+          degraded: false,
+          level: this.currentLevel,
+          warnings: []
+        };
+      } catch (error) {
+        return this.executeFallback(serviceName, error, options);
+      }
+    }
+    return this.executeFallback(serviceName, new Error(`Service ${serviceName} is ${status.status}`), options);
+  }
+  async executeFallback(serviceName, error, options) {
+    const service = this.config.services.find((s) => s.name === serviceName);
+    const strategies = service?.fallbackStrategies ?? ["default"];
+    const warnings = [`Primary operation failed: ${error.message}`];
+    for (const strategy of strategies) {
+      try {
+        const result = await this.executeStrategy(serviceName, strategy, options);
+        if (result !== null) {
+          return {
+            value: result,
+            degraded: true,
+            level: this.currentLevel,
+            strategy,
+            originalError: error,
+            warnings
+          };
+        }
+      } catch (e) {
+        warnings.push(`Fallback ${strategy} failed: ${e.message}`);
+      }
+    }
+    throw new Error(`All fallback strategies failed for ${serviceName}. Warnings: ${warnings.join("; ")}`);
+  }
+  async executeStrategy(_serviceName, strategy, options) {
+    switch (strategy) {
+      case "cache":
+        if (options?.cacheKey) {
+          const cached = await this.cache.get(options.cacheKey);
+          if (cached !== null) {
+            return cached;
+          }
+        }
+        return null;
+      case "default":
+        if (options?.defaultValue !== void 0) {
+          return options.defaultValue;
+        }
+        return null;
+      case "retry":
+        return null;
+      case "alternative":
+        return null;
+      case "skip":
+        return null;
+      case "queue":
+        if (await this.queue.size() < this.config.maxQueueSize) {
+          await this.queue.enqueue({
+            service: _serviceName,
+            timestamp: /* @__PURE__ */ new Date(),
+            options
+          });
+        }
+        return null;
+      case "manual":
+        return null;
+      default:
+        return null;
+    }
+  }
+  async runHealthChecks() {
+    const results = /* @__PURE__ */ new Map();
+    for (const service of this.config.services) {
+      const result = await this.checkServiceHealth(service);
+      results.set(service.name, result);
+      const previousStatus = this.serviceStatus.get(service.name);
+      this.serviceStatus.set(service.name, result);
+      if (previousStatus?.status !== result.status) {
+        if (result.status === "unavailable" || result.status === "degraded") {
+          this.handleServiceDegradation(service, result);
+        } else if (result.status === "healthy" && previousStatus?.status !== "healthy") {
+          this.handleServiceRecovery(service);
+        }
+      }
+    }
+    this.recalculateLevel();
+    return results;
+  }
+  async checkServiceHealth(service) {
+    const startTime = Date.now();
+    try {
+      const healthy = await this.withTimeout(service.healthCheck, 5e3);
+      const responseTime = Date.now() - startTime;
+      return {
+        service: service.name,
+        status: healthy ? "healthy" : "degraded",
+        responseTime,
+        lastSuccess: healthy ? /* @__PURE__ */ new Date() : void 0
+      };
+    } catch (error) {
+      return {
+        service: service.name,
+        status: "unavailable",
+        responseTime: Date.now() - startTime,
+        error: error.message
+      };
+    }
+  }
+  handleServiceDegradation(service, result) {
+    const previousLevel = this.currentLevel;
+    const event = {
+      id: `deg-${Date.now()}-${++this.eventCounter}`,
+      timestamp: /* @__PURE__ */ new Date(),
+      service: service.name,
+      previousLevel,
+      newLevel: this.currentLevel,
+      reason: result.error ?? `Service ${service.name} is ${result.status}`
+    };
+    this.events.push(event);
+    this.config.onDegradation?.(event);
+  }
+  handleServiceRecovery(service) {
+    this.config.onRecovery?.(service.name, this.currentLevel);
+    if (this.config.autoRecovery) {
+      this.processQueue(service.name).catch(() => {
+      });
+    }
+  }
+  async processQueue(serviceName) {
+    let processed = 0;
+    const maxProcess = 10;
+    while (processed < maxProcess) {
+      const item = await this.queue.dequeue();
+      if (!item) {
+        break;
+      }
+      if (item.service === serviceName) {
+        processed++;
+      } else {
+        await this.queue.enqueue(item);
+      }
+    }
+  }
+  recalculateLevel() {
+    const statuses = [...this.serviceStatus.values()];
+    const unavailableRequired = this.config.services.filter((s) => s.required && this.serviceStatus.get(s.name)?.status === "unavailable");
+    const totalUnavailable = statuses.filter((s) => s.status === "unavailable").length;
+    const totalDegraded = statuses.filter((s) => s.status === "degraded").length;
+    if (unavailableRequired.length > 0) {
+      this.currentLevel = "emergency";
+    } else if (totalUnavailable > statuses.length / 2) {
+      this.currentLevel = "offline";
+    } else if (totalUnavailable > 0) {
+      this.currentLevel = "minimal";
+    } else if (totalDegraded > 0) {
+      this.currentLevel = "reduced";
+    } else {
+      this.currentLevel = "full";
+    }
+  }
+  getLevel() {
+    return this.currentLevel;
+  }
+  getServiceStatus(serviceName) {
+    return this.serviceStatus.get(serviceName);
+  }
+  getAllStatuses() {
+    return new Map(this.serviceStatus);
+  }
+  getEvents(limit) {
+    const events = [...this.events].sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    return limit ? events.slice(0, limit) : events;
+  }
+  isFeatureAvailable(requiredLevel) {
+    const levels = ["full", "reduced", "minimal", "offline", "emergency"];
+    return levels.indexOf(this.currentLevel) <= levels.indexOf(requiredLevel);
+  }
+  async cacheValue(key, value, ttl) {
+    await this.cache.set(key, value, ttl);
+  }
+  async getCachedValue(key) {
+    return this.cache.get(key);
+  }
+  async clearCache() {
+    await this.cache.clear();
+  }
+  async withTimeout(operation, timeout) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Operation timed out after ${timeout}ms`));
+      }, timeout);
+      operation().then((result) => {
+        clearTimeout(timer);
+        resolve(result);
+      }).catch((error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+};
+function createGracefulDegradation(config) {
+  return new GracefulDegradation(config);
+}
+async function retryWithBackoff(operation, options) {
+  const maxAttempts = options?.maxAttempts ?? 3;
+  const initialDelay = options?.initialDelay ?? 1e3;
+  const maxDelay = options?.maxDelay ?? 3e4;
+  const backoffFactor = options?.backoffFactor ?? 2;
+  let lastError;
+  let delay = initialDelay;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * backoffFactor, maxDelay);
+      }
+    }
+  }
+  throw lastError ?? new Error("Operation failed after retries");
+}
+var CircuitBreaker = class {
+  threshold;
+  resetTimeout;
+  failures = 0;
+  lastFailure;
+  state = "closed";
+  constructor(threshold = 5, resetTimeout = 6e4) {
+    this.threshold = threshold;
+    this.resetTimeout = resetTimeout;
+  }
+  async execute(operation) {
+    if (this.state === "open") {
+      if (this.shouldAttemptReset()) {
+        this.state = "half-open";
+      } else {
+        throw new Error("Circuit breaker is open");
+      }
+    }
+    try {
+      const result = await operation();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+  shouldAttemptReset() {
+    if (!this.lastFailure) {
+      return true;
+    }
+    return Date.now() - this.lastFailure.getTime() > this.resetTimeout;
+  }
+  onSuccess() {
+    this.failures = 0;
+    this.state = "closed";
+  }
+  onFailure() {
+    this.failures++;
+    this.lastFailure = /* @__PURE__ */ new Date();
+    if (this.failures >= this.threshold) {
+      this.state = "open";
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  reset() {
+    this.failures = 0;
+    this.lastFailure = void 0;
+    this.state = "closed";
+  }
+};
+var ConsoleTransport = class {
+  write(entry) {
+    const prefix = `[${entry.timestamp.toISOString()}] [${entry.level.toUpperCase()}]`;
+    const src = entry.source ? ` (${entry.source})` : "";
+    const msg = `${prefix}${src} ${entry.message}`;
+    switch (entry.level) {
+      case "error":
+        console.error(msg);
+        break;
+      case "warn":
+        console.warn(msg);
+        break;
+      case "debug":
+        console.debug(msg);
+        break;
+      default:
+        console.log(msg);
+    }
+  }
+};
+var LOG_LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class _Logger {
+  transports;
+  minLevel;
+  source;
+  constructor(options) {
+    this.transports = options?.transports ?? [new ConsoleTransport()];
+    this.minLevel = options?.level ?? "info";
+    this.source = options?.source;
+  }
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  warn(message, context) {
+    this.log("warn", message, context);
+  }
+  error(message, context) {
+    this.log("error", message, context);
+  }
+  child(source) {
+    return new _Logger({
+      transports: this.transports,
+      level: this.minLevel,
+      source: this.source ? `${this.source}:${source}` : source
+    });
+  }
+  log(level, message, context) {
+    if (LOG_LEVEL_ORDER[level] < LOG_LEVEL_ORDER[this.minLevel]) {
+      return;
+    }
+    const entry = {
+      level,
+      message,
+      timestamp: /* @__PURE__ */ new Date(),
+      context,
+      source: this.source
+    };
+    for (const transport of this.transports) {
+      transport.write(entry);
+    }
+  }
+};
+var AuditLogger = class {
+  events = [];
+  logger;
+  constructor(logger) {
+    this.logger = logger ?? new Logger({ source: "audit" });
+  }
+  record(event) {
+    const full = { ...event, timestamp: /* @__PURE__ */ new Date() };
+    this.events.push(full);
+    this.logger.info(`[AUDIT] ${event.action} on ${event.target} by ${event.actor}: ${event.result}`);
+  }
+  getEvents(filter) {
+    return this.events.filter((e) => {
+      if (filter?.action && e.action !== filter.action) {
+        return false;
+      }
+      if (filter?.actor && e.actor !== filter.actor) {
+        return false;
+      }
+      return true;
+    });
+  }
+  clear() {
+    this.events.length = 0;
+  }
+};
+var DEFAULT_CONFIG = {
+  steeringDir: "steering",
+  storageDir: "storage",
+  llm: {
+    provider: "github-copilot",
+    model: "default"
+  },
+  knowledge: {
+    basePath: "storage/specs"
+  },
+  integration: {
+    confidenceThreshold: 0.85
+  }
+};
+var CONFIG_FILENAME = "musubix.config.json";
+var ConfigLoader = class {
+  config = null;
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath ?? process.cwd();
+  }
+  async load() {
+    const configPath = join(this.basePath, CONFIG_FILENAME);
+    try {
+      const raw = await readFile(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      this.config = this.merge(parsed);
+      return this.config;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new ActionableError(`Configuration file not found: ${configPath}`, {
+          code: ErrorCodes.CONFIG_MISSING,
+          context: { file: configPath },
+          suggestions: [
+            {
+              action: "Initialize project",
+              description: "Run init to create default configuration",
+              command: "npx musubix init"
+            }
+          ]
+        });
+      }
+      throw new ActionableError(`Failed to parse configuration: ${error.message}`, {
+        code: ErrorCodes.CONFIG_INVALID,
+        context: { file: configPath },
+        cause: error,
+        suggestions: [
+          {
+            action: "Check JSON syntax",
+            description: "Ensure musubix.config.json is valid JSON"
+          }
+        ]
+      });
+    }
+  }
+  getConfig() {
+    if (!this.config) {
+      return DEFAULT_CONFIG;
+    }
+    return this.config;
+  }
+  merge(partial) {
+    return {
+      steeringDir: partial.steeringDir ?? DEFAULT_CONFIG.steeringDir,
+      storageDir: partial.storageDir ?? DEFAULT_CONFIG.storageDir,
+      llm: {
+        ...DEFAULT_CONFIG.llm,
+        ...partial.llm
+      },
+      knowledge: {
+        ...DEFAULT_CONFIG.knowledge,
+        ...partial.knowledge
+      },
+      integration: {
+        ...DEFAULT_CONFIG.integration,
+        ...partial.integration
+      }
+    };
+  }
+};
+var InMemoryRepository = class {
+  store = /* @__PURE__ */ new Map();
+  async get(id) {
+    return this.store.get(id);
+  }
+  async getAll() {
+    return [...this.store.values()];
+  }
+  async save(entity) {
+    this.store.set(entity.id, entity);
+  }
+  async delete(id) {
+    return this.store.delete(id);
+  }
+  async exists(id) {
+    return this.store.has(id);
+  }
+};
+function createInMemoryRepository() {
+  return new InMemoryRepository();
+}
+var ExitCode = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  VALIDATION_ERROR: 2,
+  CONFIG_ERROR: 3,
+  PHASE_BLOCKED: 4
+};
+function formatSuccess(message) {
+  return `\u2705 ${message}`;
+}
+function formatError(message) {
+  return `\u274C ${message}`;
+}
+function formatTable(headers, rows) {
+  const widths = headers.map((h, i) => {
+    const maxRow = Math.max(...rows.map((r) => (r[i] ?? "").length));
+    return Math.max(h.length, maxRow);
+  });
+  const header = headers.map((h, i) => h.padEnd(widths[i])).join(" | ");
+  const separator = widths.map((w) => "-".repeat(w)).join("-+-");
+  const body = rows.map((row) => row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join(" | ")).join("\n");
+  return `${header}
+${separator}
+${body}`;
+}
+var PATTERN_RULES = [
+  {
+    pattern: "event-driven",
+    regex: /\bWHEN\b.*\b(THE\s+.+\s+)?SHALL\b/i,
+    baseConfidence: 0.6,
+    bonus: 0.25
+  },
+  {
+    pattern: "state-driven",
+    regex: /\bWHILE\b.*\b(THE\s+.+\s+)?SHALL\b/i,
+    baseConfidence: 0.6,
+    bonus: 0.25
+  },
+  {
+    pattern: "unwanted",
+    regex: /\bSHALL\s+NOT\b/i,
+    baseConfidence: 0.6,
+    bonus: 0.2
+  },
+  {
+    pattern: "optional",
+    regex: /\bWHERE\b.*\b(THE\s+.+\s+)?SHALL\b/i,
+    baseConfidence: 0.6,
+    bonus: 0.2
+  },
+  {
+    pattern: "complex",
+    regex: /\bIF\b.*\bTHEN\b.*\bSHALL\b/i,
+    baseConfidence: 0.55,
+    bonus: 0.15
+  },
+  {
+    pattern: "ubiquitous",
+    regex: /\b(THE\s+.+\s+)?SHALL\b/i,
+    baseConfidence: 0.5,
+    bonus: 0
+  }
+];
+var COMPLEX_COMBINATIONS = [
+  /\bWHEN\b.*\bWHILE\b/i,
+  /\bWHILE\b.*\bWHEN\b/i,
+  /\bIF\b.*\bWHEN\b/i
+];
+var EARSValidator = class {
+  analyze(text, options) {
+    const cleaned = this.cleanText(text, options?.sourceFormat);
+    for (const combo of COMPLEX_COMBINATIONS) {
+      if (combo.test(cleaned)) {
+        const confidence = this.computeConfidence(cleaned, "complex", 0.55, 0.15);
+        return {
+          pattern: "complex",
+          confidence,
+          triggers: this.extractTriggers(cleaned, "complex"),
+          suggestions: confidence < 0.7 ? ["Consider splitting this complex requirement into simpler EARS patterns"] : []
+        };
+      }
+    }
+    let bestResult;
+    for (const rule of PATTERN_RULES) {
+      if (rule.regex.test(cleaned)) {
+        const confidence = this.computeConfidence(cleaned, rule.pattern, rule.baseConfidence, rule.bonus);
+        const patternTriggers = this.extractTriggers(cleaned, rule.pattern);
+        const patternSuggestions = [];
+        if (confidence < 0.7) {
+          patternSuggestions.push(this.getSuggestion(rule.pattern));
+        }
+        const result = {
+          pattern: rule.pattern,
+          confidence,
+          triggers: patternTriggers,
+          suggestions: patternSuggestions
+        };
+        if (confidence >= 0.85) {
+          return result;
+        }
+        if (!bestResult || confidence > bestResult.confidence) {
+          bestResult = result;
+        }
+        return result;
+      }
+    }
+    return {
+      pattern: "ubiquitous",
+      confidence: 0.3,
+      triggers: [],
+      suggestions: [
+        'Requirement does not match any EARS pattern. Use "THE <system> SHALL <action>" as minimum.'
+      ]
+    };
+  }
+  validate(requirement) {
+    const result = this.analyze(requirement);
+    const issues = [];
+    if (result.confidence < 0.5) {
+      issues.push(`Low confidence (${result.confidence.toFixed(2)}): does not clearly match EARS pattern`);
+    }
+    if (!/\bSHALL\b/i.test(requirement)) {
+      issues.push('Missing mandatory keyword "SHALL"');
+    }
+    return {
+      valid: issues.length === 0,
+      issues
+    };
+  }
+  cleanText(text, format) {
+    let cleaned = text.trim();
+    if (format === "markdown-blockquote") {
+      cleaned = cleaned.replace(/^>\s*/gm, "");
+    }
+    return cleaned;
+  }
+  computeConfidence(text, _pattern, base, bonus) {
+    let confidence = base + bonus;
+    if (/\bTHE\s+\S+\s+SHALL\b/i.test(text)) {
+      confidence += 0.1;
+    }
+    if (text.endsWith(".") || text.endsWith("\u3002")) {
+      confidence += 0.05;
+    }
+    if (text.split(/\s+/).length < 5) {
+      confidence -= 0.15;
+    }
+    return Math.min(1, Math.max(0, confidence));
+  }
+  extractTriggers(text, pattern) {
+    const triggers = [];
+    switch (pattern) {
+      case "event-driven": {
+        const match = text.match(/\bWHEN\s+(.+?),?\s*(THE\b|$)/i);
+        if (match) {
+          triggers.push(match[1].trim());
+        }
+        break;
+      }
+      case "state-driven": {
+        const match = text.match(/\bWHILE\s+(.+?),?\s*(THE\b|$)/i);
+        if (match) {
+          triggers.push(match[1].trim());
+        }
+        break;
+      }
+      case "optional": {
+        const match = text.match(/\bWHERE\s+(.+?),?\s*(THE\b|$)/i);
+        if (match) {
+          triggers.push(match[1].trim());
+        }
+        break;
+      }
+      case "complex": {
+        const ifMatch = text.match(/\bIF\s+(.+?),?\s*THEN\b/i);
+        if (ifMatch) {
+          triggers.push(ifMatch[1].trim());
+        }
+        break;
+      }
+    }
+    return triggers;
+  }
+  getSuggestion(pattern) {
+    const suggestions = {
+      ubiquitous: 'Use "THE <system> SHALL <action>" format',
+      "event-driven": 'Use "WHEN <event>, THE <system> SHALL <action>" format',
+      "state-driven": 'Use "WHILE <state>, THE <system> SHALL <action>" format',
+      unwanted: 'Use "THE <system> SHALL NOT <action>" format',
+      optional: 'Use "WHERE <condition>, THE <system> SHALL <action>" format',
+      complex: 'Use "IF <condition>, THEN THE <system> SHALL <action>" format'
+    };
+    return suggestions[pattern];
+  }
+};
+function createEARSValidator() {
+  return new EARSValidator();
+}
+var REQ_HEADING_REGEX = /^#{1,4}\s+(REQ-[A-Z]{3}-\d{3}):\s*(.+)$/;
+var FIELD_REGEX = {
+  type: /^\*\*種別\*\*:\s*(.+)$/m,
+  priority: /^\*\*優先度\*\*:\s*(P[012])$/m,
+  requirement: /^\*\*要件\*\*:\s*\n([\s\S]+?)(?=\n\*\*|$)/m,
+  acceptanceCriteria: /^\*\*受入基準\*\*:\s*\n((?:[-*]\s+\[[ x]\].+\n?)+)/m,
+  traceability: /^\*\*トレーサビリティ\*\*:\s*(.+)$/m,
+  package: /^\*\*パッケージ\*\*:\s*`(.+)`$/m
+};
+var MarkdownEARSParser = class {
+  validator;
+  constructor(validator) {
+    this.validator = validator ?? new EARSValidator();
+  }
+  parse(markdown) {
+    const requirements = [];
+    const lines = markdown.split("\n");
+    let currentReq = null;
+    let currentBlock = "";
+    let blockStartLine = 0;
+    let inCodeBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.startsWith("```")) {
+        inCodeBlock = !inCodeBlock;
+        if (inCodeBlock) {
+          continue;
+        }
+      }
+      if (inCodeBlock) {
+        continue;
+      }
+      const headingMatch = line.match(REQ_HEADING_REGEX);
+      if (headingMatch) {
+        if (currentReq && currentReq.id) {
+          const parsed = this.parseBlock(currentReq, currentBlock, blockStartLine);
+          requirements.push(parsed);
+        }
+        currentReq = {
+          id: headingMatch[1],
+          title: headingMatch[2].trim(),
+          line: i + 1
+        };
+        currentBlock = "";
+        blockStartLine = i + 1;
+      } else if (currentReq) {
+        currentBlock += line + "\n";
+      }
+    }
+    if (currentReq && currentReq.id) {
+      const parsed = this.parseBlock(currentReq, currentBlock, blockStartLine);
+      requirements.push(parsed);
+    }
+    return requirements;
+  }
+  parseBlock(partial, block, _startLine) {
+    const typeMatch = block.match(FIELD_REGEX.type);
+    const priorityMatch = block.match(FIELD_REGEX.priority);
+    const reqMatch = block.match(FIELD_REGEX.requirement);
+    const acMatch = block.match(FIELD_REGEX.acceptanceCriteria);
+    const traceMatch = block.match(FIELD_REGEX.traceability);
+    const pkgMatch = block.match(FIELD_REGEX.package);
+    const reqText = reqMatch ? reqMatch[1].trim() : "";
+    let pattern;
+    let confidence;
+    if (reqText) {
+      const analysis = this.validator.analyze(reqText);
+      pattern = analysis.pattern;
+      confidence = analysis.confidence;
+    }
+    let acceptanceCriteria;
+    if (acMatch) {
+      acceptanceCriteria = acMatch[1].split("\n").filter((l) => l.match(/^[-*]\s+\[[ x]\]/)).map((l) => l.replace(/^[-*]\s+\[[ x]\]\s*/, "").trim());
+    }
+    return {
+      id: partial.id,
+      title: partial.title ?? "",
+      text: reqText,
+      pattern: typeMatch ? this.normalizePattern(typeMatch[1]) : pattern,
+      confidence,
+      priority: priorityMatch ? priorityMatch[1] : void 0,
+      acceptanceCriteria,
+      traceability: traceMatch ? traceMatch[1].trim() : void 0,
+      package: pkgMatch ? pkgMatch[1] : void 0,
+      line: partial.line
+    };
+  }
+  normalizePattern(raw) {
+    const mapping = {
+      UBIQUITOUS: "ubiquitous",
+      "EVENT-DRIVEN": "event-driven",
+      EVENT_DRIVEN: "event-driven",
+      "STATE-DRIVEN": "state-driven",
+      STATE_DRIVEN: "state-driven",
+      UNWANTED: "unwanted",
+      OPTIONAL: "optional",
+      COMPLEX: "complex"
+    };
+    return mapping[raw.toUpperCase()] ?? "ubiquitous";
+  }
+};
+var RequirementsValidator = class {
+  parser;
+  earsValidator;
+  constructor(parser, validator) {
+    this.earsValidator = validator ?? new EARSValidator();
+    this.parser = parser ?? new MarkdownEARSParser(this.earsValidator);
+  }
+  validate(markdown) {
+    const requirements = this.parser.parse(markdown);
+    const issues = [];
+    for (const req of requirements) {
+      if (!req.text) {
+        issues.push({
+          requirementId: req.id,
+          line: req.line ?? 0,
+          column: 0,
+          message: "Requirement text is empty"
+        });
+        continue;
+      }
+      const validation = this.earsValidator.validate(req.text);
+      if (!validation.valid) {
+        for (const issue of validation.issues) {
+          issues.push({
+            requirementId: req.id,
+            line: req.line ?? 0,
+            column: 0,
+            message: issue,
+            suggestion: issue
+          });
+        }
+      }
+      if (!req.acceptanceCriteria || req.acceptanceCriteria.length === 0) {
+        issues.push({
+          requirementId: req.id,
+          line: req.line ?? 0,
+          column: 0,
+          message: "Missing acceptance criteria",
+          suggestion: "Add acceptance criteria in checklist format"
+        });
+      }
+    }
+    return { requirements, issues };
+  }
+  map(requirements) {
+    const map = /* @__PURE__ */ new Map();
+    for (const req of requirements) {
+      map.set(req.id, req);
+    }
+    return map;
+  }
+  search(query, requirements) {
+    const lower = query.toLowerCase();
+    return requirements.filter((req) => {
+      return req.id.toLowerCase().includes(lower) || req.title.toLowerCase().includes(lower) || req.text.toLowerCase().includes(lower);
+    });
+  }
+};
+function createMarkdownEARSParser() {
+  return new MarkdownEARSParser();
+}
+function createRequirementsValidator() {
+  return new RequirementsValidator();
+}
+var DefaultReplFormatter = class {
+  formatResult(value) {
+    if (value === void 0 || value === null) {
+      return "";
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value, null, 2);
+  }
+  formatError(error) {
+    return `\u274C ${error.message}`;
+  }
+  formatHelp(commands) {
+    const lines = ["Available commands:", ""];
+    for (const cmd of commands) {
+      const aliases = cmd.aliases?.length ? ` (${cmd.aliases.join(", ")})` : "";
+      lines.push(`  ${cmd.name}${aliases} \u2014 ${cmd.description}`);
+    }
+    return lines.join("\n");
+  }
+};
+var ReplEngine = class {
+  commands = /* @__PURE__ */ new Map();
+  session;
+  formatter;
+  prompt;
+  maxHistory;
+  running = false;
+  constructor(options) {
+    this.prompt = options?.prompt ?? "musubix> ";
+    this.maxHistory = options?.maxHistory ?? 1e3;
+    this.formatter = new DefaultReplFormatter();
+    this.session = {
+      id: `repl-${Date.now()}`,
+      history: [],
+      variables: /* @__PURE__ */ new Map(),
+      startedAt: /* @__PURE__ */ new Date()
+    };
+    this.registerBuiltIns();
+    if (options?.commands) {
+      for (const cmd of options.commands) {
+        this.register(cmd);
+      }
+    }
+  }
+  register(command) {
+    this.commands.set(command.name, command);
+    if (command.aliases) {
+      for (const alias of command.aliases) {
+        this.commands.set(alias, command);
+      }
+    }
+  }
+  async eval(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      return "";
+    }
+    this.session.history.push(trimmed);
+    if (this.session.history.length > this.maxHistory) {
+      this.session.history.shift();
+    }
+    const [commandName, ...args] = trimmed.split(/\s+/);
+    const command = this.commands.get(commandName);
+    if (!command) {
+      return this.formatter.formatError(new Error(`Unknown command: ${commandName}. Type "help" for available commands.`));
+    }
+    try {
+      const result = await command.execute(args, this.session);
+      return this.formatter.formatResult(result);
+    } catch (error) {
+      return this.formatter.formatError(error);
+    }
+  }
+  complete(partial) {
+    if (!partial) {
+      return [.../* @__PURE__ */ new Set([...this.commands.keys()])];
+    }
+    const [commandPart, ...rest] = partial.split(/\s+/);
+    if (rest.length === 0) {
+      const names = [.../* @__PURE__ */ new Set([...this.commands.keys()])];
+      return names.filter((n) => n.startsWith(commandPart));
+    }
+    const command = this.commands.get(commandPart);
+    if (command?.complete) {
+      return command.complete(rest.join(" "));
+    }
+    return [];
+  }
+  getSession() {
+    return this.session;
+  }
+  getHistory() {
+    return [...this.session.history];
+  }
+  getPrompt() {
+    return this.prompt;
+  }
+  isRunning() {
+    return this.running;
+  }
+  stop() {
+    this.running = false;
+  }
+  registerBuiltIns() {
+    this.register({
+      name: "help",
+      description: "Show available commands",
+      aliases: ["?"],
+      execute: async () => {
+        const uniqueCommands = [
+          ...new Map([...this.commands.entries()].map(([_, cmd]) => [cmd.name, cmd])).values()
+        ];
+        return this.formatter.formatHelp(uniqueCommands);
+      }
+    });
+    this.register({
+      name: "history",
+      description: "Show command history",
+      execute: async () => {
+        return this.session.history.map((h, i) => `  ${i + 1}  ${h}`).join("\n");
+      }
+    });
+    this.register({
+      name: "clear",
+      description: "Clear history",
+      execute: async () => {
+        this.session.history = [];
+        return "History cleared";
+      }
+    });
+    this.register({
+      name: "exit",
+      description: "Exit REPL",
+      aliases: ["quit", "q"],
+      execute: async () => {
+        this.running = false;
+        return "Goodbye";
+      }
+    });
+  }
+};
+var ReasoningChainRecorder = class {
+  chains = /* @__PURE__ */ new Map();
+  activeChainId = null;
+  stepCounter = 0;
+  startChain(title) {
+    const id = `chain-${Date.now()}-${++this.stepCounter}`;
+    this.chains.set(id, {
+      id,
+      title,
+      steps: [],
+      conclusion: "",
+      overallConfidence: 0,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+    this.activeChainId = id;
+    return id;
+  }
+  addStep(description, evidence, confidence, metadata) {
+    if (!this.activeChainId) {
+      throw new Error("No active reasoning chain. Call startChain() first.");
+    }
+    const chain = this.chains.get(this.activeChainId);
+    const step = {
+      id: `step-${++this.stepCounter}`,
+      description,
+      evidence,
+      confidence: Math.max(0, Math.min(1, confidence)),
+      timestamp: /* @__PURE__ */ new Date(),
+      metadata
+    };
+    chain.steps.push(step);
+    this.updateConfidence(chain);
+    return step;
+  }
+  conclude(conclusion) {
+    if (!this.activeChainId) {
+      throw new Error("No active reasoning chain.");
+    }
+    const chain = this.chains.get(this.activeChainId);
+    chain.conclusion = conclusion;
+    this.activeChainId = null;
+    return chain;
+  }
+  getChain(id) {
+    return this.chains.get(id);
+  }
+  getAllChains() {
+    return [...this.chains.values()];
+  }
+  updateConfidence(chain) {
+    if (chain.steps.length === 0) {
+      chain.overallConfidence = 0;
+      return;
+    }
+    const sum = chain.steps.reduce((acc, s) => acc + s.confidence, 0);
+    chain.overallConfidence = sum / chain.steps.length;
+  }
+};
+var ExplanationGenerator = class {
+  generate(chain, options) {
+    const format = options?.format ?? "markdown";
+    const includeEvidence = options?.includeEvidence ?? true;
+    const includeConfidence = options?.includeConfidence ?? true;
+    switch (format) {
+      case "json":
+        return JSON.stringify(chain, null, 2);
+      case "text":
+        return this.generateText(chain, includeEvidence, includeConfidence);
+      case "markdown":
+      default:
+        return this.generateMarkdown(chain, includeEvidence, includeConfidence);
+    }
+  }
+  generateMarkdown(chain, includeEvidence, includeConfidence) {
+    const lines = [];
+    lines.push(`# ${chain.title}`);
+    lines.push("");
+    if (includeConfidence) {
+      lines.push(`**\u4FE1\u983C\u5EA6**: ${(chain.overallConfidence * 100).toFixed(1)}%`);
+      lines.push("");
+    }
+    lines.push("## \u63A8\u8AD6\u30B9\u30C6\u30C3\u30D7");
+    lines.push("");
+    for (let i = 0; i < chain.steps.length; i++) {
+      const step = chain.steps[i];
+      lines.push(`### ${i + 1}. ${step.description}`);
+      if (includeConfidence) {
+        lines.push(`\u4FE1\u983C\u5EA6: ${(step.confidence * 100).toFixed(1)}%`);
+      }
+      if (includeEvidence && step.evidence.length > 0) {
+        lines.push("");
+        lines.push("\u6839\u62E0:");
+        for (const e of step.evidence) {
+          lines.push(`- ${e}`);
+        }
+      }
+      lines.push("");
+    }
+    if (chain.conclusion) {
+      lines.push("## \u7D50\u8AD6");
+      lines.push("");
+      lines.push(chain.conclusion);
+    }
+    return lines.join("\n");
+  }
+  generateText(chain, includeEvidence, includeConfidence) {
+    const lines = [];
+    lines.push(chain.title);
+    lines.push("=".repeat(chain.title.length));
+    lines.push("");
+    for (let i = 0; i < chain.steps.length; i++) {
+      const step = chain.steps[i];
+      const conf = includeConfidence ? ` [${(step.confidence * 100).toFixed(0)}%]` : "";
+      lines.push(`${i + 1}. ${step.description}${conf}`);
+      if (includeEvidence && step.evidence.length > 0) {
+        for (const e of step.evidence) {
+          lines.push(`   \u2192 ${e}`);
+        }
+      }
+    }
+    if (chain.conclusion) {
+      lines.push("");
+      lines.push(`\u7D50\u8AD6: ${chain.conclusion}`);
+    }
+    return lines.join("\n");
+  }
+};
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -7,13 +1461,14 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-
-// ../core/dist/error/actionable-error.js
-var ActionableError, ErrorCodes, ErrorFormatter, CommonErrors;
+var ActionableError2;
+var ErrorCodes2;
+var ErrorFormatter2;
+var CommonErrors2;
 var init_actionable_error = __esm({
   "../core/dist/error/actionable-error.js"() {
     "use strict";
-    ActionableError = class _ActionableError extends Error {
+    ActionableError2 = class _ActionableError2 extends Error {
       code;
       severity;
       context;
@@ -26,37 +1481,37 @@ var init_actionable_error = __esm({
         this.context = options.context ?? {};
         this.suggestions = options.suggestions ?? [];
         if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _ActionableError);
+          Error.captureStackTrace(this, _ActionableError2);
         }
         if (options.cause) {
           this.cause = options.cause;
         }
       }
       static withSuggestion(message, code, suggestion) {
-        return new _ActionableError(message, {
+        return new _ActionableError2(message, {
           code,
           suggestions: [suggestion]
         });
       }
       static fromError(error, code, suggestions) {
-        return new _ActionableError(error.message, {
+        return new _ActionableError2(error.message, {
           code,
           cause: error,
           suggestions
         });
       }
       static isActionableError(error) {
-        return error instanceof _ActionableError;
+        return error instanceof _ActionableError2;
       }
       addSuggestion(suggestion) {
         this.suggestions.push(suggestion);
         return this;
       }
       toFormattedString() {
-        return ErrorFormatter.format(this);
+        return ErrorFormatter2.format(this);
       }
     };
-    ErrorCodes = {
+    ErrorCodes2 = {
       // Validation errors
       EARS_VALIDATION_FAILED: "EARS_VALIDATION_FAILED",
       TRACEABILITY_MISSING: "TRACEABILITY_MISSING",
@@ -79,16 +1534,16 @@ var init_actionable_error = __esm({
       PATTERN_NOT_FOUND: "PATTERN_NOT_FOUND",
       PATTERN_CONFLICT: "PATTERN_CONFLICT"
     };
-    ErrorFormatter = class _ErrorFormatter {
+    ErrorFormatter2 = class _ErrorFormatter2 {
       static useColors = true;
       static setColorOutput(enabled) {
-        _ErrorFormatter.useColors = enabled;
+        _ErrorFormatter2.useColors = enabled;
       }
       static format(error) {
         const lines = [];
-        const icon = _ErrorFormatter.getSeverityIcon(error.severity);
+        const icon = _ErrorFormatter2.getSeverityIcon(error.severity);
         const header = `${icon} [${error.code}] ${error.message}`;
-        lines.push(_ErrorFormatter.colorize(header, error.severity));
+        lines.push(_ErrorFormatter2.colorize(header, error.severity));
         if (error.context.file) {
           let location = `   \u{1F4CD} ${error.context.file}`;
           if (error.context.line !== void 0) {
@@ -119,7 +1574,7 @@ var init_actionable_error = __esm({
       }
       static formatAll(errors) {
         if (errors.length === 0) {
-          return _ErrorFormatter.colorize("\u2705 No errors", "info");
+          return _ErrorFormatter2.colorize("\u2705 No errors", "info");
         }
         const lines = [];
         const counts = {
@@ -130,7 +1585,7 @@ var init_actionable_error = __esm({
         lines.push(`Found ${errors.length} issue(s): ${counts.error} errors, ${counts.warning} warnings, ${counts.info} info
 `);
         for (const error of errors) {
-          lines.push(_ErrorFormatter.format(error));
+          lines.push(_ErrorFormatter2.format(error));
           lines.push("");
         }
         return lines.join("\n");
@@ -155,7 +1610,7 @@ var init_actionable_error = __esm({
         }
       }
       static colorize(text, severity) {
-        if (!_ErrorFormatter.useColors) {
+        if (!_ErrorFormatter2.useColors) {
           return text;
         }
         const colors = {
@@ -167,10 +1622,10 @@ var init_actionable_error = __esm({
         return `${colors[severity]}${text}${reset}`;
       }
     };
-    CommonErrors = {
+    CommonErrors2 = {
       fileNotFound(path) {
-        return new ActionableError(`File not found: ${path}`, {
-          code: ErrorCodes.FILE_NOT_FOUND,
+        return new ActionableError2(`File not found: ${path}`, {
+          code: ErrorCodes2.FILE_NOT_FOUND,
           context: { file: path },
           suggestions: [
             {
@@ -186,8 +1641,8 @@ var init_actionable_error = __esm({
         });
       },
       earsValidationFailed(file, issues) {
-        return new ActionableError(`EARS validation failed with ${issues.length} issue(s)`, {
-          code: ErrorCodes.EARS_VALIDATION_FAILED,
+        return new ActionableError2(`EARS validation failed with ${issues.length} issue(s)`, {
+          code: ErrorCodes2.EARS_VALIDATION_FAILED,
           context: { file },
           suggestions: [
             {
@@ -203,8 +1658,8 @@ var init_actionable_error = __esm({
         });
       },
       traceabilityMissing(reqId, designId) {
-        return new ActionableError(`Missing traceability link: ${reqId} \u2192 ${designId}`, {
-          code: ErrorCodes.TRACEABILITY_MISSING,
+        return new ActionableError2(`Missing traceability link: ${reqId} \u2192 ${designId}`, {
+          code: ErrorCodes2.TRACEABILITY_MISSING,
           severity: "warning",
           context: { artifactId: reqId },
           suggestions: [
@@ -217,8 +1672,8 @@ var init_actionable_error = __esm({
         });
       },
       phaseTransitionBlocked(from, to, reason) {
-        return new ActionableError(`Cannot transition from ${from} to ${to}: ${reason}`, {
-          code: ErrorCodes.PHASE_TRANSITION_BLOCKED,
+        return new ActionableError2(`Cannot transition from ${from} to ${to}: ${reason}`, {
+          code: ErrorCodes2.PHASE_TRANSITION_BLOCKED,
           suggestions: [
             {
               action: "Complete requirements",
@@ -233,8 +1688,8 @@ var init_actionable_error = __esm({
         });
       },
       qualityGateFailed(gate, details) {
-        return new ActionableError(`Quality gate failed: ${gate}`, {
-          code: ErrorCodes.QUALITY_GATE_FAILED,
+        return new ActionableError2(`Quality gate failed: ${gate}`, {
+          code: ErrorCodes2.QUALITY_GATE_FAILED,
           suggestions: [
             {
               action: "Fix issues",
@@ -251,12 +1706,10 @@ var init_actionable_error = __esm({
     };
   }
 });
-
-// ../core/dist/error/graceful-degradation.js
-function createGracefulDegradation(config) {
-  return new GracefulDegradation(config);
+function createGracefulDegradation2(config) {
+  return new GracefulDegradation2(config);
 }
-async function retryWithBackoff(operation, options) {
+async function retryWithBackoff2(operation, options) {
   const maxAttempts = options?.maxAttempts ?? 3;
   const initialDelay = options?.initialDelay ?? 1e3;
   const maxDelay = options?.maxDelay ?? 3e4;
@@ -276,11 +1729,15 @@ async function retryWithBackoff(operation, options) {
   }
   throw lastError ?? new Error("Operation failed after retries");
 }
-var MemoryCacheProvider, MemoryQueueProvider, DEFAULT_DEGRADATION_CONFIG, GracefulDegradation, CircuitBreaker;
+var MemoryCacheProvider2;
+var MemoryQueueProvider2;
+var DEFAULT_DEGRADATION_CONFIG2;
+var GracefulDegradation2;
+var CircuitBreaker2;
 var init_graceful_degradation = __esm({
   "../core/dist/error/graceful-degradation.js"() {
     "use strict";
-    MemoryCacheProvider = class {
+    MemoryCacheProvider2 = class {
       cache = /* @__PURE__ */ new Map();
       async get(key) {
         const entry = this.cache.get(key);
@@ -306,7 +1763,7 @@ var init_graceful_degradation = __esm({
         this.cache.clear();
       }
     };
-    MemoryQueueProvider = class {
+    MemoryQueueProvider2 = class {
       queue = [];
       counter = 0;
       async enqueue(item) {
@@ -325,13 +1782,13 @@ var init_graceful_degradation = __esm({
         this.queue = [];
       }
     };
-    DEFAULT_DEGRADATION_CONFIG = {
+    DEFAULT_DEGRADATION_CONFIG2 = {
       services: [],
       healthCheckInterval: 3e4,
       autoRecovery: true,
       maxQueueSize: 1e3
     };
-    GracefulDegradation = class {
+    GracefulDegradation2 = class {
       config;
       serviceStatus;
       currentLevel = "full";
@@ -341,10 +1798,10 @@ var init_graceful_degradation = __esm({
       cache;
       queue;
       constructor(config) {
-        this.config = { ...DEFAULT_DEGRADATION_CONFIG, ...config };
+        this.config = { ...DEFAULT_DEGRADATION_CONFIG2, ...config };
         this.serviceStatus = /* @__PURE__ */ new Map();
-        this.cache = config?.cacheProvider ?? new MemoryCacheProvider();
-        this.queue = config?.queueProvider ?? new MemoryQueueProvider();
+        this.cache = config?.cacheProvider ?? new MemoryCacheProvider2();
+        this.queue = config?.queueProvider ?? new MemoryQueueProvider2();
         for (const service of this.config.services) {
           this.serviceStatus.set(service.name, {
             service: service.name,
@@ -580,7 +2037,7 @@ var init_graceful_degradation = __esm({
         });
       }
     };
-    CircuitBreaker = class {
+    CircuitBreaker2 = class {
       threshold;
       resetTimeout;
       failures = 0;
@@ -635,8 +2092,6 @@ var init_graceful_degradation = __esm({
     };
   }
 });
-
-// ../core/dist/error/index.js
 var init_error = __esm({
   "../core/dist/error/index.js"() {
     "use strict";
@@ -644,13 +2099,15 @@ var init_error = __esm({
     init_graceful_degradation();
   }
 });
-
-// ../core/dist/logging/index.js
-var ConsoleTransport, MemoryTransport, LOG_LEVEL_ORDER, Logger, AuditLogger;
+var ConsoleTransport2;
+var MemoryTransport2;
+var LOG_LEVEL_ORDER2;
+var Logger2;
+var AuditLogger2;
 var init_logging = __esm({
   "../core/dist/logging/index.js"() {
     "use strict";
-    ConsoleTransport = class {
+    ConsoleTransport2 = class {
       write(entry) {
         const prefix = `[${entry.timestamp.toISOString()}] [${entry.level.toUpperCase()}]`;
         const src = entry.source ? ` (${entry.source})` : "";
@@ -670,7 +2127,7 @@ var init_logging = __esm({
         }
       }
     };
-    MemoryTransport = class {
+    MemoryTransport2 = class {
       entries = [];
       write(entry) {
         this.entries.push(entry);
@@ -679,18 +2136,18 @@ var init_logging = __esm({
         this.entries.length = 0;
       }
     };
-    LOG_LEVEL_ORDER = {
+    LOG_LEVEL_ORDER2 = {
       debug: 0,
       info: 1,
       warn: 2,
       error: 3
     };
-    Logger = class _Logger {
+    Logger2 = class _Logger2 {
       transports;
       minLevel;
       source;
       constructor(options) {
-        this.transports = options?.transports ?? [new ConsoleTransport()];
+        this.transports = options?.transports ?? [new ConsoleTransport2()];
         this.minLevel = options?.level ?? "info";
         this.source = options?.source;
       }
@@ -707,14 +2164,14 @@ var init_logging = __esm({
         this.log("error", message, context);
       }
       child(source) {
-        return new _Logger({
+        return new _Logger2({
           transports: this.transports,
           level: this.minLevel,
           source: this.source ? `${this.source}:${source}` : source
         });
       }
       log(level, message, context) {
-        if (LOG_LEVEL_ORDER[level] < LOG_LEVEL_ORDER[this.minLevel]) {
+        if (LOG_LEVEL_ORDER2[level] < LOG_LEVEL_ORDER2[this.minLevel]) {
           return;
         }
         const entry = {
@@ -729,11 +2186,11 @@ var init_logging = __esm({
         }
       }
     };
-    AuditLogger = class {
+    AuditLogger2 = class {
       events = [];
       logger;
       constructor(logger) {
-        this.logger = logger ?? new Logger({ source: "audit" });
+        this.logger = logger ?? new Logger2({ source: "audit" });
       }
       record(event) {
         const full = { ...event, timestamp: /* @__PURE__ */ new Date() };
@@ -757,16 +2214,14 @@ var init_logging = __esm({
     };
   }
 });
-
-// ../core/dist/config/index.js
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-var DEFAULT_CONFIG, CONFIG_FILENAME, ConfigLoader;
+var DEFAULT_CONFIG2;
+var CONFIG_FILENAME2;
+var ConfigLoader2;
 var init_config = __esm({
   "../core/dist/config/index.js"() {
     "use strict";
     init_error();
-    DEFAULT_CONFIG = {
+    DEFAULT_CONFIG2 = {
       steeringDir: "steering",
       storageDir: "storage",
       llm: {
@@ -780,24 +2235,24 @@ var init_config = __esm({
         confidenceThreshold: 0.85
       }
     };
-    CONFIG_FILENAME = "musubix.config.json";
-    ConfigLoader = class {
+    CONFIG_FILENAME2 = "musubix.config.json";
+    ConfigLoader2 = class {
       config = null;
       basePath;
       constructor(basePath) {
         this.basePath = basePath ?? process.cwd();
       }
       async load() {
-        const configPath = join(this.basePath, CONFIG_FILENAME);
+        const configPath = join2(this.basePath, CONFIG_FILENAME2);
         try {
-          const raw = await readFile(configPath, "utf-8");
+          const raw = await readFile2(configPath, "utf-8");
           const parsed = JSON.parse(raw);
           this.config = this.merge(parsed);
           return this.config;
         } catch (error) {
           if (error.code === "ENOENT") {
-            throw new ActionableError(`Configuration file not found: ${configPath}`, {
-              code: ErrorCodes.CONFIG_MISSING,
+            throw new ActionableError2(`Configuration file not found: ${configPath}`, {
+              code: ErrorCodes2.CONFIG_MISSING,
               context: { file: configPath },
               suggestions: [
                 {
@@ -808,8 +2263,8 @@ var init_config = __esm({
               ]
             });
           }
-          throw new ActionableError(`Failed to parse configuration: ${error.message}`, {
-            code: ErrorCodes.CONFIG_INVALID,
+          throw new ActionableError2(`Failed to parse configuration: ${error.message}`, {
+            code: ErrorCodes2.CONFIG_INVALID,
             context: { file: configPath },
             cause: error,
             suggestions: [
@@ -823,24 +2278,24 @@ var init_config = __esm({
       }
       getConfig() {
         if (!this.config) {
-          return DEFAULT_CONFIG;
+          return DEFAULT_CONFIG2;
         }
         return this.config;
       }
       merge(partial) {
         return {
-          steeringDir: partial.steeringDir ?? DEFAULT_CONFIG.steeringDir,
-          storageDir: partial.storageDir ?? DEFAULT_CONFIG.storageDir,
+          steeringDir: partial.steeringDir ?? DEFAULT_CONFIG2.steeringDir,
+          storageDir: partial.storageDir ?? DEFAULT_CONFIG2.storageDir,
           llm: {
-            ...DEFAULT_CONFIG.llm,
+            ...DEFAULT_CONFIG2.llm,
             ...partial.llm
           },
           knowledge: {
-            ...DEFAULT_CONFIG.knowledge,
+            ...DEFAULT_CONFIG2.knowledge,
             ...partial.knowledge
           },
           integration: {
-            ...DEFAULT_CONFIG.integration,
+            ...DEFAULT_CONFIG2.integration,
             ...partial.integration
           }
         };
@@ -848,22 +2303,22 @@ var init_config = __esm({
     };
   }
 });
-
-// ../core/dist/infrastructure/repository.js
-function createInMemoryRepository() {
-  return new InMemoryRepository();
+function createInMemoryRepository2() {
+  return new InMemoryRepository2();
 }
-function createInMemorySearchableRepository() {
-  return new InMemorySearchableRepository();
+function createInMemorySearchableRepository2() {
+  return new InMemorySearchableRepository2();
 }
-function createInMemoryPaginatedRepository() {
-  return new InMemoryPaginatedRepository();
+function createInMemoryPaginatedRepository2() {
+  return new InMemoryPaginatedRepository2();
 }
-var InMemoryRepository, InMemorySearchableRepository, InMemoryPaginatedRepository;
+var InMemoryRepository2;
+var InMemorySearchableRepository2;
+var InMemoryPaginatedRepository2;
 var init_repository = __esm({
   "../core/dist/infrastructure/repository.js"() {
     "use strict";
-    InMemoryRepository = class {
+    InMemoryRepository2 = class {
       store = /* @__PURE__ */ new Map();
       async get(id) {
         return this.store.get(id);
@@ -881,7 +2336,7 @@ var init_repository = __esm({
         return this.store.has(id);
       }
     };
-    InMemorySearchableRepository = class extends InMemoryRepository {
+    InMemorySearchableRepository2 = class extends InMemoryRepository2 {
       async search(query) {
         const lower = query.toLowerCase();
         return [...this.store.values()].filter((entity) => {
@@ -894,7 +2349,7 @@ var init_repository = __esm({
         });
       }
     };
-    InMemoryPaginatedRepository = class extends InMemoryRepository {
+    InMemoryPaginatedRepository2 = class extends InMemoryRepository2 {
       async getPage(page, size) {
         const all = [...this.store.values()];
         const total = all.length;
@@ -909,21 +2364,19 @@ var init_repository = __esm({
     };
   }
 });
-
-// ../core/dist/interface/cli/index.js
-function formatSuccess(message) {
+function formatSuccess2(message) {
   return `\u2705 ${message}`;
 }
-function formatError(message) {
+function formatError2(message) {
   return `\u274C ${message}`;
 }
-function formatWarning(message) {
+function formatWarning2(message) {
   return `\u26A0\uFE0F  ${message}`;
 }
-function formatInfo(message) {
+function formatInfo2(message) {
   return `\u2139\uFE0F  ${message}`;
 }
-function formatTable(headers, rows) {
+function formatTable2(headers, rows) {
   const widths = headers.map((h, i) => {
     const maxRow = Math.max(...rows.map((r) => (r[i] ?? "").length));
     return Math.max(h.length, maxRow);
@@ -935,11 +2388,11 @@ function formatTable(headers, rows) {
 ${separator}
 ${body}`;
 }
-var ExitCode;
+var ExitCode2;
 var init_cli = __esm({
   "../core/dist/interface/cli/index.js"() {
     "use strict";
-    ExitCode = {
+    ExitCode2 = {
       SUCCESS: 0,
       GENERAL_ERROR: 1,
       VALIDATION_ERROR: 2,
@@ -948,9 +2401,7 @@ var init_cli = __esm({
     };
   }
 });
-
-// ../core/dist/validators/ears-validator.js
-function convertToEARS(naturalLanguage) {
+function convertToEARS2(naturalLanguage) {
   const text = naturalLanguage.trim();
   const whenMatch = text.match(/^when\s+(.+?),?\s+(the\s+\S+)\s+(shall|should|must)\s+(.+)$/i);
   if (whenMatch) {
@@ -987,14 +2438,16 @@ function convertToEARS(naturalLanguage) {
   }
   return `THE system SHALL ${text}`;
 }
-function createEARSValidator() {
-  return new EARSValidator();
+function createEARSValidator2() {
+  return new EARSValidator2();
 }
-var PATTERN_RULES, COMPLEX_COMBINATIONS, EARSValidator;
+var PATTERN_RULES2;
+var COMPLEX_COMBINATIONS2;
+var EARSValidator2;
 var init_ears_validator = __esm({
   "../core/dist/validators/ears-validator.js"() {
     "use strict";
-    PATTERN_RULES = [
+    PATTERN_RULES2 = [
       {
         pattern: "event-driven",
         regex: /\bWHEN\b.*\b(THE\s+.+\s+)?SHALL\b/i,
@@ -1032,15 +2485,15 @@ var init_ears_validator = __esm({
         bonus: 0
       }
     ];
-    COMPLEX_COMBINATIONS = [
+    COMPLEX_COMBINATIONS2 = [
       /\bWHEN\b.*\bWHILE\b/i,
       /\bWHILE\b.*\bWHEN\b/i,
       /\bIF\b.*\bWHEN\b/i
     ];
-    EARSValidator = class {
+    EARSValidator2 = class {
       analyze(text, options) {
         const cleaned = this.cleanText(text, options?.sourceFormat);
-        for (const combo of COMPLEX_COMBINATIONS) {
+        for (const combo of COMPLEX_COMBINATIONS2) {
           if (combo.test(cleaned)) {
             const confidence = this.computeConfidence(cleaned, "complex", 0.55, 0.15);
             return {
@@ -1052,7 +2505,7 @@ var init_ears_validator = __esm({
           }
         }
         let bestResult;
-        for (const rule of PATTERN_RULES) {
+        for (const rule of PATTERN_RULES2) {
           if (rule.regex.test(cleaned)) {
             const confidence = this.computeConfidence(cleaned, rule.pattern, rule.baseConfidence, rule.bonus);
             const patternTriggers = this.extractTriggers(cleaned, rule.pattern);
@@ -1166,21 +2619,22 @@ var init_ears_validator = __esm({
     };
   }
 });
-
-// ../core/dist/validators/markdown-ears-parser.js
-function createMarkdownEARSParser() {
-  return new MarkdownEARSParser();
+function createMarkdownEARSParser2() {
+  return new MarkdownEARSParser2();
 }
-function createRequirementsValidator() {
-  return new RequirementsValidator();
+function createRequirementsValidator2() {
+  return new RequirementsValidator2();
 }
-var REQ_HEADING_REGEX, FIELD_REGEX, MarkdownEARSParser, RequirementsValidator;
+var REQ_HEADING_REGEX2;
+var FIELD_REGEX2;
+var MarkdownEARSParser2;
+var RequirementsValidator2;
 var init_markdown_ears_parser = __esm({
   "../core/dist/validators/markdown-ears-parser.js"() {
     "use strict";
     init_ears_validator();
-    REQ_HEADING_REGEX = /^#{1,4}\s+(REQ-[A-Z]{3}-\d{3}):\s*(.+)$/;
-    FIELD_REGEX = {
+    REQ_HEADING_REGEX2 = /^#{1,4}\s+(REQ-[A-Z]{3}-\d{3}):\s*(.+)$/;
+    FIELD_REGEX2 = {
       type: /^\*\*種別\*\*:\s*(.+)$/m,
       priority: /^\*\*優先度\*\*:\s*(P[012])$/m,
       requirement: /^\*\*要件\*\*:\s*\n([\s\S]+?)(?=\n\*\*|$)/m,
@@ -1188,10 +2642,10 @@ var init_markdown_ears_parser = __esm({
       traceability: /^\*\*トレーサビリティ\*\*:\s*(.+)$/m,
       package: /^\*\*パッケージ\*\*:\s*`(.+)`$/m
     };
-    MarkdownEARSParser = class {
+    MarkdownEARSParser2 = class {
       validator;
       constructor(validator) {
-        this.validator = validator ?? new EARSValidator();
+        this.validator = validator ?? new EARSValidator2();
       }
       parse(markdown) {
         const requirements = [];
@@ -1211,7 +2665,7 @@ var init_markdown_ears_parser = __esm({
           if (inCodeBlock) {
             continue;
           }
-          const headingMatch = line.match(REQ_HEADING_REGEX);
+          const headingMatch = line.match(REQ_HEADING_REGEX2);
           if (headingMatch) {
             if (currentReq && currentReq.id) {
               const parsed = this.parseBlock(currentReq, currentBlock, blockStartLine);
@@ -1235,12 +2689,12 @@ var init_markdown_ears_parser = __esm({
         return requirements;
       }
       parseBlock(partial, block, _startLine) {
-        const typeMatch = block.match(FIELD_REGEX.type);
-        const priorityMatch = block.match(FIELD_REGEX.priority);
-        const reqMatch = block.match(FIELD_REGEX.requirement);
-        const acMatch = block.match(FIELD_REGEX.acceptanceCriteria);
-        const traceMatch = block.match(FIELD_REGEX.traceability);
-        const pkgMatch = block.match(FIELD_REGEX.package);
+        const typeMatch = block.match(FIELD_REGEX2.type);
+        const priorityMatch = block.match(FIELD_REGEX2.priority);
+        const reqMatch = block.match(FIELD_REGEX2.requirement);
+        const acMatch = block.match(FIELD_REGEX2.acceptanceCriteria);
+        const traceMatch = block.match(FIELD_REGEX2.traceability);
+        const pkgMatch = block.match(FIELD_REGEX2.package);
         const reqText = reqMatch ? reqMatch[1].trim() : "";
         let pattern;
         let confidence;
@@ -1280,12 +2734,12 @@ var init_markdown_ears_parser = __esm({
         return mapping[raw.toUpperCase()] ?? "ubiquitous";
       }
     };
-    RequirementsValidator = class {
+    RequirementsValidator2 = class {
       parser;
       earsValidator;
       constructor(parser, validator) {
-        this.earsValidator = validator ?? new EARSValidator();
-        this.parser = parser ?? new MarkdownEARSParser(this.earsValidator);
+        this.earsValidator = validator ?? new EARSValidator2();
+        this.parser = parser ?? new MarkdownEARSParser2(this.earsValidator);
       }
       validate(markdown) {
         const requirements = this.parser.parse(markdown);
@@ -1340,8 +2794,6 @@ var init_markdown_ears_parser = __esm({
     };
   }
 });
-
-// ../core/dist/validators/index.js
 var init_validators = __esm({
   "../core/dist/validators/index.js"() {
     "use strict";
@@ -1349,13 +2801,12 @@ var init_validators = __esm({
     init_markdown_ears_parser();
   }
 });
-
-// ../core/dist/repl/index.js
-var DefaultReplFormatter, ReplEngine;
+var DefaultReplFormatter2;
+var ReplEngine2;
 var init_repl = __esm({
   "../core/dist/repl/index.js"() {
     "use strict";
-    DefaultReplFormatter = class {
+    DefaultReplFormatter2 = class {
       formatResult(value) {
         if (value === void 0 || value === null) {
           return "";
@@ -1377,7 +2828,7 @@ var init_repl = __esm({
         return lines.join("\n");
       }
     };
-    ReplEngine = class {
+    ReplEngine2 = class {
       commands = /* @__PURE__ */ new Map();
       session;
       formatter;
@@ -1387,7 +2838,7 @@ var init_repl = __esm({
       constructor(options) {
         this.prompt = options?.prompt ?? "musubix> ";
         this.maxHistory = options?.maxHistory ?? 1e3;
-        this.formatter = new DefaultReplFormatter();
+        this.formatter = new DefaultReplFormatter2();
         this.session = {
           id: `repl-${Date.now()}`,
           history: [],
@@ -1500,13 +2951,12 @@ var init_repl = __esm({
     };
   }
 });
-
-// ../core/dist/explanation/index.js
-var ReasoningChainRecorder, ExplanationGenerator;
+var ReasoningChainRecorder2;
+var ExplanationGenerator2;
 var init_explanation = __esm({
   "../core/dist/explanation/index.js"() {
     "use strict";
-    ReasoningChainRecorder = class {
+    ReasoningChainRecorder2 = class {
       chains = /* @__PURE__ */ new Map();
       activeChainId = null;
       stepCounter = 0;
@@ -1564,7 +3014,7 @@ var init_explanation = __esm({
         chain.overallConfidence = sum / chain.steps.length;
       }
     };
-    ExplanationGenerator = class {
+    ExplanationGenerator2 = class {
       generate(chain, options) {
         const format = options?.format ?? "markdown";
         const includeEvidence = options?.includeEvidence ?? true;
@@ -1635,16 +3085,14 @@ var init_explanation = __esm({
     };
   }
 });
-
-// ../core/dist/validators/traceability-validator.js
-function createTraceabilityValidator() {
-  return new TraceabilityValidator();
+function createTraceabilityValidator2() {
+  return new TraceabilityValidator2();
 }
-var TraceabilityValidator;
+var TraceabilityValidator2;
 var init_traceability_validator = __esm({
   "../core/dist/validators/traceability-validator.js"() {
     "use strict";
-    TraceabilityValidator = class {
+    TraceabilityValidator2 = class {
       /**
        * Validate traceability coverage.
        * @param requirementIds - list of requirement IDs (e.g., ['REQ-001', 'REQ-002'])
@@ -1708,8 +3156,6 @@ var init_traceability_validator = __esm({
     };
   }
 });
-
-// ../core/dist/requirements/interviewer.js
 function buildQuestionBank() {
   return [
     {
@@ -1837,14 +3283,14 @@ function buildQuestionBank() {
     }
   ];
 }
-function createRequirementsInterviewer() {
-  return new RequirementsInterviewer();
+function createRequirementsInterviewer2() {
+  return new RequirementsInterviewer2();
 }
-var RequirementsInterviewer;
+var RequirementsInterviewer2;
 var init_interviewer = __esm({
   "../core/dist/requirements/interviewer.js"() {
     "use strict";
-    RequirementsInterviewer = class {
+    RequirementsInterviewer2 = class {
       state;
       questions;
       constructor() {
@@ -2144,16 +3590,14 @@ var init_interviewer = __esm({
     };
   }
 });
-
-// ../core/dist/requirements/generator.js
-function createRequirementsDocGenerator() {
-  return new RequirementsDocGenerator();
+function createRequirementsDocGenerator2() {
+  return new RequirementsDocGenerator2();
 }
-var RequirementsDocGenerator;
+var RequirementsDocGenerator2;
 var init_generator = __esm({
   "../core/dist/requirements/generator.js"() {
     "use strict";
-    RequirementsDocGenerator = class {
+    RequirementsDocGenerator2 = class {
       counter = 0;
       /**
        * Generate a complete requirements specification from gathered context
@@ -2390,15 +3834,15 @@ var init_generator = __esm({
     };
   }
 });
-
-// ../core/dist/requirements/index.js
-function createRequirementWizard() {
-  return new RequirementWizard();
+function createRequirementWizard2() {
+  return new RequirementWizard2();
 }
-function createAcceptanceCriteriaGenerator() {
-  return new AcceptanceCriteriaGenerator();
+function createAcceptanceCriteriaGenerator2() {
+  return new AcceptanceCriteriaGenerator2();
 }
-var WIZARD_STEPS, RequirementWizard, AcceptanceCriteriaGenerator;
+var WIZARD_STEPS;
+var RequirementWizard2;
+var AcceptanceCriteriaGenerator2;
 var init_requirements = __esm({
   "../core/dist/requirements/index.js"() {
     "use strict";
@@ -2438,7 +3882,7 @@ var init_requirements = __esm({
         transform: (input) => ({ action: input.trim() })
       }
     ];
-    RequirementWizard = class {
+    RequirementWizard2 = class {
       steps;
       counter = 0;
       constructor(steps) {
@@ -2506,7 +3950,7 @@ var init_requirements = __esm({
         ].join("\n");
       }
     };
-    AcceptanceCriteriaGenerator = class {
+    AcceptanceCriteriaGenerator2 = class {
       generate(requirementText, context) {
         const criteria = [];
         criteria.push(`- [ ] ${context.projectName}: \u8981\u4EF6\u3092\u6E80\u305F\u3059\u52D5\u4F5C\u304C\u5B9F\u88C5\u3055\u308C\u3066\u3044\u308B\u3053\u3068`);
@@ -2529,19 +3973,18 @@ var init_requirements = __esm({
     };
   }
 });
-
-// ../core/dist/design/index.js
-function createDesignGenerator() {
-  return new DesignGenerator();
+function createDesignGenerator2() {
+  return new DesignGenerator2();
 }
-function createSOLIDValidator() {
-  return new SOLIDValidator();
+function createSOLIDValidator2() {
+  return new SOLIDValidator2();
 }
-var DesignGenerator, SOLIDValidator;
+var DesignGenerator2;
+var SOLIDValidator2;
 var init_design = __esm({
   "../core/dist/design/index.js"() {
     "use strict";
-    DesignGenerator = class {
+    DesignGenerator2 = class {
       counter = 0;
       generate(requirements) {
         this.counter++;
@@ -2644,7 +4087,7 @@ var init_design = __esm({
         return [...patterns];
       }
     };
-    SOLIDValidator = class {
+    SOLIDValidator2 = class {
       validate(design) {
         const violations = [];
         const principleScores = {
@@ -2689,12 +4132,12 @@ var init_design = __esm({
     };
   }
 });
-
-// ../core/dist/project/index.js
-function createProjectInitializer() {
-  return new ProjectInitializer();
+function createProjectInitializer2() {
+  return new ProjectInitializer2();
 }
-var PROJECT_NAME_PATTERN, TEMPLATES, ProjectInitializer;
+var PROJECT_NAME_PATTERN;
+var TEMPLATES;
+var ProjectInitializer2;
 var init_project = __esm({
   "../core/dist/project/index.js"() {
     "use strict";
@@ -2723,7 +4166,7 @@ var init_project = __esm({
         "musubix.config.json"
       ]
     };
-    ProjectInitializer = class {
+    ProjectInitializer2 = class {
       init(options) {
         const errors = [];
         const nameCheck = this.validateProjectName(options.projectName);
@@ -2768,16 +4211,14 @@ var init_project = __esm({
     };
   }
 });
-
-// ../core/dist/design/c4-generator.js
-function createC4ModelGenerator() {
-  return new C4ModelGenerator();
+function createC4ModelGenerator2() {
+  return new C4ModelGenerator2();
 }
-var C4ModelGenerator;
+var C4ModelGenerator2;
 var init_c4_generator = __esm({
   "../core/dist/design/c4-generator.js"() {
     "use strict";
-    C4ModelGenerator = class {
+    C4ModelGenerator2 = class {
       elements = [];
       relationships = [];
       addElement(element) {
@@ -2880,16 +4321,15 @@ var init_c4_generator = __esm({
     };
   }
 });
-
-// ../core/dist/design/pattern-detector.js
-function createPatternDetector() {
-  return new PatternDetector();
+function createPatternDetector2() {
+  return new PatternDetector2();
 }
-var PATTERN_RULES2, PatternDetector;
+var PATTERN_RULES22;
+var PatternDetector2;
 var init_pattern_detector = __esm({
   "../core/dist/design/pattern-detector.js"() {
     "use strict";
-    PATTERN_RULES2 = [
+    PATTERN_RULES22 = [
       {
         pattern: "singleton",
         matchers: [
@@ -2963,10 +4403,10 @@ var init_pattern_detector = __esm({
         ]
       }
     ];
-    PatternDetector = class {
+    PatternDetector2 = class {
       detect(code) {
         const detections = [];
-        for (const rule of PATTERN_RULES2) {
+        for (const rule of PATTERN_RULES22) {
           let totalConfidence = 0;
           const evidence = [];
           let firstMatchLine = -1;
@@ -2995,21 +4435,19 @@ var init_pattern_detector = __esm({
         return detections.sort((a, b) => b.confidence - a.confidence);
       }
       getSupportedPatterns() {
-        return PATTERN_RULES2.map((r) => r.pattern);
+        return PATTERN_RULES22.map((r) => r.pattern);
       }
     };
   }
 });
-
-// ../core/dist/codegen/index.js
-function createCodeGenerator() {
-  return new CodeGenerator();
+function createCodeGenerator2() {
+  return new CodeGenerator2();
 }
-var CodeGenerator;
+var CodeGenerator2;
 var init_codegen = __esm({
   "../core/dist/codegen/index.js"() {
     "use strict";
-    CodeGenerator = class {
+    CodeGenerator2 = class {
       generate(options) {
         const code = this.renderTemplate(options);
         const filePath = this.resolveFilePath(options);
@@ -3273,21 +4711,22 @@ var init_codegen = __esm({
     };
   }
 });
-
-// ../core/dist/codegen/static-analyzer.js
-function createStaticAnalyzer() {
-  return new StaticAnalyzer();
+function createStaticAnalyzer2() {
+  return new StaticAnalyzer2();
 }
-function createQualityMetricsCalculator() {
-  return new QualityMetricsCalculator();
+function createQualityMetricsCalculator2() {
+  return new QualityMetricsCalculator2();
 }
-var COMPLEXITY_THRESHOLD, FUNCTION_LENGTH_THRESHOLD, StaticAnalyzer, QualityMetricsCalculator;
+var COMPLEXITY_THRESHOLD;
+var FUNCTION_LENGTH_THRESHOLD;
+var StaticAnalyzer2;
+var QualityMetricsCalculator2;
 var init_static_analyzer = __esm({
   "../core/dist/codegen/static-analyzer.js"() {
     "use strict";
     COMPLEXITY_THRESHOLD = 10;
     FUNCTION_LENGTH_THRESHOLD = 30;
-    StaticAnalyzer = class {
+    StaticAnalyzer2 = class {
       analyze(code) {
         const issues = [];
         const complexity = this.calculateComplexity(code);
@@ -3467,7 +4906,7 @@ var init_static_analyzer = __esm({
         return maxLen;
       }
     };
-    QualityMetricsCalculator = class {
+    QualityMetricsCalculator2 = class {
       calculate(analysisResults) {
         if (analysisResults.length === 0) {
           return { averageScore: 100, worstFile: "none", totalIssues: 0 };
@@ -3492,16 +4931,14 @@ var init_static_analyzer = __esm({
     };
   }
 });
-
-// ../core/dist/traceability/index.js
-function createTraceabilityManager() {
-  return new TraceabilityManager();
+function createTraceabilityManager2() {
+  return new TraceabilityManager2();
 }
-var TraceabilityManager;
+var TraceabilityManager2;
 var init_traceability = __esm({
   "../core/dist/traceability/index.js"() {
     "use strict";
-    TraceabilityManager = class {
+    TraceabilityManager2 = class {
       links = [];
       linkCounter = 0;
       addLink(sourceId, targetId, type) {
@@ -3566,22 +5003,24 @@ var init_traceability = __esm({
     };
   }
 });
-
-// ../core/dist/neurosymbolic/index.js
-function createSemanticCodeFilterPipeline() {
-  return new SemanticCodeFilterPipeline();
+function createSemanticCodeFilterPipeline2() {
+  return new SemanticCodeFilterPipeline2();
 }
-function createHallucinationDetector() {
-  return new HallucinationDetector();
+function createHallucinationDetector2() {
+  return new HallucinationDetector2();
 }
-function createRejectionGate(threshold) {
-  return new RejectionGate(threshold);
+function createRejectionGate2(threshold) {
+  return new RejectionGate2(threshold);
 }
-var SemanticCodeFilterPipeline, BUILTIN_TYPES, BUILTIN_FUNCTIONS, HallucinationDetector, RejectionGate;
+var SemanticCodeFilterPipeline2;
+var BUILTIN_TYPES;
+var BUILTIN_FUNCTIONS;
+var HallucinationDetector2;
+var RejectionGate2;
 var init_neurosymbolic = __esm({
   "../core/dist/neurosymbolic/index.js"() {
     "use strict";
-    SemanticCodeFilterPipeline = class {
+    SemanticCodeFilterPipeline2 = class {
       filters = [];
       addFilter(filter) {
         this.filters.push(filter);
@@ -3657,7 +5096,7 @@ var init_neurosymbolic = __esm({
       "finally",
       "new"
     ]);
-    HallucinationDetector = class {
+    HallucinationDetector2 = class {
       detect(generatedCode, context) {
         const issues = [];
         const knownTypes = new Set(context.existingTypes);
@@ -3695,7 +5134,7 @@ var init_neurosymbolic = __esm({
         };
       }
     };
-    RejectionGate = class {
+    RejectionGate2 = class {
       threshold;
       constructor(threshold = 0.7) {
         this.threshold = threshold;
@@ -3724,19 +5163,18 @@ var init_neurosymbolic = __esm({
     };
   }
 });
-
-// ../core/dist/learning/index.js
-function createPatternExtractor() {
-  return new PatternExtractor();
+function createPatternExtractor2() {
+  return new PatternExtractor2();
 }
-function createLearningEngine() {
-  return new LearningEngine();
+function createLearningEngine2() {
+  return new LearningEngine2();
 }
-var PatternExtractor, LearningEngine;
+var PatternExtractor2;
+var LearningEngine2;
 var init_learning = __esm({
   "../core/dist/learning/index.js"() {
     "use strict";
-    PatternExtractor = class {
+    PatternExtractor2 = class {
       extract(code) {
         const patterns = [];
         const now = /* @__PURE__ */ new Date();
@@ -3826,7 +5264,7 @@ var init_learning = __esm({
         return ["code-style", "architecture", "testing", "error-handling", "naming", "api-design"];
       }
     };
-    LearningEngine = class {
+    LearningEngine2 = class {
       patterns = /* @__PURE__ */ new Map();
       events = [];
       recordPattern(pattern) {
@@ -3864,16 +5302,14 @@ var init_learning = __esm({
     };
   }
 });
-
-// ../core/dist/codegen/scaffold-generator.js
-function createScaffoldGenerator() {
-  return new ScaffoldGenerator();
+function createScaffoldGenerator2() {
+  return new ScaffoldGenerator2();
 }
-var ScaffoldGenerator;
+var ScaffoldGenerator2;
 var init_scaffold_generator = __esm({
   "../core/dist/codegen/scaffold-generator.js"() {
     "use strict";
-    ScaffoldGenerator = class {
+    ScaffoldGenerator2 = class {
       generate(config) {
         const files = [];
         files.push(...this.generateMinimalFiles(config));
@@ -3970,21 +5406,22 @@ ${config.description}
     };
   }
 });
-
-// ../core/dist/codegen/test-generator.js
-function createUnitTestGenerator() {
-  return new UnitTestGenerator();
+function createUnitTestGenerator2() {
+  return new UnitTestGenerator2();
 }
-function createCoverageReporter() {
-  return new CoverageReporter();
+function createCoverageReporter2() {
+  return new CoverageReporter2();
 }
-var EXPORT_FUNCTION_RE, EXPORT_CLASS_RE, UnitTestGenerator, CoverageReporter;
+var EXPORT_FUNCTION_RE;
+var EXPORT_CLASS_RE;
+var UnitTestGenerator2;
+var CoverageReporter2;
 var init_test_generator = __esm({
   "../core/dist/codegen/test-generator.js"() {
     "use strict";
     EXPORT_FUNCTION_RE = /export\s+(?:async\s+)?function\s+(\w+)/g;
     EXPORT_CLASS_RE = /export\s+class\s+(\w+)/g;
-    UnitTestGenerator = class {
+    UnitTestGenerator2 = class {
       generate(sourceCode, style) {
         const functions = this.extractNames(sourceCode, EXPORT_FUNCTION_RE);
         const classes = this.extractNames(sourceCode, EXPORT_CLASS_RE);
@@ -4045,7 +5482,7 @@ var init_test_generator = __esm({
         return names;
       }
     };
-    CoverageReporter = class {
+    CoverageReporter2 = class {
       formatReport(covered, total, uncoveredLines) {
         const percent = total === 0 ? 100 : Math.round(covered / total * 100);
         const lines = [
@@ -4065,16 +5502,14 @@ var init_test_generator = __esm({
     };
   }
 });
-
-// ../core/dist/codegen/status-transition.js
-function createStatusTransitionGenerator() {
-  return new StatusTransitionGenerator();
+function createStatusTransitionGenerator2() {
+  return new StatusTransitionGenerator2();
 }
-var StatusTransitionGenerator;
+var StatusTransitionGenerator2;
 var init_status_transition = __esm({
   "../core/dist/codegen/status-transition.js"() {
     "use strict";
-    StatusTransitionGenerator = class {
+    StatusTransitionGenerator2 = class {
       generate(spec) {
         const statusNames = spec.statuses.map((s) => `'${s.name}'`).join(" | ");
         const transitionEntries = spec.transitions.map((t) => {
@@ -4171,16 +5606,14 @@ var init_status_transition = __esm({
     };
   }
 });
-
-// ../core/dist/traceability/matrix-generator.js
-function createMatrixGenerator() {
-  return new MatrixGenerator();
+function createMatrixGenerator2() {
+  return new MatrixGenerator2();
 }
-var MatrixGenerator;
+var MatrixGenerator2;
 var init_matrix_generator = __esm({
   "../core/dist/traceability/matrix-generator.js"() {
     "use strict";
-    MatrixGenerator = class {
+    MatrixGenerator2 = class {
       generate(sourceIds, targetIds, links) {
         const linkMap = /* @__PURE__ */ new Map();
         for (const link of links) {
@@ -4283,19 +5716,18 @@ var init_matrix_generator = __esm({
     };
   }
 });
-
-// ../core/dist/traceability/impact-analyzer.js
-function createImpactAnalyzer() {
-  return new ImpactAnalyzer();
+function createImpactAnalyzer2() {
+  return new ImpactAnalyzer2();
 }
-function createTraceSyncService() {
-  return new TraceSyncService();
+function createTraceSyncService2() {
+  return new TraceSyncService2();
 }
-var ImpactAnalyzer, TraceSyncService;
+var ImpactAnalyzer2;
+var TraceSyncService2;
 var init_impact_analyzer = __esm({
   "../core/dist/traceability/impact-analyzer.js"() {
     "use strict";
-    ImpactAnalyzer = class {
+    ImpactAnalyzer2 = class {
       analyze(changedId, links) {
         const affected = /* @__PURE__ */ new Set();
         const queue = [changedId];
@@ -4338,7 +5770,7 @@ var init_impact_analyzer = __esm({
         return "critical";
       }
     };
-    TraceSyncService = class {
+    TraceSyncService2 = class {
       checkSync(currentLinks, expectedSources, expectedTargets) {
         const linkedSources = new Set(currentLinks.map((l) => l.source));
         const linkedTargets = new Set(currentLinks.map((l) => l.target));
@@ -4369,12 +5801,13 @@ var init_impact_analyzer = __esm({
     };
   }
 });
-
-// ../core/dist/domain/index.js
-function createDomainDetector() {
-  return new DomainDetector();
+function createDomainDetector2() {
+  return new DomainDetector2();
 }
-var DOMAIN_KEYWORDS, FILE_EXTENSION_SIGNALS, FILENAME_SIGNALS, DomainDetector;
+var DOMAIN_KEYWORDS;
+var FILE_EXTENSION_SIGNALS;
+var FILENAME_SIGNALS;
+var DomainDetector2;
 var init_domain = __esm({
   "../core/dist/domain/index.js"() {
     "use strict";
@@ -4485,7 +5918,7 @@ var init_domain = __esm({
       terraform: ["devops", "cloud"],
       ".github": ["devops"]
     };
-    DomainDetector = class {
+    DomainDetector2 = class {
       detect(projectFiles, packageJson) {
         const scores = /* @__PURE__ */ new Map();
         const addScore = (domain, score, evidence) => {
@@ -4561,19 +5994,18 @@ var init_domain = __esm({
     };
   }
 });
-
-// ../core/dist/performance/index.js
-function createLazyLoader() {
-  return new LazyLoader();
+function createLazyLoader2() {
+  return new LazyLoader2();
 }
-function createMemoryMonitor() {
-  return new MemoryMonitor();
+function createMemoryMonitor2() {
+  return new MemoryMonitor2();
 }
-var LazyLoader, MemoryMonitor;
+var LazyLoader2;
+var MemoryMonitor2;
 var init_performance = __esm({
   "../core/dist/performance/index.js"() {
     "use strict";
-    LazyLoader = class {
+    LazyLoader2 = class {
       modules = /* @__PURE__ */ new Map();
       register(key, loader) {
         this.modules.set(key, { loader, loaded: false });
@@ -4609,7 +6041,7 @@ var init_performance = __esm({
         return { registered: keys.length, loaded, keys };
       }
     };
-    MemoryMonitor = class {
+    MemoryMonitor2 = class {
       getUsage() {
         const mem = process.memoryUsage();
         return {
@@ -4640,24 +6072,24 @@ var init_performance = __esm({
     };
   }
 });
-
-// ../core/dist/monitoring/file-watcher.js
-function createFileWatcher() {
-  return new FileWatcher();
+function createFileWatcher2() {
+  return new FileWatcher2();
 }
-function createTaskScheduler() {
-  return new TaskScheduler();
+function createTaskScheduler2() {
+  return new TaskScheduler2();
 }
-var DEFAULT_WATCHER_CONFIG, FileWatcher, TaskScheduler;
+var DEFAULT_WATCHER_CONFIG2;
+var FileWatcher2;
+var TaskScheduler2;
 var init_file_watcher = __esm({
   "../core/dist/monitoring/file-watcher.js"() {
     "use strict";
-    DEFAULT_WATCHER_CONFIG = {
+    DEFAULT_WATCHER_CONFIG2 = {
       patterns: ["**/*.ts"],
       ignorePatterns: ["node_modules", "dist", ".git"],
       debounceMs: 300
     };
-    FileWatcher = class {
+    FileWatcher2 = class {
       handlers = /* @__PURE__ */ new Map();
       on(eventType, handler) {
         const existing = this.handlers.get(eventType) ?? [];
@@ -4711,7 +6143,7 @@ var init_file_watcher = __esm({
         return path === pattern;
       }
     };
-    TaskScheduler = class {
+    TaskScheduler2 = class {
       tasks = /* @__PURE__ */ new Map();
       register(task) {
         this.tasks.set(task.id, task);
@@ -4735,12 +6167,11 @@ var init_file_watcher = __esm({
     };
   }
 });
-
-// ../core/dist/monitoring/quality-reporter.js
-function createQualityGateReporter() {
-  return new QualityGateReporter();
+function createQualityGateReporter2() {
+  return new QualityGateReporter2();
 }
-var STATUS_EMOJI, QualityGateReporter;
+var STATUS_EMOJI;
+var QualityGateReporter2;
 var init_quality_reporter = __esm({
   "../core/dist/monitoring/quality-reporter.js"() {
     "use strict";
@@ -4750,7 +6181,7 @@ var init_quality_reporter = __esm({
       skipped: "\u23ED\uFE0F",
       warning: "\u26A0\uFE0F"
     };
-    QualityGateReporter = class {
+    QualityGateReporter2 = class {
       entries = [];
       addEntry(entry) {
         this.entries.push(entry);
@@ -4822,16 +6253,14 @@ var init_quality_reporter = __esm({
     };
   }
 });
-
-// ../core/dist/learning/realtime-engine.js
-function createRealtimeLearningEngine(maxBufferSize) {
-  return new RealtimeLearningEngine(maxBufferSize);
+function createRealtimeLearningEngine2(maxBufferSize) {
+  return new RealtimeLearningEngine2(maxBufferSize);
 }
-var RealtimeLearningEngine;
+var RealtimeLearningEngine2;
 var init_realtime_engine = __esm({
   "../core/dist/learning/realtime-engine.js"() {
     "use strict";
-    RealtimeLearningEngine = class {
+    RealtimeLearningEngine2 = class {
       buffer = [];
       maxBufferSize;
       allPatterns = [];
@@ -4906,13 +6335,11 @@ var init_realtime_engine = __esm({
     };
   }
 });
-
-// ../core/dist/fixtures/virtual-projects.js
-var VIRTUAL_PROJECTS;
+var VIRTUAL_PROJECTS2;
 var init_virtual_projects = __esm({
   "../core/dist/fixtures/virtual-projects.js"() {
     "use strict";
-    VIRTUAL_PROJECTS = [
+    VIRTUAL_PROJECTS2 = [
       // 1. pet-clinic
       {
         id: "pet-clinic",
@@ -5308,118 +6735,116 @@ var init_virtual_projects = __esm({
     ];
   }
 });
-
-// ../core/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
-  AcceptanceCriteriaGenerator: () => AcceptanceCriteriaGenerator,
-  ActionableError: () => ActionableError,
-  AuditLogger: () => AuditLogger,
-  C4ModelGenerator: () => C4ModelGenerator,
-  CircuitBreaker: () => CircuitBreaker,
-  CodeGenerator: () => CodeGenerator,
-  CommonErrors: () => CommonErrors,
-  ConfigLoader: () => ConfigLoader,
-  ConsoleTransport: () => ConsoleTransport,
-  CoverageReporter: () => CoverageReporter,
-  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
-  DEFAULT_WATCHER_CONFIG: () => DEFAULT_WATCHER_CONFIG,
-  DefaultReplFormatter: () => DefaultReplFormatter,
-  DesignGenerator: () => DesignGenerator,
-  DomainDetector: () => DomainDetector,
-  EARSValidator: () => EARSValidator,
-  ErrorCodes: () => ErrorCodes,
-  ErrorFormatter: () => ErrorFormatter,
-  ExitCode: () => ExitCode,
-  ExplanationGenerator: () => ExplanationGenerator,
-  FileWatcher: () => FileWatcher,
-  GracefulDegradation: () => GracefulDegradation,
-  HallucinationDetector: () => HallucinationDetector,
-  ImpactAnalyzer: () => ImpactAnalyzer,
-  InMemoryPaginatedRepository: () => InMemoryPaginatedRepository,
-  InMemoryRepository: () => InMemoryRepository,
-  InMemorySearchableRepository: () => InMemorySearchableRepository,
-  LazyLoader: () => LazyLoader,
-  LearningEngine: () => LearningEngine,
-  Logger: () => Logger,
-  MarkdownEARSParser: () => MarkdownEARSParser,
-  MatrixGenerator: () => MatrixGenerator,
-  MemoryCacheProvider: () => MemoryCacheProvider,
-  MemoryMonitor: () => MemoryMonitor,
-  MemoryQueueProvider: () => MemoryQueueProvider,
-  MemoryTransport: () => MemoryTransport,
-  PatternDetector: () => PatternDetector,
-  PatternExtractor: () => PatternExtractor,
-  ProjectInitializer: () => ProjectInitializer,
-  QualityGateReporter: () => QualityGateReporter,
-  QualityMetricsCalculator: () => QualityMetricsCalculator,
-  RealtimeLearningEngine: () => RealtimeLearningEngine,
-  ReasoningChainRecorder: () => ReasoningChainRecorder,
-  RejectionGate: () => RejectionGate,
-  ReplEngine: () => ReplEngine,
-  RequirementWizard: () => RequirementWizard,
-  RequirementsDocGenerator: () => RequirementsDocGenerator,
-  RequirementsInterviewer: () => RequirementsInterviewer,
-  RequirementsValidator: () => RequirementsValidator,
-  SOLIDValidator: () => SOLIDValidator,
-  ScaffoldGenerator: () => ScaffoldGenerator,
-  SemanticCodeFilterPipeline: () => SemanticCodeFilterPipeline,
-  StaticAnalyzer: () => StaticAnalyzer,
-  StatusTransitionGenerator: () => StatusTransitionGenerator,
-  TaskScheduler: () => TaskScheduler,
-  TraceSyncService: () => TraceSyncService,
-  TraceabilityManager: () => TraceabilityManager,
-  TraceabilityValidator: () => TraceabilityValidator,
-  UnitTestGenerator: () => UnitTestGenerator,
+  AcceptanceCriteriaGenerator: () => AcceptanceCriteriaGenerator2,
+  ActionableError: () => ActionableError2,
+  AuditLogger: () => AuditLogger2,
+  C4ModelGenerator: () => C4ModelGenerator2,
+  CircuitBreaker: () => CircuitBreaker2,
+  CodeGenerator: () => CodeGenerator2,
+  CommonErrors: () => CommonErrors2,
+  ConfigLoader: () => ConfigLoader2,
+  ConsoleTransport: () => ConsoleTransport2,
+  CoverageReporter: () => CoverageReporter2,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG2,
+  DEFAULT_WATCHER_CONFIG: () => DEFAULT_WATCHER_CONFIG2,
+  DefaultReplFormatter: () => DefaultReplFormatter2,
+  DesignGenerator: () => DesignGenerator2,
+  DomainDetector: () => DomainDetector2,
+  EARSValidator: () => EARSValidator2,
+  ErrorCodes: () => ErrorCodes2,
+  ErrorFormatter: () => ErrorFormatter2,
+  ExitCode: () => ExitCode2,
+  ExplanationGenerator: () => ExplanationGenerator2,
+  FileWatcher: () => FileWatcher2,
+  GracefulDegradation: () => GracefulDegradation2,
+  HallucinationDetector: () => HallucinationDetector2,
+  ImpactAnalyzer: () => ImpactAnalyzer2,
+  InMemoryPaginatedRepository: () => InMemoryPaginatedRepository2,
+  InMemoryRepository: () => InMemoryRepository2,
+  InMemorySearchableRepository: () => InMemorySearchableRepository2,
+  LazyLoader: () => LazyLoader2,
+  LearningEngine: () => LearningEngine2,
+  Logger: () => Logger2,
+  MarkdownEARSParser: () => MarkdownEARSParser2,
+  MatrixGenerator: () => MatrixGenerator2,
+  MemoryCacheProvider: () => MemoryCacheProvider2,
+  MemoryMonitor: () => MemoryMonitor2,
+  MemoryQueueProvider: () => MemoryQueueProvider2,
+  MemoryTransport: () => MemoryTransport2,
+  PatternDetector: () => PatternDetector2,
+  PatternExtractor: () => PatternExtractor2,
+  ProjectInitializer: () => ProjectInitializer2,
+  QualityGateReporter: () => QualityGateReporter2,
+  QualityMetricsCalculator: () => QualityMetricsCalculator2,
+  RealtimeLearningEngine: () => RealtimeLearningEngine2,
+  ReasoningChainRecorder: () => ReasoningChainRecorder2,
+  RejectionGate: () => RejectionGate2,
+  ReplEngine: () => ReplEngine2,
+  RequirementWizard: () => RequirementWizard2,
+  RequirementsDocGenerator: () => RequirementsDocGenerator2,
+  RequirementsInterviewer: () => RequirementsInterviewer2,
+  RequirementsValidator: () => RequirementsValidator2,
+  SOLIDValidator: () => SOLIDValidator2,
+  ScaffoldGenerator: () => ScaffoldGenerator2,
+  SemanticCodeFilterPipeline: () => SemanticCodeFilterPipeline2,
+  StaticAnalyzer: () => StaticAnalyzer2,
+  StatusTransitionGenerator: () => StatusTransitionGenerator2,
+  TaskScheduler: () => TaskScheduler2,
+  TraceSyncService: () => TraceSyncService2,
+  TraceabilityManager: () => TraceabilityManager2,
+  TraceabilityValidator: () => TraceabilityValidator2,
+  UnitTestGenerator: () => UnitTestGenerator2,
   VERSION: () => VERSION,
-  VIRTUAL_PROJECTS: () => VIRTUAL_PROJECTS,
-  convertToEARS: () => convertToEARS,
-  createAcceptanceCriteriaGenerator: () => createAcceptanceCriteriaGenerator,
-  createC4ModelGenerator: () => createC4ModelGenerator,
-  createCodeGenerator: () => createCodeGenerator,
-  createCoverageReporter: () => createCoverageReporter,
-  createDesignGenerator: () => createDesignGenerator,
-  createDomainDetector: () => createDomainDetector,
-  createEARSValidator: () => createEARSValidator,
-  createFileWatcher: () => createFileWatcher,
-  createGracefulDegradation: () => createGracefulDegradation,
-  createHallucinationDetector: () => createHallucinationDetector,
-  createImpactAnalyzer: () => createImpactAnalyzer,
-  createInMemoryPaginatedRepository: () => createInMemoryPaginatedRepository,
-  createInMemoryRepository: () => createInMemoryRepository,
-  createInMemorySearchableRepository: () => createInMemorySearchableRepository,
-  createLazyLoader: () => createLazyLoader,
-  createLearningEngine: () => createLearningEngine,
-  createMarkdownEARSParser: () => createMarkdownEARSParser,
-  createMatrixGenerator: () => createMatrixGenerator,
-  createMemoryMonitor: () => createMemoryMonitor,
-  createPatternDetector: () => createPatternDetector,
-  createPatternExtractor: () => createPatternExtractor,
-  createProjectInitializer: () => createProjectInitializer,
-  createQualityGateReporter: () => createQualityGateReporter,
-  createQualityMetricsCalculator: () => createQualityMetricsCalculator,
-  createRealtimeLearningEngine: () => createRealtimeLearningEngine,
-  createRejectionGate: () => createRejectionGate,
-  createRequirementWizard: () => createRequirementWizard,
-  createRequirementsDocGenerator: () => createRequirementsDocGenerator,
-  createRequirementsInterviewer: () => createRequirementsInterviewer,
-  createRequirementsValidator: () => createRequirementsValidator,
-  createSOLIDValidator: () => createSOLIDValidator,
-  createScaffoldGenerator: () => createScaffoldGenerator,
-  createSemanticCodeFilterPipeline: () => createSemanticCodeFilterPipeline,
-  createStaticAnalyzer: () => createStaticAnalyzer,
-  createStatusTransitionGenerator: () => createStatusTransitionGenerator,
-  createTaskScheduler: () => createTaskScheduler,
-  createTraceSyncService: () => createTraceSyncService,
-  createTraceabilityManager: () => createTraceabilityManager,
-  createTraceabilityValidator: () => createTraceabilityValidator,
-  createUnitTestGenerator: () => createUnitTestGenerator,
-  formatError: () => formatError,
-  formatInfo: () => formatInfo,
-  formatSuccess: () => formatSuccess,
-  formatTable: () => formatTable,
-  formatWarning: () => formatWarning,
-  retryWithBackoff: () => retryWithBackoff
+  VIRTUAL_PROJECTS: () => VIRTUAL_PROJECTS2,
+  convertToEARS: () => convertToEARS2,
+  createAcceptanceCriteriaGenerator: () => createAcceptanceCriteriaGenerator2,
+  createC4ModelGenerator: () => createC4ModelGenerator2,
+  createCodeGenerator: () => createCodeGenerator2,
+  createCoverageReporter: () => createCoverageReporter2,
+  createDesignGenerator: () => createDesignGenerator2,
+  createDomainDetector: () => createDomainDetector2,
+  createEARSValidator: () => createEARSValidator2,
+  createFileWatcher: () => createFileWatcher2,
+  createGracefulDegradation: () => createGracefulDegradation2,
+  createHallucinationDetector: () => createHallucinationDetector2,
+  createImpactAnalyzer: () => createImpactAnalyzer2,
+  createInMemoryPaginatedRepository: () => createInMemoryPaginatedRepository2,
+  createInMemoryRepository: () => createInMemoryRepository2,
+  createInMemorySearchableRepository: () => createInMemorySearchableRepository2,
+  createLazyLoader: () => createLazyLoader2,
+  createLearningEngine: () => createLearningEngine2,
+  createMarkdownEARSParser: () => createMarkdownEARSParser2,
+  createMatrixGenerator: () => createMatrixGenerator2,
+  createMemoryMonitor: () => createMemoryMonitor2,
+  createPatternDetector: () => createPatternDetector2,
+  createPatternExtractor: () => createPatternExtractor2,
+  createProjectInitializer: () => createProjectInitializer2,
+  createQualityGateReporter: () => createQualityGateReporter2,
+  createQualityMetricsCalculator: () => createQualityMetricsCalculator2,
+  createRealtimeLearningEngine: () => createRealtimeLearningEngine2,
+  createRejectionGate: () => createRejectionGate2,
+  createRequirementWizard: () => createRequirementWizard2,
+  createRequirementsDocGenerator: () => createRequirementsDocGenerator2,
+  createRequirementsInterviewer: () => createRequirementsInterviewer2,
+  createRequirementsValidator: () => createRequirementsValidator2,
+  createSOLIDValidator: () => createSOLIDValidator2,
+  createScaffoldGenerator: () => createScaffoldGenerator2,
+  createSemanticCodeFilterPipeline: () => createSemanticCodeFilterPipeline2,
+  createStaticAnalyzer: () => createStaticAnalyzer2,
+  createStatusTransitionGenerator: () => createStatusTransitionGenerator2,
+  createTaskScheduler: () => createTaskScheduler2,
+  createTraceSyncService: () => createTraceSyncService2,
+  createTraceabilityManager: () => createTraceabilityManager2,
+  createTraceabilityValidator: () => createTraceabilityValidator2,
+  createUnitTestGenerator: () => createUnitTestGenerator2,
+  formatError: () => formatError2,
+  formatInfo: () => formatInfo2,
+  formatSuccess: () => formatSuccess2,
+  formatTable: () => formatTable2,
+  formatWarning: () => formatWarning2,
+  retryWithBackoff: () => retryWithBackoff2
 });
 var VERSION;
 var init_dist = __esm({
@@ -5459,8 +6884,6 @@ var init_dist = __esm({
     VERSION = "0.1.0";
   }
 });
-
-// ../skill-manager/dist/executor.js
 function createSkillExecutor(registry) {
   return new SkillExecutor(registry);
 }
@@ -5527,8 +6950,6 @@ var init_executor = __esm({
     };
   }
 });
-
-// ../skill-manager/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
   SkillExecutor: () => SkillExecutor,
@@ -5538,7 +6959,6 @@ __export(dist_exports2, {
   createSkillManager: () => createSkillManager,
   createSkillRegistry: () => createSkillRegistry
 });
-import { randomUUID } from "node:crypto";
 function createSkillRegistry() {
   return new SkillRegistry();
 }
@@ -5546,7 +6966,8 @@ function createSkillManager() {
   const registry = createSkillRegistry();
   return new SkillManager(registry);
 }
-var SkillRegistry, SkillManager;
+var SkillRegistry;
+var SkillManager;
 var init_dist2 = __esm({
   "../skill-manager/dist/index.js"() {
     "use strict";
@@ -5640,15 +7061,11 @@ var init_dist2 = __esm({
     };
   }
 });
-
-// ../knowledge/dist/index.js
 var dist_exports3 = {};
 __export(dist_exports3, {
   FileKnowledgeStore: () => FileKnowledgeStore,
   createKnowledgeStore: () => createKnowledgeStore
 });
-import { readFile as readFile2, writeFile, mkdir } from "node:fs/promises";
-import { join as join2, dirname } from "node:path";
 function createEmptyGraph() {
   return {
     version: "1.0.0",
@@ -5668,12 +7085,12 @@ var init_dist3 = __esm({
       graph;
       filePath;
       constructor(basePath) {
-        this.filePath = join2(basePath, "knowledge-graph.json");
+        this.filePath = join22(basePath, "knowledge-graph.json");
         this.graph = createEmptyGraph();
       }
       async load() {
         try {
-          const raw = await readFile2(this.filePath, "utf-8");
+          const raw = await readFile22(this.filePath, "utf-8");
           this.graph = JSON.parse(raw);
         } catch {
           this.graph = createEmptyGraph();
@@ -5864,20 +7281,17 @@ var init_dist3 = __esm({
     };
   }
 });
-
-// ../decisions/dist/index.js
 var dist_exports4 = {};
 __export(dist_exports4, {
   ADR_TEMPLATE: () => ADR_TEMPLATE,
   DecisionManager: () => DecisionManager,
   createDecisionManager: () => createDecisionManager
 });
-import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
-import { join as join3 } from "node:path";
 function createDecisionManager(basePath) {
   return new DecisionManager(basePath);
 }
-var ADR_TEMPLATE, DecisionManager;
+var ADR_TEMPLATE;
+var DecisionManager;
 var init_dist4 = __esm({
   "../decisions/dist/index.js"() {
     "use strict";
@@ -5995,8 +7409,6 @@ var init_dist4 = __esm({
     };
   }
 });
-
-// ../deep-research/dist/index.js
 var dist_exports5 = {};
 __export(dist_exports5, {
   BreadthFirstStrategy: () => BreadthFirstStrategy,
@@ -6059,7 +7471,12 @@ function createResearchEngine() {
   const securityFilter = createSecurityFilter();
   return new ResearchEngine(accumulator, securityFilter);
 }
-var DEFAULT_SECURITY_FILTER_CONFIG, DepthFirstStrategy, BreadthFirstStrategy, SecurityFilter, KnowledgeAccumulator, ResearchEngine;
+var DEFAULT_SECURITY_FILTER_CONFIG;
+var DepthFirstStrategy;
+var BreadthFirstStrategy;
+var SecurityFilter;
+var KnowledgeAccumulator;
+var ResearchEngine;
 var init_dist5 = __esm({
   "../deep-research/dist/index.js"() {
     "use strict";
@@ -6495,8 +7912,6 @@ var init_dist5 = __esm({
     };
   }
 });
-
-// ../library-learner/dist/index.js
 var dist_exports6 = {};
 __export(dist_exports6, {
   EGraphEngine: () => EGraphEngine,
@@ -6554,7 +7969,11 @@ function createEGraphEngine() {
 function createLibraryLearner() {
   return new LibraryLearner();
 }
-var EGraphEngine, FUNCTION_SIG_RE, ARROW_FN_RE, METHOD_RE, LibraryLearner;
+var EGraphEngine;
+var FUNCTION_SIG_RE;
+var ARROW_FN_RE;
+var METHOD_RE;
+var LibraryLearner;
 var init_dist6 = __esm({
   "../library-learner/dist/index.js"() {
     "use strict";
@@ -6719,8 +8138,6 @@ var init_dist6 = __esm({
     };
   }
 });
-
-// ../synthesis/dist/index.js
 var dist_exports7 = {};
 __export(dist_exports7, {
   DSLBuilder: () => DSLBuilder,
@@ -6739,7 +8156,12 @@ function createVersionSpaceManager() {
 function createSynthesisEngine() {
   return new SynthesisEngine();
 }
-var KEYWORDS, OPERATORS, DELIMITERS, DSLBuilder, VersionSpaceManager, SynthesisEngine;
+var KEYWORDS;
+var OPERATORS;
+var DELIMITERS;
+var DSLBuilder;
+var VersionSpaceManager;
+var SynthesisEngine;
 var init_dist7 = __esm({
   "../synthesis/dist/index.js"() {
     "use strict";
@@ -7571,16 +8993,8 @@ var init_dist7 = __esm({
     };
   }
 });
-
-// dist/index.js
-init_dist();
-init_dist();
-
-// dist/cli.js
 init_dist();
 init_dist();
-
-// ../policy/dist/index.js
 var CONSTITUTION_ARTICLES = [
   {
     article: 1,
@@ -7720,8 +9134,6 @@ var PolicyEngine = class {
     }
   }
 };
-
-// ../ontology-mcp/dist/index.js
 var N3Store = class {
   triples = [];
   addTriple(triple) {
@@ -7858,11 +9270,6 @@ function createOntologyStore() {
 function createConsistencyValidator() {
   return new ConsistencyValidator();
 }
-
-// ../codegraph/dist/index.js
-import ts from "typescript";
-
-// ../codegraph/dist/multi-lang-parser.js
 var BraceBlockTracker = class {
   depth = 0;
   blockStack = [];
@@ -9228,8 +10635,6 @@ var MultiLanguageParser = class {
     return { language, nodes, imports, exports: [], errors: [] };
   }
 };
-
-// ../codegraph/dist/index.js
 var ALL_LANGUAGES = [
   "typescript",
   "javascript",
@@ -9663,8 +11068,6 @@ function createASTParser(options) {
 function createGraphEngine() {
   return new GraphEngine();
 }
-
-// ../security/dist/index.js
 function getLineNumber(code, index) {
   return code.substring(0, index).split("\n").length;
 }
@@ -9855,8 +11258,6 @@ var DependencyScanner = class {
 function createSecretDetector() {
   return new SecretDetector();
 }
-
-// ../workflow-engine/dist/task-breakdown.js
 var TaskBreakdownManager = class {
   tasks = /* @__PURE__ */ new Map();
   addTask(task) {
@@ -9937,8 +11338,6 @@ var TaskBreakdownManager = class {
 function createTaskBreakdownManager() {
   return new TaskBreakdownManager();
 }
-
-// ../workflow-engine/dist/index.js
 var PHASE_ORDER = [
   "requirements",
   "design",
@@ -10212,11 +11611,8 @@ function createDefaultGates() {
     }
   ];
 }
-
-// dist/cli.js
 init_dist();
 init_dist();
-import { readFileSync, existsSync } from "node:fs";
 function parseArgs(argv) {
   const command = argv[0] ?? "";
   let subcommand;
@@ -10429,17 +11825,17 @@ var CLIDispatcher = class {
     if (argv.length === 0 || argv.includes("--help") && !argv[0]?.match(/^[a-z]/) || argv.includes("-h") && !argv[0]?.match(/^[a-z]/)) {
       if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
         console.log(showHelp());
-        return ExitCode.SUCCESS;
+        return ExitCode2.SUCCESS;
       }
     }
     const parsed = parseArgs(argv);
     if (parsed.flags["help"] === true || parsed.flags["h"] === true) {
       console.log(showHelp(parsed.command));
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     if (!parsed.command) {
       console.log(showHelp());
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     try {
       await this.dispatch(parsed.command, {
@@ -10447,11 +11843,11 @@ var CLIDispatcher = class {
         args: parsed.args,
         ...parsed.flags
       });
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       console.error(message);
-      return ExitCode.GENERAL_ERROR;
+      return ExitCode2.GENERAL_ERROR;
     }
   }
 };
@@ -10486,33 +11882,33 @@ async function handleTasksValidate(filePath) {
     const manager = loadManagerFromFile(filePath);
     const breakdown = manager.getBreakdown();
     console.log(`\u2705 ${filePath}: ${breakdown.totalTasks} tasks parsed successfully`);
-    return ExitCode.SUCCESS;
+    return ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C Validation failed: ${msg}`);
-    return ExitCode.VALIDATION_ERROR;
+    return ExitCode2.VALIDATION_ERROR;
   }
 }
 async function handleTasksList(filePath) {
   try {
     if (!filePath) {
       console.error("\u274C --file <path> is required");
-      return ExitCode.GENERAL_ERROR;
+      return ExitCode2.GENERAL_ERROR;
     }
     const manager = loadManagerFromFile(filePath);
     console.log(manager.toMarkdown());
-    return ExitCode.SUCCESS;
+    return ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 async function handleTasksStats(filePath) {
   try {
     if (!filePath) {
       console.error("\u274C --file <path> is required");
-      return ExitCode.GENERAL_ERROR;
+      return ExitCode2.GENERAL_ERROR;
     }
     const manager = loadManagerFromFile(filePath);
     const b = manager.getBreakdown();
@@ -10522,15 +11918,15 @@ async function handleTasksStats(filePath) {
       `Blocked:   ${b.blockedTasks}`,
       `Pending:   ${b.totalTasks - b.completedTasks - b.blockedTasks}`
     ].join("\n"));
-    return ExitCode.SUCCESS;
+    return ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 async function handleInit(targetPath = ".", name, force) {
-  const initializer = createProjectInitializer();
+  const initializer = createProjectInitializer2();
   const projectName = name ?? "my-project";
   const result = initializer.init({
     projectName,
@@ -10542,7 +11938,7 @@ async function handleInit(targetPath = ".", name, force) {
     for (const err of result.errors) {
       console.error(`\u274C ${err}`);
     }
-    return ExitCode.VALIDATION_ERROR;
+    return ExitCode2.VALIDATION_ERROR;
   }
   console.log(`\u2705 Initialized project "${projectName}" at ${targetPath}`);
   for (const f of result.createdFiles) {
@@ -10570,28 +11966,28 @@ async function handleInit(targetPath = ".", name, force) {
     }
   } catch {
   }
-  return ExitCode.SUCCESS;
+  return ExitCode2.SUCCESS;
 }
 async function handleTrace(sub, args) {
   switch (sub) {
     case "matrix": {
-      const generator = createMatrixGenerator();
+      const generator = createMatrixGenerator2();
       const report = generator.generate([], [], []);
       console.log(generator.toMarkdown(report));
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "validate": {
-      const manager = createTraceabilityManager();
+      const manager = createTraceabilityManager2();
       console.log(manager.toMarkdown());
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "impact": {
       const targetId = args[0];
       if (!targetId) {
         console.error("\u274C Usage: musubix trace impact <target-id>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
-      const analyzer = createImpactAnalyzer();
+      const analyzer = createImpactAnalyzer2();
       const result = analyzer.analyze(targetId, []);
       console.log(`Impact analysis for ${targetId}:`);
       console.log(`  Level: ${result.level}`);
@@ -10599,15 +11995,15 @@ async function handleTrace(sub, args) {
       for (const id of result.affectedIds) {
         console.log(`    - ${id}`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log(showHelp("trace"));
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleTraceVerify() {
-  const validator = createTraceabilityValidator();
+  const validator = createTraceabilityValidator2();
   const report = validator.validateCoverage([], [], [], []);
   console.log(`Coverage: ${report.coveragePercent}%`);
   console.log(`Requirements: ${report.coveredRequirements}/${report.totalRequirements}`);
@@ -10619,7 +12015,7 @@ async function handleTraceVerify() {
   } else {
     console.log("No gaps found");
   }
-  return ExitCode.SUCCESS;
+  return ExitCode2.SUCCESS;
 }
 async function handlePolicy(sub, args) {
   switch (sub) {
@@ -10635,34 +12031,34 @@ async function handlePolicy(sub, args) {
       if (report.violations.length > 0) {
         console.log(`Violations: ${report.violations.length}`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "list": {
       console.log("Constitution Articles:");
       for (const art of CONSTITUTION_ARTICLES) {
         console.log(`  Article ${art.article}: ${art.name} \u2014 ${art.description}`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "info": {
       const articleNum = parseInt(args[0], 10);
       if (isNaN(articleNum)) {
         console.error("\u274C Usage: musubix policy info <article-number>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const article = CONSTITUTION_ARTICLES.find((a) => a.article === articleNum);
       if (!article) {
         console.error(`\u274C Unknown article: ${articleNum}`);
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       console.log(`Article ${article.article}: ${article.name}`);
       console.log(`  Policy ID: ${article.policyId}`);
       console.log(`  ${article.description}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log(showHelp("policy"));
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleOntology(sub) {
@@ -10678,16 +12074,16 @@ async function handleOntology(sub) {
           console.log(`  - ${JSON.stringify(v)}`);
         }
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "stats": {
       const store = createOntologyStore();
       console.log(`Triples: ${store.size()}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log(showHelp("ontology"));
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 var EXT_TO_LANG = {
@@ -10714,7 +12110,7 @@ async function handleCodegraph(sub, args) {
       const targetPath = args[0];
       if (!targetPath) {
         console.error("\u274C Usage: musubix cg index <path>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       try {
         const parser = createASTParser();
@@ -10723,7 +12119,7 @@ async function handleCodegraph(sub, args) {
         const lang = EXT_TO_LANG[ext];
         if (!lang) {
           console.error(`\u274C Unsupported file extension: .${ext}`);
-          return ExitCode.GENERAL_ERROR;
+          return ExitCode2.GENERAL_ERROR;
         }
         const nodes = parser.parse(content, lang);
         const engine = createGraphEngine();
@@ -10743,21 +12139,21 @@ async function handleCodegraph(sub, args) {
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         console.error(`\u274C ${msg}`);
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "search": {
       const query = args[0];
       if (!query) {
         console.error("\u274C Usage: musubix cg search <query>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const engine = createGraphEngine();
       const search = new GraphRAGSearch(engine);
       const results = search.globalSearch(query);
       console.log(`Results for "${query}": ${results.length} found`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "stats": {
       const engine = createGraphEngine();
@@ -10765,7 +12161,7 @@ async function handleCodegraph(sub, args) {
       console.log(`Nodes: ${stats.nodeCount}`);
       console.log(`Edges: ${stats.edgeCount}`);
       console.log(`Languages: ${[...stats.languages].join(", ") || "none"}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "languages": {
       const parser = createASTParser();
@@ -10774,18 +12170,18 @@ async function handleCodegraph(sub, args) {
       for (const lang of langs) {
         console.log(`  - ${lang}`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log(showHelp("cg"));
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleSecurity(filePath) {
   try {
     if (!existsSync(filePath)) {
       console.error(`\u274C File not found: ${filePath}`);
-      return ExitCode.GENERAL_ERROR;
+      return ExitCode2.GENERAL_ERROR;
     }
     const code = readFileSync(filePath, "utf-8");
     const secrets = createSecretDetector();
@@ -10815,11 +12211,11 @@ async function handleSecurity(filePath) {
         }
       }
     }
-    return ExitCode.SUCCESS;
+    return ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 async function handleWorkflow(sub, args) {
@@ -10835,36 +12231,36 @@ async function handleWorkflow(sub, args) {
         const icon = approved ? "\u2705" : "\u2B1C";
         console.log(`  ${icon} ${phase}`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "approve": {
       const phase = args[0];
       if (!phase) {
         console.error("\u274C Usage: musubix workflow approve <phase>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       tracker.approve(phase);
       console.log(`\u2705 Approved: ${phase}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "transition": {
       const phase = args[0];
       if (!phase) {
         console.error("\u274C Usage: musubix workflow transition <phase>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const result = await controller.transitionTo(phase);
       if (result.success) {
         console.log(`\u2705 Transitioned: ${result.fromPhase} \u2192 ${result.toPhase}`);
       } else {
         console.error(`\u274C Transition failed: ${result.errors.join(", ")}`);
-        return ExitCode.PHASE_BLOCKED;
+        return ExitCode2.PHASE_BLOCKED;
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log(showHelp("workflow"));
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleStatus() {
@@ -10879,14 +12275,14 @@ Constitution: ${CONSTITUTION_ARTICLES.length} articles`);
   for (const art of CONSTITUTION_ARTICLES) {
     console.log(`  Article ${art.article}: ${art.name}`);
   }
-  return ExitCode.SUCCESS;
+  return ExitCode2.SUCCESS;
 }
 async function handleReqValidate(filePath) {
   try {
     const content = readFileSync(filePath, "utf-8");
-    const parser = new MarkdownEARSParser();
+    const parser = new MarkdownEARSParser2();
     const requirements = parser.parse(content);
-    const validator = createEARSValidator();
+    const validator = createEARSValidator2();
     let hasIssues = false;
     for (const req of requirements) {
       const analysis = validator.analyze(req.text);
@@ -10902,42 +12298,42 @@ async function handleReqValidate(filePath) {
     if (requirements.length === 0) {
       console.log("No requirements found in file");
     }
-    return hasIssues ? ExitCode.VALIDATION_ERROR : ExitCode.SUCCESS;
+    return hasIssues ? ExitCode2.VALIDATION_ERROR : ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 async function handleReqWizard() {
   try {
-    const wizard = createRequirementWizard();
+    const wizard = createRequirementWizard2();
     const steps = wizard.getSteps();
     console.log("\u{1F9D9} Requirements Creation Wizard");
     console.log("Interactive mode \u2014 follow these steps to create a requirement:\n");
     for (let i = 0; i < steps.length; i++) {
       console.log(`  ${i + 1}. ${steps[i].prompt}`);
     }
-    return ExitCode.SUCCESS;
+    return ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 var _interviewer = null;
 function getInterviewer() {
   if (!_interviewer)
-    _interviewer = createRequirementsInterviewer();
+    _interviewer = createRequirementsInterviewer2();
   return _interviewer;
 }
 async function handleReqInterview(args) {
   try {
     const interviewer = getInterviewer();
     if (args["reset"] === true) {
-      _interviewer = createRequirementsInterviewer();
+      _interviewer = createRequirementsInterviewer2();
       console.log("\u{1F504} Interview state reset.");
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     if (args["state"] === true) {
       const state = interviewer.getState();
@@ -10951,14 +12347,14 @@ async function handleReqInterview(args) {
       if (state.currentQuestion) {
         console.log(`  Current question: ${state.currentQuestion.question}`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     if (args["generate"] === true) {
       const state = interviewer.getState();
-      const generator = createRequirementsDocGenerator();
+      const generator = createRequirementsDocGenerator2();
       const doc = generator.generate(state.context);
       console.log(doc.markdown);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     if (args["answer"] === true || typeof args["answer"] === "string") {
       const positionalArgs2 = args["args"] ?? [];
@@ -10966,7 +12362,7 @@ async function handleReqInterview(args) {
       const response = typeof args["answer"] === "string" ? positionalArgs2.join(" ") : positionalArgs2.slice(1).join(" ");
       if (!questionId || !response) {
         console.error("\u274C Usage: musubix req:interview --answer <question-id> <response>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const result2 = interviewer.answer(questionId, response);
       if (result2.status === "complete") {
@@ -10979,7 +12375,7 @@ async function handleReqInterview(args) {
           console.log(`   \u{1F4A1} ${result2.question.hint}`);
         }
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     const positionalArgs = args["args"] ?? [];
     const inputText = args["subcommand"] ? [args["subcommand"], ...positionalArgs].join(" ") : positionalArgs.join(" ");
@@ -10992,12 +12388,12 @@ async function handleReqInterview(args) {
       console.log("  musubix req:interview --state                  Show interview state");
       console.log("  musubix req:interview --generate               Generate requirements doc");
       console.log("  musubix req:interview --reset                  Reset interview");
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     const result = interviewer.analyzeInput(inputText);
     if (result.status === "complete") {
       console.log("\u2705 Sufficient info gathered! Generating requirements...");
-      const generator = createRequirementsDocGenerator();
+      const generator = createRequirementsDocGenerator2();
       const doc = generator.generate(result.context);
       console.log(doc.markdown);
     } else {
@@ -11010,19 +12406,19 @@ async function handleReqInterview(args) {
         console.log(`   \u9078\u629E\u80A2: ${result.question.choices.join(" | ")}`);
       }
     }
-    return ExitCode.SUCCESS;
+    return ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 async function handleDesignGenerate(filePath) {
   try {
     const content = readFileSync(filePath, "utf-8");
-    const parser = new MarkdownEARSParser();
+    const parser = new MarkdownEARSParser2();
     const requirements = parser.parse(content);
-    const generator = createDesignGenerator();
+    const generator = createDesignGenerator2();
     const mapped = requirements.map((r) => ({
       id: r.id,
       title: r.title,
@@ -11036,18 +12432,18 @@ async function handleDesignGenerate(filePath) {
 ## ${section.title}`);
       console.log(section.description);
     }
-    return ExitCode.SUCCESS;
+    return ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 async function handleDesignC4(filePath, level = "context") {
   try {
     const content = readFileSync(filePath, "utf-8");
     const data = JSON.parse(content);
-    const generator = createC4ModelGenerator();
+    const generator = createC4ModelGenerator2();
     for (const el of data.elements ?? []) {
       generator.addElement(el);
     }
@@ -11058,61 +12454,61 @@ async function handleDesignC4(filePath, level = "context") {
     const diagram = generator.generateDiagram(c4Level, data.title ?? "System");
     const mermaid = generator.toMermaid(diagram);
     console.log(mermaid);
-    return ExitCode.SUCCESS;
+    return ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 async function handleDesignVerify(filePath) {
   try {
     const content = readFileSync(filePath, "utf-8");
     const design = JSON.parse(content);
-    const validator = createSOLIDValidator();
+    const validator = createSOLIDValidator2();
     const report = validator.validate(design);
     if (report.violations.length === 0) {
       console.log("\u2705 All SOLID principles satisfied");
       console.log(`Score: ${report.score}/100`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     console.log(`SOLID score: ${report.score}/100`);
     for (const v of report.violations) {
       console.log(`  \u26A0 [${v.principle}] ${v.message}`);
     }
-    return ExitCode.VALIDATION_ERROR;
+    return ExitCode2.VALIDATION_ERROR;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 async function handleCodegen(name, type = "class") {
   try {
-    const generator = createCodeGenerator();
+    const generator = createCodeGenerator2();
     const result = generator.generate({
       templateType: type,
       name
     });
     console.log(result.code);
-    return ExitCode.SUCCESS;
+    return ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 async function handleTestGen(filePath) {
   try {
     const content = readFileSync(filePath, "utf-8");
-    const generator = createUnitTestGenerator();
+    const generator = createUnitTestGenerator2();
     const suite = generator.generate(content, "unit");
     console.log(suite.code);
-    return ExitCode.SUCCESS;
+    return ExitCode2.SUCCESS;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\u274C ${msg}`);
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
 }
 async function handleSkills(sub, args) {
@@ -11129,13 +12525,13 @@ async function handleSkills(sub, args) {
           console.log(`  ${skill.metadata.name}`);
         }
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "validate": {
       const path = args[0];
       if (!path) {
         console.error("\u274C Usage: musubix skills validate <path>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       try {
         const content = readFileSync(path, "utf-8");
@@ -11150,32 +12546,32 @@ async function handleSkills(sub, args) {
         if (errors.length > 0) {
           for (const e of errors)
             console.error(`  \u274C ${e}`);
-          return ExitCode.VALIDATION_ERROR;
+          return ExitCode2.VALIDATION_ERROR;
         }
         console.log(`\u2705 Skill definition valid: ${definition["name"]}`);
-        return ExitCode.SUCCESS;
+        return ExitCode2.SUCCESS;
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         console.error(`\u274C ${msg}`);
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
     }
     case "create": {
       const name = args[0];
       if (!name) {
         console.error("\u274C Usage: musubix skills create <name>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       console.log(`\u2705 Scaffolded skill: ${name}`);
       console.log(`  ${name}/`);
       console.log(`  \u251C\u2500\u2500 skill.json`);
       console.log(`  \u251C\u2500\u2500 index.ts`);
       console.log(`  \u2514\u2500\u2500 tests/`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log("Usage: musubix skills <list|validate|create> [args]");
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleKnowledge(sub, args, flags) {
@@ -11187,36 +12583,36 @@ async function handleKnowledge(sub, args, flags) {
       const id = args[0];
       if (!id) {
         console.error("\u274C Usage: musubix knowledge get <id>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const entity = store.getEntity(id);
       if (!entity) {
         console.error(`\u274C Entity not found: ${id}`);
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       console.log(JSON.stringify(entity, null, 2));
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "put": {
       const id = args[0];
       const type = args[1];
       if (!id || !type) {
         console.error("\u274C Usage: musubix knowledge put <id> <type>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       store.putEntity({ id, type, properties: {} });
       console.log(`\u2705 Stored entity: ${id} (${type})`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "delete": {
       const id = args[0];
       if (!id) {
         console.error("\u274C Usage: musubix knowledge delete <id>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       store.deleteEntity(id);
       console.log(`\u2705 Deleted entity: ${id}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "link": {
       const from = args[0];
@@ -11224,61 +12620,61 @@ async function handleKnowledge(sub, args, flags) {
       const to = args[2];
       if (!from || !rel || !to) {
         console.error("\u274C Usage: musubix knowledge link <from> <rel> <to>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       store.addRelation({ from, to, type: rel });
       console.log(`\u2705 Linked: ${from} \u2014[${rel}]\u2192 ${to}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "query": {
       const filter = args[0];
       if (!filter) {
         console.error("\u274C Usage: musubix knowledge query <filter>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const results = await store.query({ type: filter });
       console.log(`Results: ${results.length} entities`);
       for (const e of results) {
         console.log(`  ${e.id} (${e.type})`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "traverse": {
       const startId = args[0];
       if (!startId) {
         console.error("\u274C Usage: musubix knowledge traverse <startId>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const traversed = await store.traverse(startId);
       console.log(`Traversal from ${startId}: ${traversed.length} nodes`);
       for (const node of traversed) {
         console.log(`  ${node.id} (${node.type})`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "search": {
       const term = args[0];
       if (!term) {
         console.error("\u274C Usage: musubix knowledge search <term>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const results = await store.search(term);
       console.log(`Search "${term}": ${results.length} results`);
       for (const e of results) {
         console.log(`  ${e.id} (${e.type})`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "stats": {
       const stats = store.getStats();
       console.log(`Entities: ${stats.entityCount}`);
       console.log(`Relations: ${stats.relationCount}`);
       console.log(`Types: ${Object.keys(stats.types).join(", ") || "none"}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log("Usage: musubix knowledge <get|put|delete|link|query|traverse|search|stats> [args]");
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleDecision(sub, args, flags) {
@@ -11290,11 +12686,11 @@ async function handleDecision(sub, args, flags) {
       const title = args[0];
       if (!title) {
         console.error("\u274C Usage: musubix decision create <title>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const adr = await manager.create({ title, context: "", decision: "", consequences: "" });
       console.log(`\u2705 Created ADR: ${adr.id} \u2014 ${adr.title}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "list": {
       const adrs = await manager.list();
@@ -11306,66 +12702,66 @@ async function handleDecision(sub, args, flags) {
           console.log(`  ${adr.id}: ${adr.title} [${adr.status}]`);
         }
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "get": {
       const id = args[0];
       if (!id) {
         console.error("\u274C Usage: musubix decision get <id>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const adr = await manager.get(id);
       if (!adr) {
         console.error(`\u274C ADR not found: ${id}`);
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       console.log(`${adr.id}: ${adr.title}`);
       console.log(`Status: ${adr.status}`);
       console.log(`Context: ${adr.context}`);
       console.log(`Decision: ${adr.decision}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "accept": {
       const id = args[0];
       if (!id) {
         console.error("\u274C Usage: musubix decision accept <id>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       await manager.accept(id);
       console.log(`\u2705 Accepted: ${id}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "deprecate": {
       const id = args[0];
       if (!id) {
         console.error("\u274C Usage: musubix decision deprecate <id>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       await manager.deprecate(id);
       console.log(`\u2705 Deprecated: ${id}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "search": {
       const query = args[0];
       if (!query) {
         console.error("\u274C Usage: musubix decision search <query>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const results = await manager.search(query);
       console.log(`Search "${query}": ${results.length} results`);
       for (const adr of results) {
         console.log(`  ${adr.id}: ${adr.title} [${adr.status}]`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "index": {
       const index = await manager.generateIndex();
       console.log(index);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log("Usage: musubix decision <create|list|get|accept|deprecate|search|index> [args]");
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleDeepResearch(sub, args) {
@@ -11376,62 +12772,62 @@ async function handleDeepResearch(sub, args) {
       const question = args[0];
       if (!question) {
         console.error("\u274C Usage: musubix deep-research query <question>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const result = engine.research({ topic: question, depth: "medium" }, []);
       console.log(`Question: ${question}`);
       console.log(`Confidence: ${result.confidence}`);
       console.log(`Sources: ${result.sources.length}`);
       console.log(`Answer: ${result.summary}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "iterative": {
       const question = args[0];
       if (!question) {
         console.error("\u274C Usage: musubix deep-research iterative <question>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const result = engine.researchIterative({ topic: question, depth: "medium" }, () => []);
       console.log(`Iterative research: ${question}`);
       console.log(`Confidence: ${result.confidence}`);
       console.log(`Answer: ${result.summary}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "evidence": {
       const topic = args[0];
       if (!topic) {
         console.error("\u274C Usage: musubix deep-research evidence <topic>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const evidence = engine.generateEvidenceChain(topic);
       console.log(`Evidence for "${topic}": ${evidence.length} items`);
       for (const e of evidence) {
         console.log(`  - ${JSON.stringify(e)}`);
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log("Usage: musubix deep-research <query|iterative|evidence> [args]");
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleRepl() {
-  const { ReplEngine: ReplEngine2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
-  const repl = new ReplEngine2();
+  const { ReplEngine: ReplEngine22 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const repl = new ReplEngine22();
   console.log("MUSUBIX2 Interactive REPL");
   console.log('Type "help" for commands, "exit" to quit.\n');
   console.log(repl.getPrompt());
-  return ExitCode.SUCCESS;
+  return ExitCode2.SUCCESS;
 }
 async function handleScaffold(sub, args) {
-  const { createProjectInitializer: createProjectInitializer2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
-  const initializer = createProjectInitializer2();
+  const { createProjectInitializer: createProjectInitializer22 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const initializer = createProjectInitializer22();
   switch (sub) {
     case "project": {
       const name = args[0];
       if (!name) {
         console.error("\u274C Usage: musubix scaffold project <name>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const result = initializer.init({
         projectName: name,
@@ -11446,15 +12842,15 @@ async function handleScaffold(sub, args) {
       } else {
         for (const e of result.errors)
           console.error(`\u274C ${e}`);
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "package": {
       const name = args[0];
       if (!name) {
         console.error("\u274C Usage: musubix scaffold package <name>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       console.log(`\u2705 Scaffolded package: ${name}`);
       console.log(`  packages/${name}/`);
@@ -11462,34 +12858,34 @@ async function handleScaffold(sub, args) {
       console.log(`  \u251C\u2500\u2500 tsconfig.json`);
       console.log(`  \u251C\u2500\u2500 src/index.ts`);
       console.log(`  \u2514\u2500\u2500 tests/`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "skill": {
       const name = args[0];
       if (!name) {
         console.error("\u274C Usage: musubix scaffold skill <name>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       console.log(`\u2705 Scaffolded skill: ${name}`);
       console.log(`  skills/${name}/`);
       console.log(`  \u251C\u2500\u2500 skill.json`);
       console.log(`  \u251C\u2500\u2500 index.ts`);
       console.log(`  \u2514\u2500\u2500 tests/`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log("Usage: musubix scaffold <project|package|skill> <name>");
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleExplain(input) {
-  const { ExplanationGenerator: ExplanationGenerator2, ReasoningChainRecorder: ReasoningChainRecorder2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const { ExplanationGenerator: ExplanationGenerator22, ReasoningChainRecorder: ReasoningChainRecorder22 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
   if (!input) {
     console.error("\u274C Usage: musubix explain <file-or-snippet>");
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
-  const recorder = new ReasoningChainRecorder2();
-  const generator = new ExplanationGenerator2();
+  const recorder = new ReasoningChainRecorder22();
+  const generator = new ExplanationGenerator22();
   let code;
   if (existsSync(input)) {
     code = readFileSync(input, "utf-8");
@@ -11503,7 +12899,7 @@ async function handleExplain(input) {
   const explanation = generator.generate(chain);
   console.log("=== Code Explanation ===\n");
   console.log(explanation);
-  return ExitCode.SUCCESS;
+  return ExitCode2.SUCCESS;
 }
 async function handleLearn(sub, args) {
   const { createLibraryLearner: createLibraryLearner2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
@@ -11513,7 +12909,7 @@ async function handleLearn(sub, args) {
       const path = args[0];
       if (!path) {
         console.error("\u274C Usage: musubix learn analyze <path>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       try {
         const content = readFileSync(path, "utf-8");
@@ -11526,9 +12922,9 @@ async function handleLearn(sub, args) {
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         console.error(`\u274C ${msg}`);
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "patterns": {
       const patterns = learner.getPatterns();
@@ -11540,7 +12936,7 @@ async function handleLearn(sub, args) {
           console.log(`  - ${p.name}: ${p.abstraction}`);
         }
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "suggest": {
       const code = args[0] ?? "";
@@ -11553,11 +12949,11 @@ async function handleLearn(sub, args) {
           console.log(`  - ${s.name}: ${s.abstraction}`);
         }
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log("Usage: musubix learn <analyze|patterns|suggest> [args]");
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleSynthesis(sub, args) {
@@ -11576,7 +12972,7 @@ async function handleSynthesis(sub, args) {
       } else {
         console.log("  No rule could be synthesized");
       }
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "dsl": {
       const { createDSLBuilder: createDSLBuilder2 } = await Promise.resolve().then(() => (init_dist7(), dist_exports7));
@@ -11584,13 +12980,13 @@ async function handleSynthesis(sub, args) {
       const input = args[0];
       if (!input) {
         console.error("\u274C Usage: musubix synthesis dsl <input>");
-        return ExitCode.GENERAL_ERROR;
+        return ExitCode2.GENERAL_ERROR;
       }
       const result = builder.execute(input);
       console.log(`DSL output:`);
       console.log(`  Input: ${input}`);
       console.log(`  Result: ${result}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     case "version-space": {
       const { createVersionSpaceManager: createVersionSpaceManager2 } = await Promise.resolve().then(() => (init_dist7(), dist_exports7));
@@ -11598,26 +12994,26 @@ async function handleSynthesis(sub, args) {
       const spaces = manager.getSpaces();
       console.log(`Version space:`);
       console.log(`  Spaces: ${spaces.size}`);
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
     }
     default:
       console.log("Usage: musubix synthesis <fromExamples|dsl|version-space> [args]");
-      return ExitCode.SUCCESS;
+      return ExitCode2.SUCCESS;
   }
 }
 async function handleWatch(pattern) {
-  const { createFileWatcher: createFileWatcher2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const { createFileWatcher: createFileWatcher22 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
   if (!pattern) {
     console.error("\u274C Usage: musubix watch <glob-pattern>");
-    return ExitCode.GENERAL_ERROR;
+    return ExitCode2.GENERAL_ERROR;
   }
-  const watcher = createFileWatcher2();
+  const watcher = createFileWatcher22();
   console.log(`\u{1F441} Watching: ${pattern}`);
   console.log("Press Ctrl+C to stop.\n");
   watcher.on("modify", (event) => {
     console.log(`  [${event.type}] ${event.path}`);
   });
-  return ExitCode.SUCCESS;
+  return ExitCode2.SUCCESS;
 }
 function getDefaultCommands() {
   return [
@@ -12036,9 +13432,7 @@ function createCLIDispatcher() {
   dispatcher.registerBatch(getDefaultCommands());
   return dispatcher;
 }
-
-// dist/index.js
-var MUSUBI_VERSION = "0.3.6";
+var MUSUBI_VERSION = "0.3.8";
 function createEARSPipeline() {
   const validator = createEARSValidator();
   const parser = createMarkdownEARSParser();